// required for old g++ to compile PRId64 macros, see
// https://github.com/pytorch/pytorch/issues/3571
// for context
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

// an external backend might generate file within its code tree
// and check all the source files within the tree with clang-format.
// so, disable it since the backend might have a different config.
// clang-format off

// NOTE: This condition is true for all PyTorch internal libraries, it
//       just excludes external projects such as torch_xla which
//       re-use some of the PyTorch codegen machinery.
#if defined(CAFFE2_BUILD_MAIN_LIB)        || \
    defined(TORCH_CUDA_BUILD_MAIN_LIB)    || \
    defined(TORCH_HIP_BUILD_MAIN_LIB)     || \
    defined(TORCH_XPU_BUILD_MAIN_LIB)     || \
    defined(TORCH_CUDA_CU_BUILD_MAIN_LIB) || \
    defined(TORCH_CUDA_CPP_BUILD_MAIN_LIB)
#define TORCH_ASSERT_ONLY_METHOD_OPERATORS
#endif

// @generated by torchgen/gen.py from RegisterDispatchKey.cpp

#include <c10/core/TensorImpl.h>
#include <c10/core/Allocator.h>
#include <ATen/DeviceGuard.h>
#include <ATen/NamedTensorUtils.h>
#include <ATen/Utils.h>
#include <ATen/WrapDimUtils.h>
#include <ATen/Dispatch.h>
#include <c10/util/ExclusivelyOwned.h>
#include <c10/util/Half.h>
#include <c10/core/UndefinedTensorImpl.h>
#include <optional>
#include <ATen/Tensor.h>
#include <ATen/native/Resize.h>

#include <cstddef>
#include <functional>
#include <memory>
#include <utility>

#include <ATen/Config.h>
#include <ATen/core/op_registration/adaption.h>
#include <torch/library.h>


#include <ATen/ops/as_strided_native.h>
#include <ATen/ops/empty.h>
#include <ATen/ops/empty_strided.h>
#include <ATen/ops/_copy_from_and_resize.h>
#include <ATen/ops/_copy_from.h>
#include <c10/macros/Macros.h>
#include <ATen/ops/_adaptive_avg_pool2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_adaptive_avg_pool2d_backward_native.h>
#include <ATen/ops/_adaptive_avg_pool2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_adaptive_avg_pool2d_native.h>
#include <ATen/ops/_adaptive_avg_pool3d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_adaptive_avg_pool3d_backward_native.h>
#include <ATen/ops/_adaptive_avg_pool3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_adaptive_avg_pool3d_native.h>
#include <ATen/ops/_add_relu_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_add_relu_native.h>
#include <ATen/ops/_aminmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_aminmax_native.h>
#include <ATen/ops/_amp_foreach_non_finite_check_and_unscale_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_amp_foreach_non_finite_check_and_unscale_native.h>
#include <ATen/ops/_amp_update_scale_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_amp_update_scale_native.h>
#include <ATen/ops/_assert_scalar_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_assert_scalar_native.h>
#include <ATen/ops/_assert_tensor_metadata_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_assert_tensor_metadata_native.h>
#include <ATen/ops/_batch_norm_no_update_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_batch_norm_no_update_native.h>
#include <ATen/ops/_batch_norm_with_update_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_batch_norm_with_update_native.h>
#include <ATen/ops/_cdist_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cdist_backward_native.h>
#include <ATen/ops/_cdist_forward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cdist_forward_native.h>
#include <ATen/ops/_cholesky_solve_helper_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cholesky_solve_helper_native.h>
#include <ATen/ops/_chunk_cat_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_chunk_cat_native.h>
#include <ATen/ops/_coalesce_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_coalesce_native.h>
#include <ATen/ops/_coalesced_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_coalesced_native.h>
#include <ATen/ops/_conj_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_conj_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_conj_copy_native.h>
#include <ATen/ops/_conj_native.h>
#include <ATen/ops/_conj_physical_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_conj_physical_native.h>
#include <ATen/ops/_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_convolution_native.h>
#include <ATen/ops/_copy_from_and_resize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_copy_from_and_resize_native.h>
#include <ATen/ops/_copy_from_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_copy_from_native.h>
#include <ATen/ops/_ctc_loss_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_ctc_loss_backward_native.h>
#include <ATen/ops/_ctc_loss_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_ctc_loss_native.h>
#include <ATen/ops/_cudnn_ctc_loss_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cudnn_ctc_loss_native.h>
#include <ATen/ops/_cudnn_init_dropout_state_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cudnn_init_dropout_state_native.h>
#include <ATen/ops/_cudnn_rnn_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cudnn_rnn_backward_native.h>
#include <ATen/ops/_cudnn_rnn_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cudnn_rnn_flatten_weight_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_cudnn_rnn_flatten_weight_native.h>
#include <ATen/ops/_cudnn_rnn_native.h>
#include <ATen/ops/_dirichlet_grad_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_dirichlet_grad_native.h>
#include <ATen/ops/_efficientzerotensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_efficientzerotensor_native.h>
#include <ATen/ops/_embedding_bag_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_embedding_bag_dense_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_embedding_bag_dense_backward_native.h>
#include <ATen/ops/_embedding_bag_forward_only_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_embedding_bag_forward_only_native.h>
#include <ATen/ops/_embedding_bag_native.h>
#include <ATen/ops/_embedding_bag_per_sample_weights_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_embedding_bag_per_sample_weights_backward_native.h>
#include <ATen/ops/_empty_affine_quantized_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_empty_affine_quantized_native.h>
#include <ATen/ops/_empty_per_channel_affine_quantized_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_empty_per_channel_affine_quantized_native.h>
#include <ATen/ops/_euclidean_dist_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_euclidean_dist_native.h>
#include <ATen/ops/_fake_quantize_learnable_per_channel_affine_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fake_quantize_learnable_per_channel_affine_native.h>
#include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fake_quantize_learnable_per_tensor_affine_native.h>
#include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_native.h>
#include <ATen/ops/_foobar_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foobar_native.h>
#include <ATen/ops/_foreach_abs_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_abs_native.h>
#include <ATen/ops/_foreach_acos_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_acos_native.h>
#include <ATen/ops/_foreach_add_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_add_native.h>
#include <ATen/ops/_foreach_addcdiv_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_addcdiv_native.h>
#include <ATen/ops/_foreach_addcmul_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_addcmul_native.h>
#include <ATen/ops/_foreach_asin_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_asin_native.h>
#include <ATen/ops/_foreach_atan_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_atan_native.h>
#include <ATen/ops/_foreach_ceil_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_ceil_native.h>
#include <ATen/ops/_foreach_clamp_max_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_clamp_max_native.h>
#include <ATen/ops/_foreach_clamp_min_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_clamp_min_native.h>
#include <ATen/ops/_foreach_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_copy_native.h>
#include <ATen/ops/_foreach_cos_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_cos_native.h>
#include <ATen/ops/_foreach_cosh_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_cosh_native.h>
#include <ATen/ops/_foreach_div_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_div_native.h>
#include <ATen/ops/_foreach_erf_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_erf_native.h>
#include <ATen/ops/_foreach_erfc_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_erfc_native.h>
#include <ATen/ops/_foreach_exp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_exp_native.h>
#include <ATen/ops/_foreach_expm1_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_expm1_native.h>
#include <ATen/ops/_foreach_floor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_floor_native.h>
#include <ATen/ops/_foreach_frac_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_frac_native.h>
#include <ATen/ops/_foreach_lerp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_lerp_native.h>
#include <ATen/ops/_foreach_lgamma_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_lgamma_native.h>
#include <ATen/ops/_foreach_log10_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_log10_native.h>
#include <ATen/ops/_foreach_log1p_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_log1p_native.h>
#include <ATen/ops/_foreach_log2_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_log2_native.h>
#include <ATen/ops/_foreach_log_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_log_native.h>
#include <ATen/ops/_foreach_max_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_max_native.h>
#include <ATen/ops/_foreach_maximum_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_maximum_native.h>
#include <ATen/ops/_foreach_minimum_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_minimum_native.h>
#include <ATen/ops/_foreach_mul_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_mul_native.h>
#include <ATen/ops/_foreach_neg_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_neg_native.h>
#include <ATen/ops/_foreach_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_norm_native.h>
#include <ATen/ops/_foreach_pow_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_pow_native.h>
#include <ATen/ops/_foreach_reciprocal_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_reciprocal_native.h>
#include <ATen/ops/_foreach_round_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_round_native.h>
#include <ATen/ops/_foreach_rsqrt_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_rsqrt_native.h>
#include <ATen/ops/_foreach_sigmoid_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sigmoid_native.h>
#include <ATen/ops/_foreach_sign_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sign_native.h>
#include <ATen/ops/_foreach_sin_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sin_native.h>
#include <ATen/ops/_foreach_sinh_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sinh_native.h>
#include <ATen/ops/_foreach_sqrt_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sqrt_native.h>
#include <ATen/ops/_foreach_sub_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_sub_native.h>
#include <ATen/ops/_foreach_tan_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_tan_native.h>
#include <ATen/ops/_foreach_tanh_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_tanh_native.h>
#include <ATen/ops/_foreach_trunc_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_trunc_native.h>
#include <ATen/ops/_foreach_zero_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_foreach_zero_native.h>
#include <ATen/ops/_functional_assert_scalar_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_functional_assert_scalar_native.h>
#include <ATen/ops/_functional_sym_constrain_range_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_functional_sym_constrain_range_for_size_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_functional_sym_constrain_range_for_size_native.h>
#include <ATen/ops/_functional_sym_constrain_range_native.h>
#include <ATen/ops/_fused_adagrad_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_adagrad_native.h>
#include <ATen/ops/_fused_adam_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_adam_native.h>
#include <ATen/ops/_fused_adamw_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_adamw_native.h>
#include <ATen/ops/_fused_dropout_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_dropout_native.h>
#include <ATen/ops/_fused_moving_avg_obs_fq_helper_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_moving_avg_obs_fq_helper_native.h>
#include <ATen/ops/_fused_sgd_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fused_sgd_native.h>
#include <ATen/ops/_fw_primal_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fw_primal_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_fw_primal_copy_native.h>
#include <ATen/ops/_fw_primal_native.h>
#include <ATen/ops/_grid_sampler_2d_cpu_fallback_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_grid_sampler_2d_cpu_fallback_native.h>
#include <ATen/ops/_has_same_storage_numel_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_has_same_storage_numel_native.h>
#include <ATen/ops/_histogramdd_bin_edges_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_histogramdd_bin_edges_native.h>
#include <ATen/ops/_histogramdd_from_bin_cts_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_histogramdd_from_bin_cts_native.h>
#include <ATen/ops/_histogramdd_from_bin_tensors_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_histogramdd_from_bin_tensors_native.h>
#include <ATen/ops/_index_put_impl_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_index_put_impl_native.h>
#include <ATen/ops/_indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_indices_copy_native.h>
#include <ATen/ops/_is_all_true_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_is_all_true_native.h>
#include <ATen/ops/_is_any_true_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_is_any_true_native.h>
#include <ATen/ops/_lazy_clone_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_lazy_clone_native.h>
#include <ATen/ops/_linalg_check_errors_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_linalg_check_errors_native.h>
#include <ATen/ops/_lstm_mps_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_lstm_mps_native.h>
#include <ATen/ops/_make_dual_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_make_dual_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_make_dual_copy_native.h>
#include <ATen/ops/_make_dual_native.h>
#include <ATen/ops/_make_per_channel_quantized_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_make_per_channel_quantized_tensor_native.h>
#include <ATen/ops/_make_per_tensor_quantized_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_make_per_tensor_quantized_tensor_native.h>
#include <ATen/ops/_masked_scale_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_masked_scale_native.h>
#include <ATen/ops/_masked_softmax_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_masked_softmax_backward_native.h>
#include <ATen/ops/_masked_softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_masked_softmax_native.h>
#include <ATen/ops/_mkldnn_reshape_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_mkldnn_reshape_native.h>
#include <ATen/ops/_mkldnn_transpose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_mkldnn_transpose_native.h>
#include <ATen/ops/_mps_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_mps_convolution_native.h>
#include <ATen/ops/_mps_convolution_transpose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_mps_convolution_transpose_native.h>
#include <ATen/ops/_native_batch_norm_legit_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_native_batch_norm_legit_native.h>
#include <ATen/ops/_native_batch_norm_legit_no_training_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_native_batch_norm_legit_no_training_native.h>
#include <ATen/ops/_native_multi_head_attention_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_native_multi_head_attention_native.h>
#include <ATen/ops/_neg_view_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_neg_view_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_neg_view_copy_native.h>
#include <ATen/ops/_neg_view_native.h>
#include <ATen/ops/_nested_from_padded_and_nested_example_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_from_padded_and_nested_example_native.h>
#include <ATen/ops/_nested_from_padded_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_from_padded_native.h>
#include <ATen/ops/_nested_get_values_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_get_values_copy_native.h>
#include <ATen/ops/_nested_tensor_from_mask_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_tensor_from_mask_native.h>
#include <ATen/ops/_nested_tensor_from_tensor_list_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_tensor_from_tensor_list_native.h>
#include <ATen/ops/_nested_tensor_size_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_tensor_size_native.h>
#include <ATen/ops/_nested_tensor_storage_offsets_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_tensor_storage_offsets_native.h>
#include <ATen/ops/_nested_tensor_strides_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_tensor_strides_native.h>
#include <ATen/ops/_nested_view_from_buffer_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_view_from_buffer_copy_native.h>
#include <ATen/ops/_nested_view_from_jagged_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nested_view_from_jagged_copy_native.h>
#include <ATen/ops/_new_zeros_with_same_feature_meta_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_new_zeros_with_same_feature_meta_native.h>
#include <ATen/ops/_nnpack_spatial_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_nnpack_spatial_convolution_native.h>
#include <ATen/ops/_pack_padded_sequence_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_pack_padded_sequence_native.h>
#include <ATen/ops/_pdist_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_pdist_backward_native.h>
#include <ATen/ops/_pdist_forward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_pdist_forward_native.h>
#include <ATen/ops/_pin_memory_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_pin_memory_native.h>
#include <ATen/ops/_print_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_print_native.h>
#include <ATen/ops/_reshape_alias_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_reshape_alias_copy_native.h>
#include <ATen/ops/_reshape_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_reshape_copy_native.h>
#include <ATen/ops/_resize_output_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_resize_output_native.h>
#include <ATen/ops/_safe_softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_safe_softmax_native.h>
#include <ATen/ops/_sample_dirichlet_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sample_dirichlet_native.h>
#include <ATen/ops/_scaled_dot_product_fused_attention_overrideable_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_scaled_dot_product_fused_attention_overrideable_backward_native.h>
#include <ATen/ops/_scaled_dot_product_fused_attention_overrideable_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_scaled_dot_product_fused_attention_overrideable_native.h>
#include <ATen/ops/_segment_reduce_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_segment_reduce_backward_native.h>
#include <ATen/ops/_slow_conv2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_slow_conv2d_backward_native.h>
#include <ATen/ops/_sparse_addmm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_addmm_native.h>
#include <ATen/ops/_sparse_broadcast_to_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_broadcast_to_copy_native.h>
#include <ATen/ops/_sparse_compressed_tensor_with_dims_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_compressed_tensor_with_dims_native.h>
#include <ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_coo_tensor_with_dims_and_tensors_native.h>
#include <ATen/ops/_sparse_coo_tensor_with_dims_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_coo_tensor_with_dims_native.h>
#include <ATen/ops/_sparse_csr_prod_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_csr_prod_native.h>
#include <ATen/ops/_sparse_csr_sum_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_csr_sum_native.h>
#include <ATen/ops/_sparse_log_softmax_backward_data_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_log_softmax_backward_data_native.h>
#include <ATen/ops/_sparse_log_softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_log_softmax_native.h>
#include <ATen/ops/_sparse_mask_projection_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_mask_projection_native.h>
#include <ATen/ops/_sparse_softmax_backward_data_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_softmax_backward_data_native.h>
#include <ATen/ops/_sparse_softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_softmax_native.h>
#include <ATen/ops/_sparse_sparse_matmul_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_sparse_matmul_native.h>
#include <ATen/ops/_sparse_sum_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_sum_backward_native.h>
#include <ATen/ops/_sparse_sum_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_sparse_sum_native.h>
#include <ATen/ops/_spdiags_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_spdiags_native.h>
#include <ATen/ops/_stack_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_stack_native.h>
#include <ATen/ops/_standard_gamma_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_standard_gamma_grad_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_standard_gamma_grad_native.h>
#include <ATen/ops/_standard_gamma_native.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_native.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_view_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_view_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_view_copy_native.h>
#include <ATen/ops/_test_autograd_multiple_dispatch_view_native.h>
#include <ATen/ops/_test_functorch_fallback_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_functorch_fallback_native.h>
#include <ATen/ops/_test_optional_filled_intlist_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_optional_filled_intlist_native.h>
#include <ATen/ops/_test_optional_floatlist_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_optional_floatlist_native.h>
#include <ATen/ops/_test_optional_intlist_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_optional_intlist_native.h>
#include <ATen/ops/_test_parallel_materialize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_parallel_materialize_native.h>
#include <ATen/ops/_test_warn_in_autograd_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_test_warn_in_autograd_native.h>
#include <ATen/ops/_thnn_fused_gru_cell_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_thnn_fused_gru_cell_backward_native.h>
#include <ATen/ops/_thnn_fused_gru_cell_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_thnn_fused_gru_cell_native.h>
#include <ATen/ops/_thnn_fused_lstm_cell_backward_impl_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_thnn_fused_lstm_cell_backward_impl_native.h>
#include <ATen/ops/_thnn_fused_lstm_cell_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_thnn_fused_lstm_cell_native.h>
#include <ATen/ops/_to_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_copy_native.h>
#include <ATen/ops/_to_dense_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_dense_native.h>
#include <ATen/ops/_to_sparse_bsc_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_sparse_bsc_native.h>
#include <ATen/ops/_to_sparse_bsr_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_sparse_bsr_native.h>
#include <ATen/ops/_to_sparse_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_sparse_csc_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_sparse_csc_native.h>
#include <ATen/ops/_to_sparse_csr_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_to_sparse_csr_native.h>
#include <ATen/ops/_to_sparse_native.h>
#include <ATen/ops/_transform_bias_rescale_qkv_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_transform_bias_rescale_qkv_native.h>
#include <ATen/ops/_transformer_encoder_layer_fwd_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_transformer_encoder_layer_fwd_native.h>
#include <ATen/ops/_trilinear_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_trilinear_native.h>
#include <ATen/ops/_triton_multi_head_attention_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_triton_multi_head_attention_native.h>
#include <ATen/ops/_triton_scaled_dot_attention_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_triton_scaled_dot_attention_native.h>
#include <ATen/ops/_unique2_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unique2_native.h>
#include <ATen/ops/_unique_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unique_native.h>
#include <ATen/ops/_unsafe_index_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unsafe_index_native.h>
#include <ATen/ops/_unsafe_index_put_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unsafe_index_put_native.h>
#include <ATen/ops/_unsafe_masked_index_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unsafe_masked_index_native.h>
#include <ATen/ops/_unsafe_masked_index_put_accumulate_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unsafe_masked_index_put_accumulate_native.h>
#include <ATen/ops/_unsafe_view_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_unsafe_view_native.h>
#include <ATen/ops/_values_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_values_copy_native.h>
#include <ATen/ops/_weight_norm_interface_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_weight_norm_interface_backward_native.h>
#include <ATen/ops/_weight_norm_interface_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/_weight_norm_interface_native.h>
#include <ATen/ops/abs_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/abs_native.h>
#include <ATen/ops/adaptive_avg_pool1d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/adaptive_avg_pool1d_native.h>
#include <ATen/ops/add_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/add_native.h>
#include <ATen/ops/addr_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/addr_native.h>
#include <ATen/ops/affine_grid_generator_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/affine_grid_generator_native.h>
#include <ATen/ops/alias_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/alias_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/alias_copy_native.h>
#include <ATen/ops/alias_native.h>
#include <ATen/ops/all_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/all_native.h>
#include <ATen/ops/allclose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/allclose_native.h>
#include <ATen/ops/any_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/any_native.h>
#include <ATen/ops/arange_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/arange_native.h>
#include <ATen/ops/as_strided_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/as_strided_copy_native.h>
#include <ATen/ops/as_strided_scatter_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/as_strided_scatter_native.h>
#include <ATen/ops/avg_pool1d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/avg_pool1d_native.h>
#include <ATen/ops/bartlett_window_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bartlett_window_native.h>
#include <ATen/ops/batch_norm_backward_elemt_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_backward_elemt_native.h>
#include <ATen/ops/batch_norm_backward_reduce_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_backward_reduce_native.h>
#include <ATen/ops/batch_norm_gather_stats_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_gather_stats_native.h>
#include <ATen/ops/batch_norm_gather_stats_with_counts_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_gather_stats_with_counts_native.h>
#include <ATen/ops/batch_norm_stats_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_stats_native.h>
#include <ATen/ops/batch_norm_update_stats_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/batch_norm_update_stats_native.h>
#include <ATen/ops/bernoulli_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bernoulli_native.h>
#include <ATen/ops/binary_cross_entropy_with_logits_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/binary_cross_entropy_with_logits_native.h>
#include <ATen/ops/bincount_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bincount_native.h>
#include <ATen/ops/binomial_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/binomial_native.h>
#include <ATen/ops/bitwise_and_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bitwise_and_native.h>
#include <ATen/ops/bitwise_left_shift_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bitwise_left_shift_native.h>
#include <ATen/ops/bitwise_or_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bitwise_or_native.h>
#include <ATen/ops/bitwise_right_shift_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bitwise_right_shift_native.h>
#include <ATen/ops/bitwise_xor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bitwise_xor_native.h>
#include <ATen/ops/blackman_window_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/blackman_window_native.h>
#include <ATen/ops/block_diag_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/block_diag_native.h>
#include <ATen/ops/bucketize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/bucketize_native.h>
#include <ATen/ops/cauchy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cauchy_native.h>
#include <ATen/ops/ccol_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/ccol_indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/ccol_indices_copy_native.h>
#include <ATen/ops/ccol_indices_native.h>
#include <ATen/ops/celu_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/celu_native.h>
#include <ATen/ops/channel_shuffle_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/channel_shuffle_native.h>
#include <ATen/ops/cholesky_solve_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cholesky_solve_native.h>
#include <ATen/ops/clone_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/clone_native.h>
#include <ATen/ops/col_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/col_indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/col_indices_copy_native.h>
#include <ATen/ops/col_indices_native.h>
#include <ATen/ops/complex_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/complex_native.h>
#include <ATen/ops/conj_physical_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/conj_physical_native.h>
#include <ATen/ops/constant_pad_nd_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/constant_pad_nd_native.h>
#include <ATen/ops/conv_depthwise3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/conv_depthwise3d_native.h>
#include <ATen/ops/conv_tbc_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/conv_tbc_native.h>
#include <ATen/ops/convolution_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/convolution_backward_native.h>
#include <ATen/ops/convolution_backward_overrideable_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/convolution_backward_overrideable_native.h>
#include <ATen/ops/convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/convolution_native.h>
#include <ATen/ops/convolution_overrideable_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/convolution_overrideable_native.h>
#include <ATen/ops/copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/copy_native.h>
#include <ATen/ops/copy_sparse_to_sparse_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/copy_sparse_to_sparse_native.h>
#include <ATen/ops/copysign_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/copysign_native.h>
#include <ATen/ops/count_nonzero_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/count_nonzero_native.h>
#include <ATen/ops/crow_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/crow_indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/crow_indices_copy_native.h>
#include <ATen/ops/crow_indices_native.h>
#include <ATen/ops/cudnn_affine_grid_generator_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_affine_grid_generator_backward_native.h>
#include <ATen/ops/cudnn_affine_grid_generator_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_affine_grid_generator_native.h>
#include <ATen/ops/cudnn_batch_norm_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_batch_norm_backward_native.h>
#include <ATen/ops/cudnn_batch_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_batch_norm_native.h>
#include <ATen/ops/cudnn_convolution_add_relu_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_convolution_add_relu_native.h>
#include <ATen/ops/cudnn_convolution_relu_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_convolution_relu_native.h>
#include <ATen/ops/cudnn_convolution_transpose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_convolution_transpose_native.h>
#include <ATen/ops/cudnn_grid_sampler_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_grid_sampler_backward_native.h>
#include <ATen/ops/cudnn_grid_sampler_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cudnn_grid_sampler_native.h>
#include <ATen/ops/cummax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cummax_native.h>
#include <ATen/ops/cummin_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/cummin_native.h>
#include <ATen/ops/deg2rad_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/deg2rad_native.h>
#include <ATen/ops/dense_dim_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/dense_dim_native.h>
#include <ATen/ops/dequantize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/dequantize_native.h>
#include <ATen/ops/detach_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/detach_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/detach_copy_native.h>
#include <ATen/ops/detach_native.h>
#include <ATen/ops/diag_embed_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/diag_embed_native.h>
#include <ATen/ops/diagonal_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/diagonal_backward_native.h>
#include <ATen/ops/diagonal_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/diagonal_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/diagonal_copy_native.h>
#include <ATen/ops/diagonal_native.h>
#include <ATen/ops/diagonal_scatter_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/diagonal_scatter_native.h>
#include <ATen/ops/dist_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/dist_native.h>
#include <ATen/ops/div_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/div_native.h>
#include <ATen/ops/dot_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/dot_native.h>
#include <ATen/ops/embedding_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/embedding_dense_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/embedding_dense_backward_native.h>
#include <ATen/ops/embedding_native.h>
#include <ATen/ops/embedding_renorm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/embedding_renorm_native.h>
#include <ATen/ops/empty_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/empty_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/empty_like_native.h>
#include <ATen/ops/empty_native.h>
#include <ATen/ops/empty_permuted_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/empty_permuted_native.h>
#include <ATen/ops/empty_quantized_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/empty_quantized_native.h>
#include <ATen/ops/empty_strided_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/empty_strided_native.h>
#include <ATen/ops/expand_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/expand_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/expand_copy_native.h>
#include <ATen/ops/expand_native.h>
#include <ATen/ops/exponential_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/exponential_native.h>
#include <ATen/ops/eye_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/eye_native.h>
#include <ATen/ops/fake_quantize_per_channel_affine_cachemask_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fake_quantize_per_channel_affine_cachemask_native.h>
#include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fake_quantize_per_tensor_affine_cachemask_native.h>
#include <ATen/ops/fft_fftfreq_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fft_fftfreq_native.h>
#include <ATen/ops/fft_rfftfreq_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fft_rfftfreq_native.h>
#include <ATen/ops/fill_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fill_native.h>
#include <ATen/ops/flip_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/flip_native.h>
#include <ATen/ops/floor_divide_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/floor_divide_native.h>
#include <ATen/ops/fmod_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/fmod_native.h>
#include <ATen/ops/frexp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/frexp_native.h>
#include <ATen/ops/from_file_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/from_file_native.h>
#include <ATen/ops/full_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/full_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/full_like_native.h>
#include <ATen/ops/full_native.h>
#include <ATen/ops/geometric_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/geometric_native.h>
#include <ATen/ops/glu_backward_jvp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/glu_backward_jvp_native.h>
#include <ATen/ops/glu_jvp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/glu_jvp_native.h>
#include <ATen/ops/grid_sampler_2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/grid_sampler_2d_backward_native.h>
#include <ATen/ops/grid_sampler_2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/grid_sampler_2d_native.h>
#include <ATen/ops/grid_sampler_3d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/grid_sampler_3d_backward_native.h>
#include <ATen/ops/grid_sampler_3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/grid_sampler_3d_native.h>
#include <ATen/ops/hamming_window_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/hamming_window_native.h>
#include <ATen/ops/hann_window_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/hann_window_native.h>
#include <ATen/ops/hardswish_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/hardswish_backward_native.h>
#include <ATen/ops/huber_loss_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/huber_loss_backward_native.h>
#include <ATen/ops/index_fill_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/index_fill_native.h>
#include <ATen/ops/index_put_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/index_put_native.h>
#include <ATen/ops/indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/indices_copy_native.h>
#include <ATen/ops/indices_native.h>
#include <ATen/ops/int_repr_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/int_repr_native.h>
#include <ATen/ops/is_coalesced_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/is_coalesced_native.h>
#include <ATen/ops/is_pinned_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/is_pinned_native.h>
#include <ATen/ops/is_same_size_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/is_same_size_native.h>
#include <ATen/ops/isinf_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/isinf_native.h>
#include <ATen/ops/isnan_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/isnan_native.h>
#include <ATen/ops/kaiser_window_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/kaiser_window_native.h>
#include <ATen/ops/kthvalue_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/kthvalue_native.h>
#include <ATen/ops/lift_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/lift_fresh_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/lift_fresh_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/lift_fresh_copy_native.h>
#include <ATen/ops/lift_fresh_native.h>
#include <ATen/ops/lift_native.h>
#include <ATen/ops/linalg_lstsq_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linalg_lstsq_native.h>
#include <ATen/ops/linalg_matrix_exp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linalg_matrix_exp_native.h>
#include <ATen/ops/linalg_pinv_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linalg_pinv_native.h>
#include <ATen/ops/linear_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linear_backward_native.h>
#include <ATen/ops/linear_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linear_native.h>
#include <ATen/ops/linspace_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/linspace_native.h>
#include <ATen/ops/log_normal_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/log_normal_native.h>
#include <ATen/ops/log_softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/log_softmax_native.h>
#include <ATen/ops/logcumsumexp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logcumsumexp_native.h>
#include <ATen/ops/logical_and_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logical_and_native.h>
#include <ATen/ops/logical_not_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logical_not_native.h>
#include <ATen/ops/logical_or_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logical_or_native.h>
#include <ATen/ops/logical_xor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logical_xor_native.h>
#include <ATen/ops/logspace_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logspace_native.h>
#include <ATen/ops/logsumexp_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/logsumexp_native.h>
#include <ATen/ops/lshift_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/lshift_native.h>
#include <ATen/ops/lstm_mps_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/lstm_mps_backward_native.h>
#include <ATen/ops/masked_fill_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/masked_fill_native.h>
#include <ATen/ops/masked_scatter_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/masked_scatter_backward_native.h>
#include <ATen/ops/masked_scatter_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/masked_scatter_native.h>
#include <ATen/ops/matmul_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/matmul_backward_native.h>
#include <ATen/ops/max_pool2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/max_pool2d_backward_native.h>
#include <ATen/ops/mean_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mean_native.h>
#include <ATen/ops/median_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/median_native.h>
#include <ATen/ops/miopen_batch_norm_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_batch_norm_backward_native.h>
#include <ATen/ops/miopen_batch_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_batch_norm_native.h>
#include <ATen/ops/miopen_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_convolution_native.h>
#include <ATen/ops/miopen_convolution_transpose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_convolution_transpose_native.h>
#include <ATen/ops/miopen_depthwise_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_depthwise_convolution_native.h>
#include <ATen/ops/miopen_rnn_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_rnn_backward_native.h>
#include <ATen/ops/miopen_rnn_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/miopen_rnn_native.h>
#include <ATen/ops/mkldnn_adaptive_avg_pool2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_adaptive_avg_pool2d_backward_native.h>
#include <ATen/ops/mkldnn_convolution_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_convolution_native.h>
#include <ATen/ops/mkldnn_linear_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_linear_backward_input_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_linear_backward_input_native.h>
#include <ATen/ops/mkldnn_linear_backward_native.h>
#include <ATen/ops/mkldnn_linear_backward_weights_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_linear_backward_weights_native.h>
#include <ATen/ops/mkldnn_linear_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_linear_native.h>
#include <ATen/ops/mkldnn_max_pool2d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_max_pool2d_backward_native.h>
#include <ATen/ops/mkldnn_max_pool2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_max_pool2d_native.h>
#include <ATen/ops/mkldnn_max_pool3d_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_max_pool3d_backward_native.h>
#include <ATen/ops/mkldnn_max_pool3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_max_pool3d_native.h>
#include <ATen/ops/mkldnn_reorder_conv2d_weight_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_reorder_conv2d_weight_native.h>
#include <ATen/ops/mkldnn_reorder_conv3d_weight_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_reorder_conv3d_weight_native.h>
#include <ATen/ops/mkldnn_rnn_layer_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_rnn_layer_backward_native.h>
#include <ATen/ops/mkldnn_rnn_layer_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mkldnn_rnn_layer_native.h>
#include <ATen/ops/mode_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mode_native.h>
#include <ATen/ops/mps_convolution_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mps_convolution_backward_native.h>
#include <ATen/ops/mps_convolution_transpose_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mps_convolution_transpose_backward_native.h>
#include <ATen/ops/mul_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mul_native.h>
#include <ATen/ops/mv_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mv_native.h>
#include <ATen/ops/mvlgamma_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/mvlgamma_native.h>
#include <ATen/ops/nan_to_num_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/nan_to_num_native.h>
#include <ATen/ops/nanmedian_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/nanmedian_native.h>
#include <ATen/ops/native_batch_norm_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_batch_norm_backward_native.h>
#include <ATen/ops/native_dropout_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_dropout_backward_native.h>
#include <ATen/ops/native_dropout_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_dropout_native.h>
#include <ATen/ops/native_group_norm_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_group_norm_backward_native.h>
#include <ATen/ops/native_group_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_group_norm_native.h>
#include <ATen/ops/native_layer_norm_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_layer_norm_backward_native.h>
#include <ATen/ops/native_layer_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_layer_norm_native.h>
#include <ATen/ops/native_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/native_norm_native.h>
#include <ATen/ops/new_empty_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/new_empty_native.h>
#include <ATen/ops/new_empty_strided_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/new_empty_strided_native.h>
#include <ATen/ops/new_full_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/new_full_native.h>
#include <ATen/ops/new_ones_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/new_ones_native.h>
#include <ATen/ops/new_zeros_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/new_zeros_native.h>
#include <ATen/ops/norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/norm_native.h>
#include <ATen/ops/normal_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/normal_native.h>
#include <ATen/ops/ones_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/ones_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/ones_like_native.h>
#include <ATen/ops/ones_native.h>
#include <ATen/ops/permute_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/permute_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/permute_copy_native.h>
#include <ATen/ops/permute_native.h>
#include <ATen/ops/pixel_shuffle_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/pixel_shuffle_native.h>
#include <ATen/ops/pixel_unshuffle_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/pixel_unshuffle_native.h>
#include <ATen/ops/poisson_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/poisson_native.h>
#include <ATen/ops/polar_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/polar_native.h>
#include <ATen/ops/polygamma_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/polygamma_native.h>
#include <ATen/ops/prod_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/prod_native.h>
#include <ATen/ops/put_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/put_native.h>
#include <ATen/ops/q_per_channel_scales_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/q_per_channel_scales_native.h>
#include <ATen/ops/q_per_channel_zero_points_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/q_per_channel_zero_points_native.h>
#include <ATen/ops/quantize_per_channel_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantize_per_channel_native.h>
#include <ATen/ops/quantize_per_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantize_per_tensor_dynamic_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantize_per_tensor_dynamic_native.h>
#include <ATen/ops/quantize_per_tensor_native.h>
#include <ATen/ops/quantized_batch_norm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantized_batch_norm_native.h>
#include <ATen/ops/quantized_max_pool1d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantized_max_pool1d_native.h>
#include <ATen/ops/quantized_max_pool2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantized_max_pool2d_native.h>
#include <ATen/ops/quantized_max_pool3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/quantized_max_pool3d_native.h>
#include <ATen/ops/rad2deg_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rad2deg_native.h>
#include <ATen/ops/rand_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rand_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rand_like_native.h>
#include <ATen/ops/rand_native.h>
#include <ATen/ops/randint_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/randint_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/randint_like_native.h>
#include <ATen/ops/randint_native.h>
#include <ATen/ops/randn_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/randn_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/randn_like_native.h>
#include <ATen/ops/randn_native.h>
#include <ATen/ops/random_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/random_native.h>
#include <ATen/ops/randperm_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/randperm_native.h>
#include <ATen/ops/range_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/range_native.h>
#include <ATen/ops/relu_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/relu_native.h>
#include <ATen/ops/remainder_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/remainder_native.h>
#include <ATen/ops/repeat_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/repeat_interleave_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/repeat_interleave_native.h>
#include <ATen/ops/repeat_native.h>
#include <ATen/ops/resize_as_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/resize_as_native.h>
#include <ATen/ops/resize_as_sparse_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/resize_as_sparse_native.h>
#include <ATen/ops/resize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/resize_native.h>
#include <ATen/ops/roll_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/roll_native.h>
#include <ATen/ops/rot90_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rot90_native.h>
#include <ATen/ops/row_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/row_indices_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/row_indices_copy_native.h>
#include <ATen/ops/row_indices_native.h>
#include <ATen/ops/rrelu_with_noise_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rrelu_with_noise_backward_native.h>
#include <ATen/ops/rrelu_with_noise_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rrelu_with_noise_native.h>
#include <ATen/ops/rshift_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rshift_native.h>
#include <ATen/ops/rsub_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/rsub_native.h>
#include <ATen/ops/scalar_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/scalar_tensor_native.h>
#include <ATen/ops/segment_reduce_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/segment_reduce_native.h>
#include <ATen/ops/select_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/select_backward_native.h>
#include <ATen/ops/select_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/select_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/select_copy_native.h>
#include <ATen/ops/select_native.h>
#include <ATen/ops/select_scatter_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/select_scatter_native.h>
#include <ATen/ops/set_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/set_native.h>
#include <ATen/ops/slice_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slice_backward_native.h>
#include <ATen/ops/slice_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slice_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slice_copy_native.h>
#include <ATen/ops/slice_inverse_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slice_inverse_native.h>
#include <ATen/ops/slice_native.h>
#include <ATen/ops/slice_scatter_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slice_scatter_native.h>
#include <ATen/ops/slow_conv_dilated2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slow_conv_dilated2d_native.h>
#include <ATen/ops/slow_conv_dilated3d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/slow_conv_dilated3d_native.h>
#include <ATen/ops/smooth_l1_loss_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/smooth_l1_loss_backward_native.h>
#include <ATen/ops/soft_margin_loss_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/soft_margin_loss_backward_native.h>
#include <ATen/ops/soft_margin_loss_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/soft_margin_loss_native.h>
#include <ATen/ops/softmax_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/softmax_native.h>
#include <ATen/ops/sort_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sort_native.h>
#include <ATen/ops/sparse_compressed_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_compressed_tensor_native.h>
#include <ATen/ops/sparse_coo_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_coo_tensor_native.h>
#include <ATen/ops/sparse_dim_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_dim_native.h>
#include <ATen/ops/sparse_mask_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_mask_native.h>
#include <ATen/ops/sparse_resize_and_clear_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_resize_and_clear_native.h>
#include <ATen/ops/sparse_resize_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sparse_resize_native.h>
#include <ATen/ops/special_chebyshev_polynomial_t_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_chebyshev_polynomial_t_native.h>
#include <ATen/ops/special_chebyshev_polynomial_u_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_chebyshev_polynomial_u_native.h>
#include <ATen/ops/special_chebyshev_polynomial_v_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_chebyshev_polynomial_v_native.h>
#include <ATen/ops/special_chebyshev_polynomial_w_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_chebyshev_polynomial_w_native.h>
#include <ATen/ops/special_hermite_polynomial_h_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_hermite_polynomial_h_native.h>
#include <ATen/ops/special_hermite_polynomial_he_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_hermite_polynomial_he_native.h>
#include <ATen/ops/special_laguerre_polynomial_l_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_laguerre_polynomial_l_native.h>
#include <ATen/ops/special_legendre_polynomial_p_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_legendre_polynomial_p_native.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_t_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_t_native.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_u_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_u_native.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_v_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_v_native.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_w_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_shifted_chebyshev_polynomial_w_native.h>
#include <ATen/ops/special_xlog1py_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_xlog1py_native.h>
#include <ATen/ops/special_zeta_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/special_zeta_native.h>
#include <ATen/ops/split_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/split_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/split_copy_native.h>
#include <ATen/ops/split_native.h>
#include <ATen/ops/split_with_sizes_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/split_with_sizes_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/split_with_sizes_copy_native.h>
#include <ATen/ops/split_with_sizes_native.h>
#include <ATen/ops/squeeze_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/squeeze_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/squeeze_copy_native.h>
#include <ATen/ops/squeeze_native.h>
#include <ATen/ops/stack_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/stack_native.h>
#include <ATen/ops/std_mean_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/std_mean_native.h>
#include <ATen/ops/sub_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sub_native.h>
#include <ATen/ops/sum_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sum_native.h>
#include <ATen/ops/sym_constrain_range_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sym_constrain_range_for_size_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/sym_constrain_range_for_size_native.h>
#include <ATen/ops/sym_constrain_range_native.h>
#include <ATen/ops/t_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/t_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/t_copy_native.h>
#include <ATen/ops/t_native.h>
#include <ATen/ops/to_mkldnn_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/to_mkldnn_native.h>
#include <ATen/ops/to_padded_tensor_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/to_padded_tensor_native.h>
#include <ATen/ops/trace_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/trace_native.h>
#include <ATen/ops/transpose_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/transpose_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/transpose_copy_native.h>
#include <ATen/ops/transpose_native.h>
#include <ATen/ops/tril_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/tril_indices_native.h>
#include <ATen/ops/triu_indices_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/triu_indices_native.h>
#include <ATen/ops/unbind_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unbind_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unbind_copy_native.h>
#include <ATen/ops/unbind_native.h>
#include <ATen/ops/unfold_backward_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unfold_backward_native.h>
#include <ATen/ops/unfold_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unfold_copy_native.h>
#include <ATen/ops/uniform_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/uniform_native.h>
#include <ATen/ops/unique_consecutive_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unique_consecutive_native.h>
#include <ATen/ops/unique_dim_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unique_dim_consecutive_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unique_dim_consecutive_native.h>
#include <ATen/ops/unique_dim_native.h>
#include <ATen/ops/unsafe_split_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unsafe_split_native.h>
#include <ATen/ops/unsafe_split_with_sizes_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unsafe_split_with_sizes_native.h>
#include <ATen/ops/unsqueeze_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unsqueeze_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/unsqueeze_copy_native.h>
#include <ATen/ops/unsqueeze_native.h>
#include <ATen/ops/upsample_bilinear2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/upsample_bilinear2d_native.h>
#include <ATen/ops/upsample_nearest2d_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/upsample_nearest2d_native.h>
#include <ATen/ops/values_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/values_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/values_copy_native.h>
#include <ATen/ops/values_native.h>
#include <ATen/ops/var_mean_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/var_mean_native.h>
#include <ATen/ops/vdot_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/vdot_native.h>
#include <ATen/ops/view_as_complex_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/view_as_complex_copy_native.h>
#include <ATen/ops/view_as_real_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/view_as_real_copy_native.h>
#include <ATen/ops/view_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/view_copy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/view_copy_native.h>
#include <ATen/ops/view_native.h>
#include <ATen/ops/xlogy_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/xlogy_native.h>
#include <ATen/ops/zero_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/zero_native.h>
#include <ATen/ops/zeros_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/zeros_like_compositeexplicitautograd_dispatch.h>
#include <ATen/ops/zeros_like_native.h>
#include <ATen/ops/zeros_native.h>

namespace at {
namespace {
C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function")

void resize_out(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  TORCH_CHECK(options.dtype() == out.dtype(),
      "Expected out tensor to have dtype ", options.dtype(), ", but got ", out.dtype(), " instead");
  TORCH_CHECK(options.device() == out.device(),
      "Expected out tensor to have device ", options.device(), ", but got ", out.device(), " instead");
  const bool resized = at::native::resize_output(out, sizes);
  // Only restride if a resize occurred; otherwise we ignore the (advisory)
  // strides from the meta function and directly use the output tensor's
  // preexisting strides
  if (resized) {
    if (!strides.empty()) {
      TORCH_INTERNAL_ASSERT(!options.memory_format_opt().has_value());
      // TODO: avoid the redispatch here
      out.as_strided_(sizes, strides);
    } else if (options.memory_format_opt().has_value()) {
      out.unsafeGetTensorImpl()->empty_tensor_restride(*options.memory_format_opt());
    }
  }
}

void check_inplace(const Tensor &self, IntArrayRef sizes, const TensorOptions &options) {
  // These checks are needed on those operators that:
  //   1) don't use 'TensorIterator' (e.g. 'addmm' and 'baddbmm')
  //   2) have particular typing rules (e.g. 'cumsum' and 'cumprod')
  // For other operators (e.g. 'add'), 'TensorIterator' already checks
  // these things separately.
  TORCH_CHECK(options.dtype() == self.dtype(),
      "Bad in-place call: ",
      "input tensor dtype ", self.dtype(), " and output tensor dtype ", options.dtype(), " should match");
  TORCH_CHECK(options.device() == self.device(),
      "Bad in-place call: ",
      "input tensor device ", self.device(), " and output tensor device ", options.device(), " should match");
  TORCH_CHECK(sizes == self.sizes(),
      "Bad in-place call: ",
      "input tensor size ", self.sizes(), " and output tensor size ", sizes, " should match");
}
C10_DIAGNOSTIC_POP()
} // namespace
} // namespace at

// See template file RegisterDispatchDefinitions.ini
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___fw_primal(const at::Tensor & self, int64_t level) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fw_primal(self, level);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fw_primal",
TORCH_FN(wrapper_CompositeExplicitAutograd___fw_primal));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _fw_primal(const at::Tensor & self, int64_t level) {
return wrapper_CompositeExplicitAutograd___fw_primal(self, level);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___make_dual(const at::Tensor & primal, const at::Tensor & tangent, int64_t level) {
    // No device check
  // DeviceGuard omitted
  return at::native::_make_dual(primal, tangent, level);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_make_dual",
TORCH_FN(wrapper_CompositeExplicitAutograd___make_dual));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _make_dual(const at::Tensor & primal, const at::Tensor & tangent, int64_t level) {
return wrapper_CompositeExplicitAutograd___make_dual(primal, tangent, level);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___new_zeros_with_same_feature_meta(const at::Tensor & self, const at::Tensor & other, int64_t self_num_batch_dims) {
    // No device check
  // DeviceGuard omitted
  return at::native::_new_zeros_with_same_feature_meta(self, other, self_num_batch_dims);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__new_zeros_with_same_feature_meta_out(const at::Tensor & self, const at::Tensor & other, int64_t self_num_batch_dims, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_new_zeros_with_same_feature_meta_out(self, other, self_num_batch_dims, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_new_zeros_with_same_feature_meta",
TORCH_FN(wrapper_CompositeExplicitAutograd___new_zeros_with_same_feature_meta));
m.impl("_new_zeros_with_same_feature_meta.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__new_zeros_with_same_feature_meta_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _new_zeros_with_same_feature_meta(const at::Tensor & self, const at::Tensor & other, int64_t self_num_batch_dims) {
return wrapper_CompositeExplicitAutograd___new_zeros_with_same_feature_meta(self, other, self_num_batch_dims);
}
at::Tensor & _new_zeros_with_same_feature_meta_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, int64_t self_num_batch_dims) {
return wrapper_CompositeExplicitAutograd_out__new_zeros_with_same_feature_meta_out(self, other, self_num_batch_dims, out);
}
at::Tensor & _new_zeros_with_same_feature_meta_outf(const at::Tensor & self, const at::Tensor & other, int64_t self_num_batch_dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__new_zeros_with_same_feature_meta_out(self, other, self_num_batch_dims, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
bool wrapper_CompositeExplicitAutograd___has_same_storage_numel(const at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::_has_same_storage_numel(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_has_same_storage_numel",
TORCH_FN(wrapper_CompositeExplicitAutograd___has_same_storage_numel));
}
} // anonymous namespace
namespace compositeexplicitautograd {
bool _has_same_storage_numel(const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd___has_same_storage_numel(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd___assert_scalar(const at::Scalar & self, c10::string_view assert_msg) {
    // No device check
  // DeviceGuard omitted
  return at::native::_assert_scalar(self, assert_msg);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_assert_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd___assert_scalar));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _assert_scalar(const at::Scalar & self, c10::string_view assert_msg) {
return wrapper_CompositeExplicitAutograd___assert_scalar(self, assert_msg);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___functional_assert_scalar(const at::Scalar & self, c10::string_view assert_msg, const at::Tensor & dep_token) {
    // No device check
  // DeviceGuard omitted
  return at::native::_functional_assert_scalar(self, assert_msg, dep_token);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_functional_assert_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd___functional_assert_scalar));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _functional_assert_scalar(const at::Scalar & self, c10::string_view assert_msg, const at::Tensor & dep_token) {
return wrapper_CompositeExplicitAutograd___functional_assert_scalar(self, assert_msg, dep_token);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd___assert_tensor_metadata(const at::Tensor & a, at::OptionalSymIntArrayRef size, at::OptionalSymIntArrayRef stride, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Device> device, ::std::optional<at::Layout> layout) {
    // No device check
  // DeviceGuard omitted
  return at::native::_assert_tensor_metadata(a, size.has_value() ? ::std::make_optional(C10_AS_INTARRAYREF_SLOW(*size)) : ::std::nullopt, stride.has_value() ? ::std::make_optional(C10_AS_INTARRAYREF_SLOW(*stride)) : ::std::nullopt, dtype, device, layout);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_assert_tensor_metadata",
TORCH_FN(wrapper_CompositeExplicitAutograd___assert_tensor_metadata));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _assert_tensor_metadata(const at::Tensor & a, at::OptionalIntArrayRef size, at::OptionalIntArrayRef stride, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Device> device, ::std::optional<at::Layout> layout) {
return wrapper_CompositeExplicitAutograd___assert_tensor_metadata(a, size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*size)) : ::std::nullopt, stride.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*stride)) : ::std::nullopt, dtype, device, layout);
}
void _assert_tensor_metadata_symint(const at::Tensor & a, at::OptionalSymIntArrayRef size, at::OptionalSymIntArrayRef stride, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Device> device, ::std::optional<at::Layout> layout) {
return wrapper_CompositeExplicitAutograd___assert_tensor_metadata(a, size, stride, dtype, device, layout);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd___print(c10::string_view s) {
    // No device check
  // DeviceGuard omitted
  return at::native::_print(s);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_print",
TORCH_FN(wrapper_CompositeExplicitAutograd___print));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _print(c10::string_view s) {
return wrapper_CompositeExplicitAutograd___print(s);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd__sym_constrain_range(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max) {
    // No device check
  // DeviceGuard omitted
  return at::native::sym_constrain_range(size, min, max);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sym_constrain_range",
TORCH_FN(wrapper_CompositeExplicitAutograd__sym_constrain_range));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void sym_constrain_range(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max) {
return wrapper_CompositeExplicitAutograd__sym_constrain_range(size, min, max);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd__sym_constrain_range_for_size(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max) {
    // No device check
  // DeviceGuard omitted
  return at::native::sym_constrain_range_for_size(size, min, max);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sym_constrain_range_for_size",
TORCH_FN(wrapper_CompositeExplicitAutograd__sym_constrain_range_for_size));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void sym_constrain_range_for_size(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max) {
return wrapper_CompositeExplicitAutograd__sym_constrain_range_for_size(size, min, max);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___functional_sym_constrain_range(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max, const at::Tensor & dep_token) {
    // No device check
  // DeviceGuard omitted
  return at::native::_functional_sym_constrain_range(size, min, max, dep_token);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_functional_sym_constrain_range",
TORCH_FN(wrapper_CompositeExplicitAutograd___functional_sym_constrain_range));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _functional_sym_constrain_range(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max, const at::Tensor & dep_token) {
return wrapper_CompositeExplicitAutograd___functional_sym_constrain_range(size, min, max, dep_token);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___functional_sym_constrain_range_for_size(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max, const at::Tensor & dep_token) {
    // No device check
  // DeviceGuard omitted
  return at::native::_functional_sym_constrain_range_for_size(size, min, max, dep_token);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_functional_sym_constrain_range_for_size",
TORCH_FN(wrapper_CompositeExplicitAutograd___functional_sym_constrain_range_for_size));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _functional_sym_constrain_range_for_size(const at::Scalar & size, ::std::optional<int64_t> min, ::std::optional<int64_t> max, const at::Tensor & dep_token) {
return wrapper_CompositeExplicitAutograd___functional_sym_constrain_range_for_size(size, min, max, dep_token);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__cudnn_ctc_loss_out(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cudnn_ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cudnn_ctc_loss.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cudnn_ctc_loss_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _cudnn_ctc_loss_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity) {
return wrapper_CompositeExplicitAutograd_out__cudnn_ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _cudnn_ctc_loss_outf(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool deterministic, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__cudnn_ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, deterministic, zero_infinity, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out(at::TensorList weight_arr, int64_t weight_stride0, c10::SymInt input_size, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, bool bidirectional, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cudnn_rnn_flatten_weight_out_symint(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cudnn_rnn_flatten_weight.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _cudnn_rnn_flatten_weight_out(at::Tensor & out, at::TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, bool bidirectional) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional, out);
}
at::Tensor & _cudnn_rnn_flatten_weight_outf(at::TensorList weight_arr, int64_t weight_stride0, int64_t input_size, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, bool bidirectional, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional, out);
}
at::Tensor & _cudnn_rnn_flatten_weight_symint_out(at::Tensor & out, at::TensorList weight_arr, int64_t weight_stride0, c10::SymInt input_size, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, bool bidirectional) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional, out);
}
at::Tensor & _cudnn_rnn_flatten_weight_symint_outf(at::TensorList weight_arr, int64_t weight_stride0, c10::SymInt input_size, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, bool bidirectional, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_flatten_weight_out(weight_arr, weight_stride0, input_size, mode, hidden_size, proj_size, num_layers, batch_first, bidirectional, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const ::std::optional<at::Tensor> & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cudnn_rnn_out_symint(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cudnn_rnn.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _cudnn_rnn_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const ::std::optional<at::Tensor> & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _cudnn_rnn_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const ::std::optional<at::Tensor> & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, out0, out1, out2, out3, out4);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _cudnn_rnn_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const ::std::optional<at::Tensor> & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _cudnn_rnn_symint_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const ::std::optional<at::Tensor> & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_out(input, weight, weight_stride0, weight_buf, hx, cx, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cudnn_rnn_backward_out_symint(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cudnn_rnn_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _cudnn_rnn_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, reserve, output_mask, out0, out1, out2, out3);
}
void _cudnn_rnn_backward_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, int64_t hidden_size, int64_t proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, c10::fromIntArrayRefSlow(batch_sizes), dropout_state, reserve, output_mask, out0, out1, out2, out3);
}
void _cudnn_rnn_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask, out0, out1, out2, out3);
}
void _cudnn_rnn_backward_symint_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, c10::SymInt hidden_size, c10::SymInt proj_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, c10::SymIntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3) {
return wrapper_CompositeExplicitAutograd_out__cudnn_rnn_backward_out(input, weight, weight_stride0, weight_buf, hx, cx, output, grad_output, grad_hy, grad_cy, mode, hidden_size, proj_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, reserve, output_mask, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__cudnn_init_dropout_state_out(double dropout, bool train, int64_t dropout_seed, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cudnn_init_dropout_state_out(dropout, train, dropout_seed, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cudnn_init_dropout_state.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cudnn_init_dropout_state_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _cudnn_init_dropout_state_out(at::Tensor & out, double dropout, bool train, int64_t dropout_seed) {
return wrapper_CompositeExplicitAutograd_out__cudnn_init_dropout_state_out(dropout, train, dropout_seed, out);
}
at::Tensor & _cudnn_init_dropout_state_outf(double dropout, bool train, int64_t dropout_seed, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cudnn_init_dropout_state_out(dropout, train, dropout_seed, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__fused_dropout_out(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_dropout_out(self, p, generator, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_dropout.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_dropout_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _fused_dropout_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, double p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out__fused_dropout_out(self, p, generator, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _fused_dropout_outf(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__fused_dropout_out(self, p, generator, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__masked_scale_out(const at::Tensor & self, const at::Tensor & mask, double scale, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_masked_scale_out(self, mask, scale, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_masked_scale.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__masked_scale_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _masked_scale_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, double scale) {
return wrapper_CompositeExplicitAutograd_out__masked_scale_out(self, mask, scale, out);
}
at::Tensor & _masked_scale_outf(const at::Tensor & self, const at::Tensor & mask, double scale, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__masked_scale_out(self, mask, scale, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_dropout_out(const at::Tensor & input, double p, ::std::optional<bool> train, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_dropout_out(input, p, train, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_dropout.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_dropout_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> native_dropout_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, double p, ::std::optional<bool> train) {
return wrapper_CompositeExplicitAutograd_out_native_dropout_out(input, p, train, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> native_dropout_outf(const at::Tensor & input, double p, ::std::optional<bool> train, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_native_dropout_out(input, p, train, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_native_dropout_backward_out(const at::Tensor & grad_output, const at::Tensor & mask, double scale, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_dropout_backward_out(grad_output, mask, scale, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_dropout_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_dropout_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & native_dropout_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & mask, double scale) {
return wrapper_CompositeExplicitAutograd_out_native_dropout_backward_out(grad_output, mask, scale, out);
}
at::Tensor & native_dropout_backward_outf(const at::Tensor & grad_output, const at::Tensor & mask, double scale, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_native_dropout_backward_out(grad_output, mask, scale, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__abs(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::abs(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__abs_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::abs_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("abs",
TORCH_FN(wrapper_CompositeExplicitAutograd__abs));
m.impl("abs_",
TORCH_FN(wrapper_CompositeExplicitAutograd__abs_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor abs(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__abs(self);
}
at::Tensor & abs_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__abs_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___conj(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_conj(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_conj",
TORCH_FN(wrapper_CompositeExplicitAutograd___conj));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _conj(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___conj(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___conj_physical(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_conj_physical(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__conj_physical_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_conj_physical_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_conj_physical",
TORCH_FN(wrapper_CompositeExplicitAutograd___conj_physical));
m.impl("_conj_physical.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__conj_physical_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _conj_physical(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___conj_physical(self);
}
at::Tensor & _conj_physical_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__conj_physical_out(self, out);
}
at::Tensor & _conj_physical_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__conj_physical_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__conj_physical_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::conj_physical_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("conj_physical_",
TORCH_FN(wrapper_CompositeExplicitAutograd__conj_physical_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & conj_physical_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__conj_physical_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___neg_view(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_neg_view(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_neg_view",
TORCH_FN(wrapper_CompositeExplicitAutograd___neg_view));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _neg_view(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___neg_view(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_avg_pool1d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::avg_pool1d_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("avg_pool1d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_avg_pool1d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & avg_pool1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
return wrapper_CompositeExplicitAutograd_out_avg_pool1d_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, out);
}
at::Tensor & avg_pool1d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, bool ceil_mode, bool count_include_pad, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_avg_pool1d_out(self, kernel_size, stride, padding, ceil_mode, count_include_pad, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_adaptive_avg_pool1d_out(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::adaptive_avg_pool1d_out(self, output_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("adaptive_avg_pool1d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_adaptive_avg_pool1d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & adaptive_avg_pool1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out_adaptive_avg_pool1d_out(self, output_size, out);
}
at::Tensor & adaptive_avg_pool1d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_adaptive_avg_pool1d_out(self, output_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out__add_relu_out(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_add_relu_Scalar_out(self, other, alpha, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_add_relu.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__add_relu_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _add_relu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_out__add_relu_out(self, other, alpha, out);
}
at::Tensor & _add_relu_outf(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__add_relu_out(self, other, alpha, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_add(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::add(self, other, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_add_out(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::add_Scalar_out(self, other, alpha, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_add_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::add_(self, other, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("add.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_add));
m.impl("add.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_add_out));
m.impl("add_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_add_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor add(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_add(self, other, alpha);
}
at::Tensor & add_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_out_add_out(self, other, alpha, out);
}
at::Tensor & add_outf(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_add_out(self, other, alpha, out);
}
at::Tensor & add_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_add_(self, other, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__addr(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::math_addr(self, vec1, vec2, beta, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_addr_out(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::math_addr_out(self, vec1, vec2, beta, alpha, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__addr_(at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::addr_(self, vec1, vec2, beta, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("addr",
TORCH_FN(wrapper_CompositeExplicitAutograd__addr));
m.impl("addr.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_addr_out));
m.impl("addr_",
TORCH_FN(wrapper_CompositeExplicitAutograd__addr_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor addr(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd__addr(self, vec1, vec2, beta, alpha);
}
at::Tensor & addr_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_out_addr_out(self, vec1, vec2, beta, alpha, out);
}
at::Tensor & addr_outf(const at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_addr_out(self, vec1, vec2, beta, alpha, out);
}
at::Tensor & addr_(at::Tensor & self, const at::Tensor & vec1, const at::Tensor & vec2, const at::Scalar & beta, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd__addr_(self, vec1, vec2, beta, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__affine_grid_generator(const at::Tensor & theta, c10::SymIntArrayRef size, bool align_corners) {
    // No device check
  // DeviceGuard omitted
  return at::native::affine_grid_generator(theta, C10_AS_INTARRAYREF_SLOW(size), align_corners);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out(const at::Tensor & theta, c10::SymIntArrayRef size, bool align_corners, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::affine_grid_generator_out_symint(theta, size, align_corners, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("affine_grid_generator",
TORCH_FN(wrapper_CompositeExplicitAutograd__affine_grid_generator));
m.impl("affine_grid_generator.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor affine_grid_generator(const at::Tensor & theta, at::IntArrayRef size, bool align_corners) {
return wrapper_CompositeExplicitAutograd__affine_grid_generator(theta, c10::fromIntArrayRefSlow(size), align_corners);
}
at::Tensor affine_grid_generator_symint(const at::Tensor & theta, c10::SymIntArrayRef size, bool align_corners) {
return wrapper_CompositeExplicitAutograd__affine_grid_generator(theta, size, align_corners);
}
at::Tensor & affine_grid_generator_out(at::Tensor & out, const at::Tensor & theta, at::IntArrayRef size, bool align_corners) {
return wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out(theta, c10::fromIntArrayRefSlow(size), align_corners, out);
}
at::Tensor & affine_grid_generator_outf(const at::Tensor & theta, at::IntArrayRef size, bool align_corners, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out(theta, c10::fromIntArrayRefSlow(size), align_corners, out);
}
at::Tensor & affine_grid_generator_symint_out(at::Tensor & out, const at::Tensor & theta, c10::SymIntArrayRef size, bool align_corners) {
return wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out(theta, size, align_corners, out);
}
at::Tensor & affine_grid_generator_symint_outf(const at::Tensor & theta, c10::SymIntArrayRef size, bool align_corners, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_affine_grid_generator_out(theta, size, align_corners, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___is_all_true(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_is_all_true(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_is_all_true",
TORCH_FN(wrapper_CompositeExplicitAutograd___is_all_true));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _is_all_true(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___is_all_true(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___is_any_true(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_is_any_true(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_is_any_true",
TORCH_FN(wrapper_CompositeExplicitAutograd___is_any_true));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _is_any_true(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___is_any_true(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_functorch_fallback_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_functorch_fallback_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_functorch_fallback.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_functorch_fallback_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _test_functorch_fallback_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_out__test_functorch_fallback_out(self, other, out);
}
at::Tensor & _test_functorch_fallback_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_functorch_fallback_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dims_all(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::all_dims_default(self, dim, keepdim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dims_out_all_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::all_dims_out_default(self, dim, keepdim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("all.dims",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_all));
m.impl("all.dims_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_out_all_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor all(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dims_all(self, dim, keepdim);
}
at::Tensor & all_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dims_out_all_out(self, dim, keepdim, out);
}
at::Tensor & all_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dims_out_all_out(self, dim, keepdim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
bool wrapper_CompositeExplicitAutograd__allclose(const at::Tensor & self, const at::Tensor & other, double rtol, double atol, bool equal_nan) {
    // No device check
  // DeviceGuard omitted
  return at::native::allclose(self, other, rtol, atol, equal_nan);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("allclose",
TORCH_FN(wrapper_CompositeExplicitAutograd__allclose));
}
} // anonymous namespace
namespace compositeexplicitautograd {
bool allclose(const at::Tensor & self, const at::Tensor & other, double rtol, double atol, bool equal_nan) {
return wrapper_CompositeExplicitAutograd__allclose(self, other, rtol, atol, equal_nan);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dims_any(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::any_dims_default(self, dim, keepdim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dims_out_any_out(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::any_dims_out_default(self, dim, keepdim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("any.dims",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_any));
m.impl("any.dims_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_out_any_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor any(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dims_any(self, dim, keepdim);
}
at::Tensor & any_out(at::Tensor & out, const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dims_out_any_out(self, dim, keepdim, out);
}
at::Tensor & any_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, bool keepdim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dims_out_any_out(self, dim, keepdim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__arange(const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::arange(end, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_arange_out(const at::Scalar & end, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::arange_out(end, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("arange",
TORCH_FN(wrapper_CompositeExplicitAutograd__arange));
m.impl("arange.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_arange_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor arange(const at::Scalar & end, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__arange(end, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor arange(const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__arange(end, dtype, layout, device, pin_memory);
}
at::Tensor & arange_out(at::Tensor & out, const at::Scalar & end) {
return wrapper_CompositeExplicitAutograd_out_arange_out(end, out);
}
at::Tensor & arange_outf(const at::Scalar & end, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_arange_out(end, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_start_arange(const at::Scalar & start, const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::arange(start, end, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("arange.start",
TORCH_FN(wrapper_CompositeExplicitAutograd_start_arange));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor arange(const at::Scalar & start, const at::Scalar & end, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_start_arange(start, end, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor arange(const at::Scalar & start, const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_start_arange(start, end, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_start_step_arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::arange(start, end, step, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("arange.start_step",
TORCH_FN(wrapper_CompositeExplicitAutograd_start_step_arange));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_start_step_arange(start, end, step, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_start_step_arange(start, end, step, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__bartlett_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::bartlett_window(window_length, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_bartlett_window_out(int64_t window_length, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bartlett_window_out(window_length, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bartlett_window",
TORCH_FN(wrapper_CompositeExplicitAutograd__bartlett_window));
m.impl("bartlett_window.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_bartlett_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bartlett_window(int64_t window_length, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__bartlett_window(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor bartlett_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__bartlett_window(window_length, dtype, layout, device, pin_memory);
}
at::Tensor & bartlett_window_out(at::Tensor & out, int64_t window_length) {
return wrapper_CompositeExplicitAutograd_out_bartlett_window_out(window_length, out);
}
at::Tensor & bartlett_window_outf(int64_t window_length, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_bartlett_window_out(window_length, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_bartlett_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::bartlett_window(window_length, periodic, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_out_bartlett_window_out(int64_t window_length, bool periodic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bartlett_window_periodic_out(window_length, periodic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bartlett_window.periodic",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_bartlett_window));
m.impl("bartlett_window.periodic_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_out_bartlett_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bartlett_window(int64_t window_length, bool periodic, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_bartlett_window(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor bartlett_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_bartlett_window(window_length, periodic, dtype, layout, device, pin_memory);
}
at::Tensor & bartlett_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
return wrapper_CompositeExplicitAutograd_periodic_out_bartlett_window_out(window_length, periodic, out);
}
at::Tensor & bartlett_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_out_bartlett_window_out(window_length, periodic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantized_batch_norm_out(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & mean, const at::Tensor & var, double eps, double output_scale, int64_t output_zero_point, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantized_batch_norm_out(input, weight, bias, mean, var, eps, output_scale, output_zero_point, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantized_batch_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantized_batch_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantized_batch_norm_out(at::Tensor & out, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & mean, const at::Tensor & var, double eps, double output_scale, int64_t output_zero_point) {
return wrapper_CompositeExplicitAutograd_out_quantized_batch_norm_out(input, weight, bias, mean, var, eps, output_scale, output_zero_point, out);
}
at::Tensor & quantized_batch_norm_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & mean, const at::Tensor & var, double eps, double output_scale, int64_t output_zero_point, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantized_batch_norm_out(input, weight, bias, mean, var, eps, output_scale, output_zero_point, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__bernoulli(const at::Tensor & self, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::bernoulli(self, generator);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bernoulli",
TORCH_FN(wrapper_CompositeExplicitAutograd__bernoulli));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bernoulli(const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__bernoulli(self, generator);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_bernoulli(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::bernoulli(self, p, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_bernoulli_out(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bernoulli_Tensor_out(self, p, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bernoulli.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_bernoulli));
m.impl("bernoulli.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_bernoulli_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bernoulli(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_Tensor_bernoulli(self, p, generator);
}
at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_Tensor_out_bernoulli_out(self, p, generator, out);
}
at::Tensor & bernoulli_outf(const at::Tensor & self, const at::Tensor & p, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_bernoulli_out(self, p, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_float_out_bernoulli_out(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bernoulli_float_out(self, p, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bernoulli.float_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_float_out_bernoulli_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & bernoulli_out(at::Tensor & out, const at::Tensor & self, double p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_float_out_bernoulli_out(self, p, generator, out);
}
at::Tensor & bernoulli_outf(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_float_out_bernoulli_out(self, p, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction) {
    // No device check
  // DeviceGuard omitted
  return at::native::binary_cross_entropy_with_logits(self, target, weight, pos_weight, reduction);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_binary_cross_entropy_with_logits_out(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::binary_cross_entropy_with_logits_out(self, target, weight, pos_weight, reduction, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("binary_cross_entropy_with_logits",
TORCH_FN(wrapper_CompositeExplicitAutograd__binary_cross_entropy_with_logits));
m.impl("binary_cross_entropy_with_logits.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_binary_cross_entropy_with_logits_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor binary_cross_entropy_with_logits(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction) {
return wrapper_CompositeExplicitAutograd__binary_cross_entropy_with_logits(self, target, weight, pos_weight, reduction);
}
at::Tensor & binary_cross_entropy_with_logits_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction) {
return wrapper_CompositeExplicitAutograd_out_binary_cross_entropy_with_logits_out(self, target, weight, pos_weight, reduction, out);
}
at::Tensor & binary_cross_entropy_with_logits_outf(const at::Tensor & self, const at::Tensor & target, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & pos_weight, int64_t reduction, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_binary_cross_entropy_with_logits_out(self, target, weight, pos_weight, reduction, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_bincount_out(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bincount_out(self, weights, minlength, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bincount.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_bincount_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & bincount_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength) {
return wrapper_CompositeExplicitAutograd_out_bincount_out(self, weights, minlength, out);
}
at::Tensor & bincount_outf(const at::Tensor & self, const ::std::optional<at::Tensor> & weights, int64_t minlength, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_bincount_out(self, weights, minlength, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_copysign(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::copysign(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_copysign_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::copysign_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_copysign_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::copysign_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("copysign.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_copysign));
m.impl("copysign.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_copysign_out));
m.impl("copysign_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_copysign_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor copysign(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_copysign(self, other);
}
at::Tensor & copysign_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_copysign_out(self, other, out);
}
at::Tensor & copysign_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_copysign_out(self, other, out);
}
at::Tensor & copysign_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_copysign_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___lazy_clone(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_lazy_clone(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_lazy_clone",
TORCH_FN(wrapper_CompositeExplicitAutograd___lazy_clone));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _lazy_clone(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___lazy_clone(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logical_not(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_not(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__logical_not_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_not_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logical_not",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_not));
m.impl("logical_not_",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_not_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logical_not(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__logical_not(self);
}
at::Tensor & logical_not_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__logical_not_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logical_xor(const at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_xor(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__logical_xor_(at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_xor_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logical_xor",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_xor));
m.impl("logical_xor_",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_xor_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logical_xor(const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_xor(self, other);
}
at::Tensor & logical_xor_(at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_xor_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logical_and(const at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_and(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__logical_and_(at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_and_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logical_and",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_and));
m.impl("logical_and_",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_and_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logical_and(const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_and(self, other);
}
at::Tensor & logical_and_(at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_and_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logical_or(const at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_or(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__logical_or_(at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::logical_or_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logical_or",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_or));
m.impl("logical_or_",
TORCH_FN(wrapper_CompositeExplicitAutograd__logical_or_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logical_or(const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_or(self, other);
}
at::Tensor & logical_or_(at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__logical_or_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__blackman_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::blackman_window(window_length, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_blackman_window_out(int64_t window_length, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::blackman_window_out(window_length, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("blackman_window",
TORCH_FN(wrapper_CompositeExplicitAutograd__blackman_window));
m.impl("blackman_window.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_blackman_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor blackman_window(int64_t window_length, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__blackman_window(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor blackman_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__blackman_window(window_length, dtype, layout, device, pin_memory);
}
at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length) {
return wrapper_CompositeExplicitAutograd_out_blackman_window_out(window_length, out);
}
at::Tensor & blackman_window_outf(int64_t window_length, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_blackman_window_out(window_length, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_blackman_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::blackman_window(window_length, periodic, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_out_blackman_window_out(int64_t window_length, bool periodic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::blackman_window_periodic_out(window_length, periodic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("blackman_window.periodic",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_blackman_window));
m.impl("blackman_window.periodic_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_out_blackman_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_blackman_window(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor blackman_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_blackman_window(window_length, periodic, dtype, layout, device, pin_memory);
}
at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
return wrapper_CompositeExplicitAutograd_periodic_out_blackman_window_out(window_length, periodic, out);
}
at::Tensor & blackman_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_out_blackman_window_out(window_length, periodic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__block_diag(at::TensorList tensors) {
    // No device check
  // DeviceGuard omitted
  return at::native::block_diag(tensors);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_block_diag_out(at::TensorList tensors, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::block_diag_out(tensors, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("block_diag",
TORCH_FN(wrapper_CompositeExplicitAutograd__block_diag));
m.impl("block_diag.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_block_diag_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor block_diag(at::TensorList tensors) {
return wrapper_CompositeExplicitAutograd__block_diag(tensors);
}
at::Tensor & block_diag_out(at::Tensor & out, at::TensorList tensors) {
return wrapper_CompositeExplicitAutograd_out_block_diag_out(tensors, out);
}
at::Tensor & block_diag_outf(at::TensorList tensors, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_block_diag_out(tensors, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__complex(const at::Tensor & real, const at::Tensor & imag) {
    // No device check
  // DeviceGuard omitted
  return at::native::complex(real, imag);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("complex",
TORCH_FN(wrapper_CompositeExplicitAutograd__complex));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor complex(const at::Tensor & real, const at::Tensor & imag) {
return wrapper_CompositeExplicitAutograd__complex(real, imag);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__polar(const at::Tensor & abs, const at::Tensor & angle) {
    // No device check
  // DeviceGuard omitted
  return at::native::polar(abs, angle);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("polar",
TORCH_FN(wrapper_CompositeExplicitAutograd__polar));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor polar(const at::Tensor & abs, const at::Tensor & angle) {
return wrapper_CompositeExplicitAutograd__polar(abs, angle);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__constant_pad_nd(const at::Tensor & self, c10::SymIntArrayRef pad, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::constant_pad_nd(self, C10_AS_INTARRAYREF_SLOW(pad), value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out(const at::Tensor & self, c10::SymIntArrayRef pad, const at::Scalar & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::constant_pad_nd_out_symint(self, pad, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("constant_pad_nd",
TORCH_FN(wrapper_CompositeExplicitAutograd__constant_pad_nd));
m.impl("constant_pad_nd.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor constant_pad_nd(const at::Tensor & self, at::IntArrayRef pad, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd__constant_pad_nd(self, c10::fromIntArrayRefSlow(pad), value);
}
at::Tensor constant_pad_nd_symint(const at::Tensor & self, c10::SymIntArrayRef pad, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd__constant_pad_nd(self, pad, value);
}
at::Tensor & constant_pad_nd_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef pad, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out(self, c10::fromIntArrayRefSlow(pad), value, out);
}
at::Tensor & constant_pad_nd_outf(const at::Tensor & self, at::IntArrayRef pad, const at::Scalar & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out(self, c10::fromIntArrayRefSlow(pad), value, out);
}
at::Tensor & constant_pad_nd_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef pad, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out(self, pad, value, out);
}
at::Tensor & constant_pad_nd_symint_outf(const at::Tensor & self, c10::SymIntArrayRef pad, const at::Scalar & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_constant_pad_nd_out(self, pad, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution(input, weight, bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(dilation), transposed, C10_AS_INTARRAYREF_SLOW(output_padding), groups.guard_int(__FILE__, __LINE__));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_convolution_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_out_symint(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("convolution",
TORCH_FN(wrapper_CompositeExplicitAutograd__convolution));
m.impl("convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return wrapper_CompositeExplicitAutograd__convolution(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups);
}
at::Tensor convolution_symint(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd__convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
}
at::Tensor & convolution_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, out);
}
at::Tensor & convolution_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, out);
}
at::Tensor & convolution_symint_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_convolution_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
at::Tensor & convolution_symint_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_convolution_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__convolution_backward(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_backward(grad_output, input, weight, bias_sizes.has_value() ? ::std::make_optional(C10_AS_INTARRAYREF_SLOW(*bias_sizes)) : ::std::nullopt, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(dilation), transposed, C10_AS_INTARRAYREF_SLOW(output_padding), groups.guard_int(__FILE__, __LINE__), output_mask);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_convolution_backward_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_backward_out_symint(grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("convolution_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__convolution_backward));
m.impl("convolution_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_convolution_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> convolution_backward(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalIntArrayRef bias_sizes, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd__convolution_backward(grad_output, input, weight, bias_sizes.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*bias_sizes)) : ::std::nullopt, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask);
}
::std::tuple<at::Tensor,at::Tensor,at::Tensor> convolution_backward_symint(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd__convolution_backward(grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalIntArrayRef bias_sizes, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_out(grad_output, input, weight, bias_sizes.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*bias_sizes)) : ::std::nullopt, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalIntArrayRef bias_sizes, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_out(grad_output, input, weight, bias_sizes.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*bias_sizes)) : ::std::nullopt, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_out(grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::OptionalSymIntArrayRef bias_sizes, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_out(grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__convolution_overrideable(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_overrideable(input, weight, bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(dilation), transposed, C10_AS_INTARRAYREF_SLOW(output_padding), groups.guard_int(__FILE__, __LINE__));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_overrideable_out_symint(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("convolution_overrideable",
TORCH_FN(wrapper_CompositeExplicitAutograd__convolution_overrideable));
m.impl("convolution_overrideable.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor convolution_overrideable(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return wrapper_CompositeExplicitAutograd__convolution_overrideable(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups);
}
at::Tensor convolution_overrideable_symint(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd__convolution_overrideable(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups);
}
at::Tensor & convolution_overrideable_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, out);
}
at::Tensor & convolution_overrideable_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, out);
}
at::Tensor & convolution_overrideable_symint_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
at::Tensor & convolution_overrideable_symint_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_convolution_overrideable_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__convolution_backward_overrideable(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_backward_overrideable(grad_output, input, weight, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(dilation), transposed, C10_AS_INTARRAYREF_SLOW(output_padding), groups.guard_int(__FILE__, __LINE__), output_mask);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::convolution_backward_overrideable_out_symint(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("convolution_backward_overrideable",
TORCH_FN(wrapper_CompositeExplicitAutograd__convolution_backward_overrideable));
m.impl("convolution_backward_overrideable.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> convolution_backward_overrideable(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd__convolution_backward_overrideable(grad_output, input, weight, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask);
}
::std::tuple<at::Tensor,at::Tensor,at::Tensor> convolution_backward_overrideable_symint(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd__convolution_backward_overrideable(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_overrideable_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out(grad_output, input, weight, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_overrideable_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out(grad_output, input, weight, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_overrideable_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> convolution_backward_overrideable_symint_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_convolution_backward_overrideable_out(grad_output, input, weight, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
    // No device check
  // DeviceGuard omitted
  return at::native::_convolution(input, weight, bias, C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(dilation), transposed, C10_AS_INTARRAYREF_SLOW(output_padding), groups.guard_int(__FILE__, __LINE__), benchmark, deterministic, cudnn_enabled, allow_tf32);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__convolution_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_convolution_out_symint(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_convolution",
TORCH_FN(wrapper_CompositeExplicitAutograd___convolution));
m.impl("_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd___convolution(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, benchmark, deterministic, cudnn_enabled, allow_tf32);
}
at::Tensor _convolution_symint(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd___convolution(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32);
}
at::Tensor & _convolution_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd_out__convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, benchmark, deterministic, cudnn_enabled, allow_tf32, out);
}
at::Tensor & _convolution_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool transposed, at::IntArrayRef output_padding, int64_t groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), transposed, c10::fromIntArrayRefSlow(output_padding), groups, benchmark, deterministic, cudnn_enabled, allow_tf32, out);
}
at::Tensor & _convolution_symint_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd_out__convolution_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32, out);
}
at::Tensor & _convolution_symint_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, bool benchmark, bool deterministic, bool cudnn_enabled, bool allow_tf32, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__convolution_out(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, benchmark, deterministic, cudnn_enabled, allow_tf32, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__conv_tbc(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad) {
    // No device check
  // DeviceGuard omitted
  return at::native::conv_tbc(self, weight, bias, pad);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_conv_tbc_out(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::conv_tbc_out(self, weight, bias, pad, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("conv_tbc",
TORCH_FN(wrapper_CompositeExplicitAutograd__conv_tbc));
m.impl("conv_tbc.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_conv_tbc_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor conv_tbc(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad) {
return wrapper_CompositeExplicitAutograd__conv_tbc(self, weight, bias, pad);
}
at::Tensor & conv_tbc_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad) {
return wrapper_CompositeExplicitAutograd_out_conv_tbc_out(self, weight, bias, pad, out);
}
at::Tensor & conv_tbc_outf(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & bias, int64_t pad, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_conv_tbc_out(self, weight, bias, pad, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_copy_out(const at::Tensor & self, const at::Tensor & src, bool non_blocking, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::copy_out(self, src, non_blocking, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__copy_(at::Tensor & self, const at::Tensor & src, bool non_blocking) {
    // No device check
  // DeviceGuard omitted
  return at::native::copy_(self, src, non_blocking);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_copy_out));
m.impl("copy_",
TORCH_FN(wrapper_CompositeExplicitAutograd__copy_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & copy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd_out_copy_out(self, src, non_blocking, out);
}
at::Tensor & copy_outf(const at::Tensor & self, const at::Tensor & src, bool non_blocking, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_copy_out(self, src, non_blocking, out);
}
at::Tensor & copy_(at::Tensor & self, const at::Tensor & src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd__copy_(self, src, non_blocking);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__copy_from_out(const at::Tensor & self, const at::Tensor & dst, bool non_blocking, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_copy_from_out(self, dst, non_blocking, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_copy_from.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__copy_from_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _copy_from_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & dst, bool non_blocking) {
return wrapper_CompositeExplicitAutograd_out__copy_from_out(self, dst, non_blocking, out);
}
at::Tensor & _copy_from_outf(const at::Tensor & self, const at::Tensor & dst, bool non_blocking, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__copy_from_out(self, dst, non_blocking, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__copy_from_and_resize_out(const at::Tensor & self, const at::Tensor & dst, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_copy_from_and_resize_out(self, dst, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_copy_from_and_resize.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__copy_from_and_resize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _copy_from_and_resize_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & dst) {
return wrapper_CompositeExplicitAutograd_out__copy_from_and_resize_out(self, dst, out);
}
at::Tensor & _copy_from_and_resize_outf(const at::Tensor & self, const at::Tensor & dst, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__copy_from_and_resize_out(self, dst, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_IntList_out_count_nonzero_out(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::count_nonzero_dim_IntList_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("count_nonzero.dim_IntList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_IntList_out_count_nonzero_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & count_nonzero_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dim_IntList_out_count_nonzero_out(self, dim, out);
}
at::Tensor & count_nonzero_outf(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dim_IntList_out_count_nonzero_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__count_nonzero(const at::Tensor & self, ::std::optional<int64_t> dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::count_nonzero(self, dim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_count_nonzero_out(const at::Tensor & self, ::std::optional<int64_t> dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::count_nonzero_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("count_nonzero",
TORCH_FN(wrapper_CompositeExplicitAutograd__count_nonzero));
m.impl("count_nonzero.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_count_nonzero_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor count_nonzero(const at::Tensor & self, ::std::optional<int64_t> dim) {
return wrapper_CompositeExplicitAutograd__count_nonzero(self, dim);
}
at::Tensor & count_nonzero_out(at::Tensor & out, const at::Tensor & self, ::std::optional<int64_t> dim) {
return wrapper_CompositeExplicitAutograd_out_count_nonzero_out(self, dim, out);
}
at::Tensor & count_nonzero_outf(const at::Tensor & self, ::std::optional<int64_t> dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_count_nonzero_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_out(const at::Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_affine_grid_generator_out(theta, N, C, H, W, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_affine_grid_generator.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_affine_grid_generator_out(at::Tensor & out, const at::Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W) {
return wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_out(theta, N, C, H, W, out);
}
at::Tensor & cudnn_affine_grid_generator_outf(const at::Tensor & theta, int64_t N, int64_t C, int64_t H, int64_t W, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_out(theta, N, C, H, W, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_backward_out(const at::Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_affine_grid_generator_backward_out(grad, N, C, H, W, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_affine_grid_generator_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_affine_grid_generator_backward_out(at::Tensor & out, const at::Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W) {
return wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_backward_out(grad, N, C, H, W, out);
}
at::Tensor & cudnn_affine_grid_generator_backward_outf(const at::Tensor & grad, int64_t N, int64_t C, int64_t H, int64_t W, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_affine_grid_generator_backward_out(grad, N, C, H, W, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_batch_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> cudnn_batch_norm_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon) {
return wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> cudnn_batch_norm_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_backward_out(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon, const at::Tensor & reserveSpace, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_batch_norm_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> cudnn_batch_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon, const at::Tensor & reserveSpace) {
return wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> cudnn_batch_norm_backward_outf(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon, const at::Tensor & reserveSpace, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_cudnn_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, reserveSpace, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_convolution_transpose_out_symint(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_convolution_transpose.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
}
at::Tensor & cudnn_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, allow_tf32, out);
}
at::Tensor & cudnn_convolution_transpose_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
}
at::Tensor & cudnn_convolution_transpose_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, bool allow_tf32, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_transpose_out(self, weight, padding, output_padding, stride, dilation, groups, benchmark, deterministic, allow_tf32, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_mps_convolution_transpose_out_symint(self, weight, padding, output_padding, stride, dilation, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_mps_convolution_transpose.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _mps_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & _mps_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out(self, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & _mps_convolution_transpose_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out(self, weight, padding, output_padding, stride, dilation, groups, out);
}
at::Tensor & _mps_convolution_transpose_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_transpose_out(self, weight, padding, output_padding, stride, dilation, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::mps_convolution_transpose_backward_out_symint(self, grad_output, weight, padding, output_padding, stride, dilation, groups, output_mask, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mps_convolution_transpose_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> mps_convolution_transpose_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,2> output_mask) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> mps_convolution_transpose_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> mps_convolution_transpose_backward_symint_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,2> output_mask) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out(self, grad_output, weight, padding, output_padding, stride, dilation, groups, output_mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> mps_convolution_transpose_backward_symint_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_transpose_backward_out(self, grad_output, weight, padding, output_padding, stride, dilation, groups, output_mask, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_convolution_relu_out_symint(self, weight, bias, stride, padding, dilation, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_convolution_relu.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_convolution_relu_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out(self, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & cudnn_convolution_relu_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out(self, weight, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & cudnn_convolution_relu_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out(self, weight, bias, stride, padding, dilation, groups, out);
}
at::Tensor & cudnn_convolution_relu_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_relu_out(self, weight, bias, stride, padding, dilation, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const ::std::optional<at::Scalar> & alpha, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_convolution_add_relu_out_symint(self, weight, z, alpha, bias, stride, padding, dilation, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_convolution_add_relu.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_convolution_add_relu_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const ::std::optional<at::Scalar> & alpha, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out(self, weight, z, alpha, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & cudnn_convolution_add_relu_outf(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const ::std::optional<at::Scalar> & alpha, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out(self, weight, z, alpha, bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & cudnn_convolution_add_relu_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const ::std::optional<at::Scalar> & alpha, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out(self, weight, z, alpha, bias, stride, padding, dilation, groups, out);
}
at::Tensor & cudnn_convolution_add_relu_symint_outf(const at::Tensor & self, const at::Tensor & weight, const at::Tensor & z, const ::std::optional<at::Scalar> & alpha, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_convolution_add_relu_out(self, weight, z, alpha, bias, stride, padding, dilation, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_out(const at::Tensor & self, const at::Tensor & grid, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_grid_sampler_out(self, grid, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_grid_sampler.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & cudnn_grid_sampler_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & grid) {
return wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_out(self, grid, out);
}
at::Tensor & cudnn_grid_sampler_outf(const at::Tensor & self, const at::Tensor & grid, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_out(self, grid, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_backward_out(const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::cudnn_grid_sampler_backward_out(self, grid, grad_output, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cudnn_grid_sampler_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> cudnn_grid_sampler_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output) {
return wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_backward_out(self, grid, grad_output, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> cudnn_grid_sampler_backward_outf(const at::Tensor & self, const at::Tensor & grid, const at::Tensor & grad_output, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_cudnn_grid_sampler_backward_out(self, grid, grad_output, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__cummax(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::cummax(self, dim);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_cummax_out(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
    // No device check
  // DeviceGuard omitted
  return at::native::cummax_out(self, dim, values, indices);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cummax",
TORCH_FN(wrapper_CompositeExplicitAutograd__cummax));
m.impl("cummax.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cummax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> cummax(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd__cummax(self, dim);
}
::std::tuple<at::Tensor &,at::Tensor &> cummax_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_cummax_out(self, dim, values, indices);
}
::std::tuple<at::Tensor &,at::Tensor &> cummax_outf(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
return wrapper_CompositeExplicitAutograd_out_cummax_out(self, dim, values, indices);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__cummin(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::cummin(self, dim);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_cummin_out(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
    // No device check
  // DeviceGuard omitted
  return at::native::cummin_out(self, dim, values, indices);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cummin",
TORCH_FN(wrapper_CompositeExplicitAutograd__cummin));
m.impl("cummin.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cummin_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> cummin(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd__cummin(self, dim);
}
::std::tuple<at::Tensor &,at::Tensor &> cummin_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_cummin_out(self, dim, values, indices);
}
::std::tuple<at::Tensor &,at::Tensor &> cummin_outf(const at::Tensor & self, int64_t dim, at::Tensor & values, at::Tensor & indices) {
return wrapper_CompositeExplicitAutograd_out_cummin_out(self, dim, values, indices);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__ctc_loss_out(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_ctc_loss.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__ctc_loss_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity) {
return wrapper_CompositeExplicitAutograd_out__ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_outf(const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_Tensor_out__ctc_loss_out(const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_ctc_loss_Tensor_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_ctc_loss.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__ctc_loss_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank, bool zero_infinity) {
return wrapper_CompositeExplicitAutograd_Tensor_out__ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _ctc_loss_outf(const at::Tensor & log_probs, const at::Tensor & targets, const at::Tensor & input_lengths, const at::Tensor & target_lengths, int64_t blank, bool zero_infinity, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_Tensor_out__ctc_loss_out(log_probs, targets, input_lengths, target_lengths, blank, zero_infinity, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__ctc_loss_backward_out(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_ctc_loss_backward_out(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_ctc_loss_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__ctc_loss_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _ctc_loss_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity) {
return wrapper_CompositeExplicitAutograd_out__ctc_loss_backward_out(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity, out);
}
at::Tensor & _ctc_loss_backward_outf(const at::Tensor & grad, const at::Tensor & log_probs, const at::Tensor & targets, at::IntArrayRef input_lengths, at::IntArrayRef target_lengths, const at::Tensor & neg_log_likelihood, const at::Tensor & log_alpha, int64_t blank, bool zero_infinity, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__ctc_loss_backward_out(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, blank, zero_infinity, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_diag_embed_out(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::diag_embed_out(self, offset, dim1, dim2, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("diag_embed.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_diag_embed_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & diag_embed_out(at::Tensor & out, const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd_out_diag_embed_out(self, offset, dim1, dim2, out);
}
at::Tensor & diag_embed_outf(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_diag_embed_out(self, offset, dim1, dim2, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__diagonal(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
    // No device check
  // DeviceGuard omitted
  return at::native::diagonal(self, offset, dim1, dim2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("diagonal",
TORCH_FN(wrapper_CompositeExplicitAutograd__diagonal));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor diagonal(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd__diagonal(self, offset, dim1, dim2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__diagonal_backward(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
    // No device check
  // DeviceGuard omitted
  return at::native::diagonal_backward_symint(grad_output, input_sizes, offset, dim1, dim2);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_diagonal_backward_out(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::diagonal_backward_out_symint(grad_output, input_sizes, offset, dim1, dim2, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("diagonal_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__diagonal_backward));
m.impl("diagonal_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_diagonal_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor diagonal_backward(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd__diagonal_backward(grad_output, c10::fromIntArrayRefSlow(input_sizes), offset, dim1, dim2);
}
at::Tensor diagonal_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd__diagonal_backward(grad_output, input_sizes, offset, dim1, dim2);
}
at::Tensor & diagonal_backward_out(at::Tensor & out, const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd_out_diagonal_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), offset, dim1, dim2, out);
}
at::Tensor & diagonal_backward_outf(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_diagonal_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), offset, dim1, dim2, out);
}
at::Tensor & diagonal_backward_symint_out(at::Tensor & out, const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd_out_diagonal_backward_out(grad_output, input_sizes, offset, dim1, dim2, out);
}
at::Tensor & diagonal_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_diagonal_backward_out(grad_output, input_sizes, offset, dim1, dim2, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_div(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::div(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_div_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::div_Scalar_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_div_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::div_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("div.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_div));
m.impl("div.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_div_out));
m.impl("div_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor div(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_div(self, other);
}
at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_div_out(self, other, out);
}
at::Tensor & div_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_div_out(self, other, out);
}
at::Tensor & div_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_div_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_mode_div(const at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode) {
    // No device check
  // DeviceGuard omitted
  return at::native::div(self, other, rounding_mode);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_mode_out_div_out(const at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::div_Scalar_mode_out(self, other, rounding_mode, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_mode_div_(at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode) {
    // No device check
  // DeviceGuard omitted
  return at::native::div_(self, other, rounding_mode);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("div.Scalar_mode",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_mode_div));
m.impl("div.Scalar_mode_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_mode_out_div_out));
m.impl("div_.Scalar_mode",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_mode_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor div(const at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode) {
return wrapper_CompositeExplicitAutograd_Scalar_mode_div(self, other, rounding_mode);
}
at::Tensor & div_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode) {
return wrapper_CompositeExplicitAutograd_Scalar_mode_out_div_out(self, other, rounding_mode, out);
}
at::Tensor & div_outf(const at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_mode_out_div_out(self, other, rounding_mode, out);
}
at::Tensor & div_(at::Tensor & self, const at::Scalar & other, ::std::optional<c10::string_view> rounding_mode) {
return wrapper_CompositeExplicitAutograd_Scalar_mode_div_(self, other, rounding_mode);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_dot_out(const at::Tensor & self, const at::Tensor & tensor, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::dot_out(self, tensor, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("dot.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_dot_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & dot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & tensor) {
return wrapper_CompositeExplicitAutograd_out_dot_out(self, tensor, out);
}
at::Tensor & dot_outf(const at::Tensor & self, const at::Tensor & tensor, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_dot_out(self, tensor, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_vdot_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::vdot_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("vdot.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_vdot_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & vdot_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_out_vdot_out(self, other, out);
}
at::Tensor & vdot_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_vdot_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__embedding(const at::Tensor & weight, const at::Tensor & indices, c10::SymInt padding_idx, bool scale_grad_by_freq, bool sparse) {
    // No device check
  // DeviceGuard omitted
  return at::native::embedding_symint(weight, indices, padding_idx, scale_grad_by_freq, sparse);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_embedding_out(const at::Tensor & weight, const at::Tensor & indices, c10::SymInt padding_idx, bool scale_grad_by_freq, bool sparse, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::embedding_out_symint(weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("embedding",
TORCH_FN(wrapper_CompositeExplicitAutograd__embedding));
m.impl("embedding.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_embedding_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor embedding(const at::Tensor & weight, const at::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
return wrapper_CompositeExplicitAutograd__embedding(weight, indices, padding_idx, scale_grad_by_freq, sparse);
}
at::Tensor embedding_symint(const at::Tensor & weight, const at::Tensor & indices, c10::SymInt padding_idx, bool scale_grad_by_freq, bool sparse) {
return wrapper_CompositeExplicitAutograd__embedding(weight, indices, padding_idx, scale_grad_by_freq, sparse);
}
at::Tensor & embedding_out(at::Tensor & out, const at::Tensor & weight, const at::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse) {
return wrapper_CompositeExplicitAutograd_out_embedding_out(weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
}
at::Tensor & embedding_outf(const at::Tensor & weight, const at::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_embedding_out(weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
}
at::Tensor & embedding_symint_out(at::Tensor & out, const at::Tensor & weight, const at::Tensor & indices, c10::SymInt padding_idx, bool scale_grad_by_freq, bool sparse) {
return wrapper_CompositeExplicitAutograd_out_embedding_out(weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
}
at::Tensor & embedding_symint_outf(const at::Tensor & weight, const at::Tensor & indices, c10::SymInt padding_idx, bool scale_grad_by_freq, bool sparse, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_embedding_out(weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out(const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::embedding_dense_backward_out_symint(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("embedding_dense_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & embedding_dense_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq) {
return wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq, out);
}
at::Tensor & embedding_dense_backward_outf(const at::Tensor & grad_output, const at::Tensor & indices, int64_t num_weights, int64_t padding_idx, bool scale_grad_by_freq, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq, out);
}
at::Tensor & embedding_dense_backward_symint_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq) {
return wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq, out);
}
at::Tensor & embedding_dense_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & indices, c10::SymInt num_weights, c10::SymInt padding_idx, bool scale_grad_by_freq, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_embedding_dense_backward_out(grad_output, indices, num_weights, padding_idx, scale_grad_by_freq, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__embedding_renorm(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) {
    // No device check
  // DeviceGuard omitted
  return at::native::embedding_renorm(self, indices, max_norm, norm_type);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_embedding_renorm_out(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::embedding_renorm_out(self, indices, max_norm, norm_type, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("embedding_renorm",
TORCH_FN(wrapper_CompositeExplicitAutograd__embedding_renorm));
m.impl("embedding_renorm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_embedding_renorm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor embedding_renorm(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) {
return wrapper_CompositeExplicitAutograd__embedding_renorm(self, indices, max_norm, norm_type);
}
at::Tensor & embedding_renorm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type) {
return wrapper_CompositeExplicitAutograd_out_embedding_renorm_out(self, indices, max_norm, norm_type, out);
}
at::Tensor & embedding_renorm_outf(const at::Tensor & self, const at::Tensor & indices, double max_norm, double norm_type, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_embedding_renorm_out(self, indices, max_norm, norm_type, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__embedding_bag_forward_only_out(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::_embedding_bag_forward_only_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_embedding_bag_forward_only.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__embedding_bag_forward_only_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _embedding_bag_forward_only_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_forward_only_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _embedding_bag_forward_only_outf(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_forward_only_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__embedding_bag_out(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::_embedding_bag_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_embedding_bag.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__embedding_bag_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _embedding_bag_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _embedding_bag_outf(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const ::std::optional<at::Tensor> & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_out(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out(const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, c10::SymInt num_weights, bool scale_grad_by_freq, int64_t mode, const ::std::optional<at::Tensor> & per_sample_weights, int64_t padding_idx, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_embedding_bag_dense_backward_out_symint(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_embedding_bag_dense_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _embedding_bag_dense_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, int64_t num_weights, bool scale_grad_by_freq, int64_t mode, const ::std::optional<at::Tensor> & per_sample_weights, int64_t padding_idx) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx, out);
}
at::Tensor & _embedding_bag_dense_backward_outf(const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, int64_t num_weights, bool scale_grad_by_freq, int64_t mode, const ::std::optional<at::Tensor> & per_sample_weights, int64_t padding_idx, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx, out);
}
at::Tensor & _embedding_bag_dense_backward_symint_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, c10::SymInt num_weights, bool scale_grad_by_freq, int64_t mode, const ::std::optional<at::Tensor> & per_sample_weights, int64_t padding_idx) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx, out);
}
at::Tensor & _embedding_bag_dense_backward_symint_outf(const at::Tensor & grad, const at::Tensor & indices, const at::Tensor & offset2bag, const at::Tensor & bag_size, const at::Tensor & maximum_indices, c10::SymInt num_weights, bool scale_grad_by_freq, int64_t mode, const ::std::optional<at::Tensor> & per_sample_weights, int64_t padding_idx, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_dense_backward_out(grad, indices, offset2bag, bag_size, maximum_indices, num_weights, scale_grad_by_freq, mode, per_sample_weights, padding_idx, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__embedding_bag_per_sample_weights_backward_out(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_embedding_bag_per_sample_weights_backward_out(grad, weight, indices, offsets, offset2bag, mode, padding_idx, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_embedding_bag_per_sample_weights_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__embedding_bag_per_sample_weights_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _embedding_bag_per_sample_weights_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_per_sample_weights_backward_out(grad, weight, indices, offsets, offset2bag, mode, padding_idx, out);
}
at::Tensor & _embedding_bag_per_sample_weights_backward_outf(const at::Tensor & grad, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, const at::Tensor & offset2bag, int64_t mode, int64_t padding_idx, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__embedding_bag_per_sample_weights_backward_out(grad, weight, indices, offsets, offset2bag, mode, padding_idx, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_empty(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_names(size, names, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_empty_out(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_names_out(size, names, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("empty.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_empty));
m.impl("empty.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_empty_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor empty(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_names_empty(size, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor empty(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_names_empty(size, names, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & empty_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_names_out_empty_out(size, names, memory_format, out);
}
at::Tensor & empty_outf(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_empty_out(size, names, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__empty_permuted(c10::SymIntArrayRef size, at::IntArrayRef physical_layout, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_permuted_symint(size, physical_layout, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_empty_permuted_out(c10::SymIntArrayRef size, at::IntArrayRef physical_layout, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_permuted_out_symint(size, physical_layout, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("empty_permuted",
TORCH_FN(wrapper_CompositeExplicitAutograd__empty_permuted));
m.impl("empty_permuted.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_empty_permuted_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor empty_permuted(at::IntArrayRef size, at::IntArrayRef physical_layout, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__empty_permuted(c10::fromIntArrayRefSlow(size), physical_layout, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor empty_permuted(at::IntArrayRef size, at::IntArrayRef physical_layout, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__empty_permuted(c10::fromIntArrayRefSlow(size), physical_layout, dtype, layout, device, pin_memory);
}
at::Tensor empty_permuted_symint(c10::SymIntArrayRef size, at::IntArrayRef physical_layout, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__empty_permuted(size, physical_layout, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor empty_permuted_symint(c10::SymIntArrayRef size, at::IntArrayRef physical_layout, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__empty_permuted(size, physical_layout, dtype, layout, device, pin_memory);
}
at::Tensor & empty_permuted_out(at::Tensor & out, at::IntArrayRef size, at::IntArrayRef physical_layout) {
return wrapper_CompositeExplicitAutograd_out_empty_permuted_out(c10::fromIntArrayRefSlow(size), physical_layout, out);
}
at::Tensor & empty_permuted_outf(at::IntArrayRef size, at::IntArrayRef physical_layout, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_permuted_out(c10::fromIntArrayRefSlow(size), physical_layout, out);
}
at::Tensor & empty_permuted_symint_out(at::Tensor & out, c10::SymIntArrayRef size, at::IntArrayRef physical_layout) {
return wrapper_CompositeExplicitAutograd_out_empty_permuted_out(size, physical_layout, out);
}
at::Tensor & empty_permuted_symint_outf(c10::SymIntArrayRef size, at::IntArrayRef physical_layout, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_permuted_out(size, physical_layout, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__new_empty(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_empty_symint(self, size, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_new_empty_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_empty_out_symint(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("new_empty",
TORCH_FN(wrapper_CompositeExplicitAutograd__new_empty));
m.impl("new_empty.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_new_empty_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor new_empty(const at::Tensor & self, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_empty(self, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_empty(const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_empty(self, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor new_empty_symint(const at::Tensor & self, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_empty(self, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_empty_symint(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_empty(self, size, dtype, layout, device, pin_memory);
}
at::Tensor & new_empty_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_empty_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_empty_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_empty_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_empty_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_empty_out(self, size, out);
}
at::Tensor & new_empty_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_empty_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_new_empty_strided_out(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_empty_strided_out_symint(self, size, stride, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("new_empty_strided.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_new_empty_strided_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & new_empty_strided_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out_new_empty_strided_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & new_empty_strided_outf(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_empty_strided_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & new_empty_strided_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out_new_empty_strided_out(self, size, stride, out);
}
at::Tensor & new_empty_strided_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_empty_strided_out(self, size, stride, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__new_full(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_full(self, C10_AS_INTARRAYREF_SLOW(size), fill_value, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_new_full_out(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_full_out_symint(self, size, fill_value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("new_full",
TORCH_FN(wrapper_CompositeExplicitAutograd__new_full));
m.impl("new_full.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_new_full_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor new_full(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_full(self, c10::fromIntArrayRefSlow(size), fill_value, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_full(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_full(self, c10::fromIntArrayRefSlow(size), fill_value, dtype, layout, device, pin_memory);
}
at::Tensor new_full_symint(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_full(self, size, fill_value, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_full_symint(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_full(self, size, fill_value, dtype, layout, device, pin_memory);
}
at::Tensor & new_full_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value) {
return wrapper_CompositeExplicitAutograd_out_new_full_out(self, c10::fromIntArrayRefSlow(size), fill_value, out);
}
at::Tensor & new_full_outf(const at::Tensor & self, at::IntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_full_out(self, c10::fromIntArrayRefSlow(size), fill_value, out);
}
at::Tensor & new_full_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value) {
return wrapper_CompositeExplicitAutograd_out_new_full_out(self, size, fill_value, out);
}
at::Tensor & new_full_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_full_out(self, size, fill_value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__new_zeros(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_zeros(self, C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_new_zeros_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_zeros_out_symint(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("new_zeros",
TORCH_FN(wrapper_CompositeExplicitAutograd__new_zeros));
m.impl("new_zeros.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_new_zeros_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor new_zeros(const at::Tensor & self, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_zeros(self, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_zeros(const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_zeros(self, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor new_zeros_symint(const at::Tensor & self, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_zeros(self, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_zeros_symint(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_zeros(self, size, dtype, layout, device, pin_memory);
}
at::Tensor & new_zeros_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_zeros_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_zeros_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_zeros_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_zeros_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_zeros_out(self, size, out);
}
at::Tensor & new_zeros_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_zeros_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__new_ones(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_ones(self, C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_new_ones_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::new_ones_out_symint(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("new_ones",
TORCH_FN(wrapper_CompositeExplicitAutograd__new_ones));
m.impl("new_ones.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_new_ones_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor new_ones(const at::Tensor & self, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_ones(self, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_ones(const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_ones(self, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor new_ones_symint(const at::Tensor & self, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__new_ones(self, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor new_ones_symint(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__new_ones(self, size, dtype, layout, device, pin_memory);
}
at::Tensor & new_ones_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_ones_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_ones_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_ones_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & new_ones_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_new_ones_out(self, size, out);
}
at::Tensor & new_ones_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_new_ones_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out(c10::SymIntArrayRef size, double scale, int64_t zero_point, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_empty_affine_quantized_out_symint(size, scale, zero_point, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_empty_affine_quantized.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _empty_affine_quantized_out(at::Tensor & out, at::IntArrayRef size, double scale, int64_t zero_point, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out(c10::fromIntArrayRefSlow(size), scale, zero_point, memory_format, out);
}
at::Tensor & _empty_affine_quantized_outf(at::IntArrayRef size, double scale, int64_t zero_point, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out(c10::fromIntArrayRefSlow(size), scale, zero_point, memory_format, out);
}
at::Tensor & _empty_affine_quantized_symint_out(at::Tensor & out, c10::SymIntArrayRef size, double scale, int64_t zero_point, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out(size, scale, zero_point, memory_format, out);
}
at::Tensor & _empty_affine_quantized_symint_outf(c10::SymIntArrayRef size, double scale, int64_t zero_point, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__empty_affine_quantized_out(size, scale, zero_point, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out(c10::SymIntArrayRef size, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_empty_per_channel_affine_quantized_out_symint(size, scales, zero_points, axis, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_empty_per_channel_affine_quantized.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _empty_per_channel_affine_quantized_out(at::Tensor & out, at::IntArrayRef size, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out(c10::fromIntArrayRefSlow(size), scales, zero_points, axis, memory_format, out);
}
at::Tensor & _empty_per_channel_affine_quantized_outf(at::IntArrayRef size, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out(c10::fromIntArrayRefSlow(size), scales, zero_points, axis, memory_format, out);
}
at::Tensor & _empty_per_channel_affine_quantized_symint_out(at::Tensor & out, c10::SymIntArrayRef size, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out(size, scales, zero_points, axis, memory_format, out);
}
at::Tensor & _empty_per_channel_affine_quantized_symint_outf(c10::SymIntArrayRef size, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__empty_per_channel_affine_quantized_out(size, scales, zero_points, axis, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__resize(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_symint(self, size, memory_format);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out_resize_out(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::MemoryFormat> memory_format, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_out_symint(self, size, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("resize",
TORCH_FN(wrapper_CompositeExplicitAutograd__resize));
m.impl("resize.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_resize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor resize(const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__resize(self, c10::fromIntArrayRefSlow(size), memory_format);
}
at::Tensor resize_symint(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__resize(self, size, memory_format);
}
const at::Tensor & resize_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_resize_out(self, c10::fromIntArrayRefSlow(size), memory_format, out);
}
const at::Tensor & resize_outf(const at::Tensor & self, at::IntArrayRef size, ::std::optional<at::MemoryFormat> memory_format, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_resize_out(self, c10::fromIntArrayRefSlow(size), memory_format, out);
}
const at::Tensor & resize_symint_out(const at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_resize_out(self, size, memory_format, out);
}
const at::Tensor & resize_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, ::std::optional<at::MemoryFormat> memory_format, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_resize_out(self, size, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___resize_output(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device) {
    // No device check
  // DeviceGuard omitted
  return at::native::_resize_output_symint(self, size, device);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out__resize_output_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_resize_output_out_symint(self, size, device, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_resize_output",
TORCH_FN(wrapper_CompositeExplicitAutograd___resize_output));
m.impl("_resize_output.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__resize_output_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _resize_output(const at::Tensor & self, at::IntArrayRef size, at::Device device) {
return wrapper_CompositeExplicitAutograd___resize_output(self, c10::fromIntArrayRefSlow(size), device);
}
at::Tensor _resize_output_symint(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device) {
return wrapper_CompositeExplicitAutograd___resize_output(self, size, device);
}
const at::Tensor & _resize_output_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, at::Device device) {
return wrapper_CompositeExplicitAutograd_out__resize_output_out(self, c10::fromIntArrayRefSlow(size), device, out);
}
const at::Tensor & _resize_output_outf(const at::Tensor & self, at::IntArrayRef size, at::Device device, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__resize_output_out(self, c10::fromIntArrayRefSlow(size), device, out);
}
const at::Tensor & _resize_output_symint_out(const at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, at::Device device) {
return wrapper_CompositeExplicitAutograd_out__resize_output_out(self, size, device, out);
}
const at::Tensor & _resize_output_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Device device, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__resize_output_out(self, size, device, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_empty_quantized_out(at::IntArrayRef size, const at::Tensor & qtensor, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_quantized_out(size, qtensor, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("empty_quantized.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_empty_quantized_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & empty_quantized_out(at::Tensor & out, at::IntArrayRef size, const at::Tensor & qtensor, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_empty_quantized_out(size, qtensor, memory_format, out);
}
at::Tensor & empty_quantized_outf(at::IntArrayRef size, const at::Tensor & qtensor, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_quantized_out(size, qtensor, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__empty_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_like(self, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_empty_like_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_like_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("empty_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__empty_like));
m.impl("empty_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_empty_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor empty_like(const at::Tensor & self, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__empty_like(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor empty_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__empty_like(self, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & empty_like_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_empty_like_out(self, memory_format, out);
}
at::Tensor & empty_like_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_like_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_empty_strided_out(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::empty_strided_out_symint(size, stride, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("empty_strided.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_empty_strided_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & empty_strided_out(at::Tensor & out, at::IntArrayRef size, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out_empty_strided_out(c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & empty_strided_outf(at::IntArrayRef size, at::IntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_strided_out(c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & empty_strided_symint_out(at::Tensor & out, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out_empty_strided_out(size, stride, out);
}
at::Tensor & empty_strided_symint_outf(c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_empty_strided_out(size, stride, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__expand(const at::Tensor & self, c10::SymIntArrayRef size, bool implicit) {
    // No device check
  // DeviceGuard omitted
  return at::native::expand(self, C10_AS_INTARRAYREF_SLOW(size), implicit);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("expand",
TORCH_FN(wrapper_CompositeExplicitAutograd__expand));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor expand(const at::Tensor & self, at::IntArrayRef size, bool implicit) {
return wrapper_CompositeExplicitAutograd__expand(self, c10::fromIntArrayRefSlow(size), implicit);
}
at::Tensor expand_symint(const at::Tensor & self, c10::SymIntArrayRef size, bool implicit) {
return wrapper_CompositeExplicitAutograd__expand(self, size, implicit);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__eye(c10::SymInt n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::eye(n.guard_int(__FILE__, __LINE__), dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("eye",
TORCH_FN(wrapper_CompositeExplicitAutograd__eye));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor eye(int64_t n, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__eye(n, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor eye(int64_t n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__eye(n, dtype, layout, device, pin_memory);
}
at::Tensor eye_symint(c10::SymInt n, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__eye(n, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor eye_symint(c10::SymInt n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__eye(n, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_m_eye(c10::SymInt n, c10::SymInt m, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::eye(n.guard_int(__FILE__, __LINE__), m.guard_int(__FILE__, __LINE__), dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("eye.m",
TORCH_FN(wrapper_CompositeExplicitAutograd_m_eye));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor eye(int64_t n, int64_t m, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_m_eye(n, m, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor eye(int64_t n, int64_t m, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_m_eye(n, m, dtype, layout, device, pin_memory);
}
at::Tensor eye_symint(c10::SymInt n, c10::SymInt m, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_m_eye(n, m, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor eye_symint(c10::SymInt n, c10::SymInt m, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_m_eye(n, m, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_fill(const at::Tensor & self, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::fill(self, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_fill_out(const at::Tensor & self, const at::Scalar & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::fill_Scalar_out(self, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fill.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_fill));
m.impl("fill.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor fill(const at::Tensor & self, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_fill(self, value);
}
at::Tensor & fill_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_out_fill_out(self, value, out);
}
at::Tensor & fill_outf(const at::Tensor & self, const at::Scalar & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_fill_out(self, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_fill(const at::Tensor & self, const at::Tensor & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::fill(self, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_fill_out(const at::Tensor & self, const at::Tensor & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::fill_Tensor_out(self, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fill.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_fill));
m.impl("fill.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor fill(const at::Tensor & self, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_Tensor_fill(self, value);
}
at::Tensor & fill_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_Tensor_out_fill_out(self, value, out);
}
at::Tensor & fill_outf(const at::Tensor & self, const at::Tensor & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_fill_out(self, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_floor_divide(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::floor_divide(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_floor_divide_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::floor_divide_Scalar_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_floor_divide_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::floor_divide_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("floor_divide.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_floor_divide));
m.impl("floor_divide.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_floor_divide_out));
m.impl("floor_divide_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_floor_divide_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor floor_divide(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_floor_divide(self, other);
}
at::Tensor & floor_divide_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_floor_divide_out(self, other, out);
}
at::Tensor & floor_divide_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_floor_divide_out(self, other, out);
}
at::Tensor & floor_divide_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_floor_divide_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_full(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::full(size, fill_value, names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_full_out(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::full_names_out(size, fill_value, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("full.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_full));
m.impl("full.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_full_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor full(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_full(size, fill_value, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor full(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_full(size, fill_value, names, dtype, layout, device, pin_memory);
}
at::Tensor & full_out(at::Tensor & out, at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_full_out(size, fill_value, names, out);
}
at::Tensor & full_outf(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_full_out(size, fill_value, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__full(c10::SymIntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::full(C10_AS_INTARRAYREF_SLOW(size), fill_value, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_full_out(c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::full_out(C10_AS_INTARRAYREF_SLOW(size), fill_value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("full",
TORCH_FN(wrapper_CompositeExplicitAutograd__full));
m.impl("full.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_full_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor full(at::IntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__full(c10::fromIntArrayRefSlow(size), fill_value, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor full(at::IntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__full(c10::fromIntArrayRefSlow(size), fill_value, dtype, layout, device, pin_memory);
}
at::Tensor full_symint(c10::SymIntArrayRef size, const at::Scalar & fill_value, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__full(size, fill_value, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor full_symint(c10::SymIntArrayRef size, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__full(size, fill_value, dtype, layout, device, pin_memory);
}
at::Tensor & full_out(at::Tensor & out, at::IntArrayRef size, const at::Scalar & fill_value) {
return wrapper_CompositeExplicitAutograd_out_full_out(c10::fromIntArrayRefSlow(size), fill_value, out);
}
at::Tensor & full_outf(at::IntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_full_out(c10::fromIntArrayRefSlow(size), fill_value, out);
}
at::Tensor & full_symint_out(at::Tensor & out, c10::SymIntArrayRef size, const at::Scalar & fill_value) {
return wrapper_CompositeExplicitAutograd_out_full_out(size, fill_value, out);
}
at::Tensor & full_symint_outf(c10::SymIntArrayRef size, const at::Scalar & fill_value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_full_out(size, fill_value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__full_like(const at::Tensor & self, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::full_like(self, fill_value, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_full_like_out(const at::Tensor & self, const at::Scalar & fill_value, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::full_like_out(self, fill_value, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("full_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__full_like));
m.impl("full_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_full_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor full_like(const at::Tensor & self, const at::Scalar & fill_value, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__full_like(self, fill_value, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor full_like(const at::Tensor & self, const at::Scalar & fill_value, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__full_like(self, fill_value, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & full_like_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & fill_value, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_full_like_out(self, fill_value, memory_format, out);
}
at::Tensor & full_like_outf(const at::Tensor & self, const at::Scalar & fill_value, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_full_like_out(self, fill_value, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_from_file_out(c10::string_view filename, ::std::optional<bool> shared, ::std::optional<int64_t> size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::from_file_out(filename, shared, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("from_file.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_from_file_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & from_file_out(at::Tensor & out, c10::string_view filename, ::std::optional<bool> shared, ::std::optional<int64_t> size) {
return wrapper_CompositeExplicitAutograd_out_from_file_out(filename, shared, size, out);
}
at::Tensor & from_file_outf(c10::string_view filename, ::std::optional<bool> shared, ::std::optional<int64_t> size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_from_file_out(filename, shared, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_out(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::grid_sampler_2d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("grid_sampler_2d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & grid_sampler_2d_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
at::Tensor & grid_sampler_2d_outf(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_backward_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::grid_sampler_2d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("grid_sampler_2d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> grid_sampler_2d_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> grid_sampler_2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_2d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___grid_sampler_2d_cpu_fallback(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
    // No device check
  // DeviceGuard omitted
  return at::native::_grid_sampler_2d_cpu_fallback(input, grid, interpolation_mode, padding_mode, align_corners);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__grid_sampler_2d_cpu_fallback_out(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_grid_sampler_2d_cpu_fallback_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_grid_sampler_2d_cpu_fallback",
TORCH_FN(wrapper_CompositeExplicitAutograd___grid_sampler_2d_cpu_fallback));
m.impl("_grid_sampler_2d_cpu_fallback.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__grid_sampler_2d_cpu_fallback_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _grid_sampler_2d_cpu_fallback(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
return wrapper_CompositeExplicitAutograd___grid_sampler_2d_cpu_fallback(input, grid, interpolation_mode, padding_mode, align_corners);
}
at::Tensor & _grid_sampler_2d_cpu_fallback_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
return wrapper_CompositeExplicitAutograd_out__grid_sampler_2d_cpu_fallback_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
at::Tensor & _grid_sampler_2d_cpu_fallback_outf(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__grid_sampler_2d_cpu_fallback_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_out(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::grid_sampler_3d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("grid_sampler_3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & grid_sampler_3d_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
at::Tensor & grid_sampler_3d_outf(const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_out(input, grid, interpolation_mode, padding_mode, align_corners, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_backward_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::grid_sampler_3d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("grid_sampler_3d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> grid_sampler_3d_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> grid_sampler_3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, ::std::array<bool,2> output_mask, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_grid_sampler_3d_backward_out(grad_output, input, grid, interpolation_mode, padding_mode, align_corners, output_mask, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__hann_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hann_window(window_length, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_hann_window_out(int64_t window_length, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hann_window_out(window_length, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hann_window",
TORCH_FN(wrapper_CompositeExplicitAutograd__hann_window));
m.impl("hann_window.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_hann_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hann_window(int64_t window_length, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__hann_window(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hann_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__hann_window(window_length, dtype, layout, device, pin_memory);
}
at::Tensor & hann_window_out(at::Tensor & out, int64_t window_length) {
return wrapper_CompositeExplicitAutograd_out_hann_window_out(window_length, out);
}
at::Tensor & hann_window_outf(int64_t window_length, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_hann_window_out(window_length, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_hann_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hann_window(window_length, periodic, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_out_hann_window_out(int64_t window_length, bool periodic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hann_window_periodic_out(window_length, periodic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hann_window.periodic",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_hann_window));
m.impl("hann_window.periodic_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_out_hann_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hann_window(int64_t window_length, bool periodic, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_hann_window(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hann_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_hann_window(window_length, periodic, dtype, layout, device, pin_memory);
}
at::Tensor & hann_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
return wrapper_CompositeExplicitAutograd_periodic_out_hann_window_out(window_length, periodic, out);
}
at::Tensor & hann_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_out_hann_window_out(window_length, periodic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__hamming_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window(window_length, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_hamming_window_out(int64_t window_length, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window_out(window_length, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hamming_window",
TORCH_FN(wrapper_CompositeExplicitAutograd__hamming_window));
m.impl("hamming_window.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_hamming_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hamming_window(int64_t window_length, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__hamming_window(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hamming_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__hamming_window(window_length, dtype, layout, device, pin_memory);
}
at::Tensor & hamming_window_out(at::Tensor & out, int64_t window_length) {
return wrapper_CompositeExplicitAutograd_out_hamming_window_out(window_length, out);
}
at::Tensor & hamming_window_outf(int64_t window_length, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_hamming_window_out(window_length, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_hamming_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window(window_length, periodic, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_out_hamming_window_out(int64_t window_length, bool periodic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window_periodic_out(window_length, periodic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hamming_window.periodic",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_hamming_window));
m.impl("hamming_window.periodic_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_out_hamming_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hamming_window(int64_t window_length, bool periodic, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_hamming_window(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hamming_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_hamming_window(window_length, periodic, dtype, layout, device, pin_memory);
}
at::Tensor & hamming_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
return wrapper_CompositeExplicitAutograd_periodic_out_hamming_window_out(window_length, periodic, out);
}
at::Tensor & hamming_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_out_hamming_window_out(window_length, periodic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_alpha_hamming_window(int64_t window_length, bool periodic, double alpha, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window(window_length, periodic, alpha, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_alpha_out_hamming_window_out(int64_t window_length, bool periodic, double alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window_periodic_alpha_out(window_length, periodic, alpha, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hamming_window.periodic_alpha",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_alpha_hamming_window));
m.impl("hamming_window.periodic_alpha_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_alpha_out_hamming_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hamming_window(int64_t window_length, bool periodic, double alpha, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_hamming_window(window_length, periodic, alpha, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hamming_window(int64_t window_length, bool periodic, double alpha, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_hamming_window(window_length, periodic, alpha, dtype, layout, device, pin_memory);
}
at::Tensor & hamming_window_out(at::Tensor & out, int64_t window_length, bool periodic, double alpha) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_out_hamming_window_out(window_length, periodic, alpha, out);
}
at::Tensor & hamming_window_outf(int64_t window_length, bool periodic, double alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_out_hamming_window_out(window_length, periodic, alpha, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_alpha_beta_hamming_window(int64_t window_length, bool periodic, double alpha, double beta, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window(window_length, periodic, alpha, beta, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_alpha_beta_out_hamming_window_out(int64_t window_length, bool periodic, double alpha, double beta, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hamming_window_periodic_alpha_beta_out(window_length, periodic, alpha, beta, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hamming_window.periodic_alpha_beta",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_alpha_beta_hamming_window));
m.impl("hamming_window.periodic_alpha_beta_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_alpha_beta_out_hamming_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor hamming_window(int64_t window_length, bool periodic, double alpha, double beta, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_beta_hamming_window(window_length, periodic, alpha, beta, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor hamming_window(int64_t window_length, bool periodic, double alpha, double beta, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_beta_hamming_window(window_length, periodic, alpha, beta, dtype, layout, device, pin_memory);
}
at::Tensor & hamming_window_out(at::Tensor & out, int64_t window_length, bool periodic, double alpha, double beta) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_beta_out_hamming_window_out(window_length, periodic, alpha, beta, out);
}
at::Tensor & hamming_window_outf(int64_t window_length, bool periodic, double alpha, double beta, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_alpha_beta_out_hamming_window_out(window_length, periodic, alpha, beta, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__kaiser_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window(window_length, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_kaiser_window_out(int64_t window_length, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window_out(window_length, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("kaiser_window",
TORCH_FN(wrapper_CompositeExplicitAutograd__kaiser_window));
m.impl("kaiser_window.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_kaiser_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor kaiser_window(int64_t window_length, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__kaiser_window(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor kaiser_window(int64_t window_length, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__kaiser_window(window_length, dtype, layout, device, pin_memory);
}
at::Tensor & kaiser_window_out(at::Tensor & out, int64_t window_length) {
return wrapper_CompositeExplicitAutograd_out_kaiser_window_out(window_length, out);
}
at::Tensor & kaiser_window_outf(int64_t window_length, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_kaiser_window_out(window_length, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_periodic_kaiser_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window(window_length, periodic, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_periodic_out_kaiser_window_out(int64_t window_length, bool periodic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window_periodic_out(window_length, periodic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("kaiser_window.periodic",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_kaiser_window));
m.impl("kaiser_window.periodic_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_periodic_out_kaiser_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor kaiser_window(int64_t window_length, bool periodic, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_periodic_kaiser_window(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor kaiser_window(int64_t window_length, bool periodic, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_periodic_kaiser_window(window_length, periodic, dtype, layout, device, pin_memory);
}
at::Tensor & kaiser_window_out(at::Tensor & out, int64_t window_length, bool periodic) {
return wrapper_CompositeExplicitAutograd_periodic_out_kaiser_window_out(window_length, periodic, out);
}
at::Tensor & kaiser_window_outf(int64_t window_length, bool periodic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_periodic_out_kaiser_window_out(window_length, periodic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_beta_kaiser_window(int64_t window_length, bool periodic, double beta, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window(window_length, periodic, beta, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_beta_out_kaiser_window_out(int64_t window_length, bool periodic, double beta, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::kaiser_window_beta_out(window_length, periodic, beta, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("kaiser_window.beta",
TORCH_FN(wrapper_CompositeExplicitAutograd_beta_kaiser_window));
m.impl("kaiser_window.beta_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_beta_out_kaiser_window_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor kaiser_window(int64_t window_length, bool periodic, double beta, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_beta_kaiser_window(window_length, periodic, beta, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor kaiser_window(int64_t window_length, bool periodic, double beta, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_beta_kaiser_window(window_length, periodic, beta, dtype, layout, device, pin_memory);
}
at::Tensor & kaiser_window_out(at::Tensor & out, int64_t window_length, bool periodic, double beta) {
return wrapper_CompositeExplicitAutograd_beta_out_kaiser_window_out(window_length, periodic, beta, out);
}
at::Tensor & kaiser_window_outf(int64_t window_length, bool periodic, double beta, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_beta_out_kaiser_window_out(window_length, periodic, beta, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__native_group_norm(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::math_group_norm(input, weight, bias, N.guard_int(__FILE__, __LINE__), C.guard_int(__FILE__, __LINE__), HxW.guard_int(__FILE__, __LINE__), group, eps);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_group_norm_out(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_group_norm_out_symint(input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_group_norm",
TORCH_FN(wrapper_CompositeExplicitAutograd__native_group_norm));
m.impl("native_group_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_group_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_group_norm(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps) {
return wrapper_CompositeExplicitAutograd__native_group_norm(input, weight, bias, N, C, HxW, group, eps);
}
::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_group_norm_symint(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps) {
return wrapper_CompositeExplicitAutograd__native_group_norm(input, weight, bias, N, C, HxW, group, eps);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_out(input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_out(input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_out(input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_symint_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_out(input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_group_norm_backward_out_symint(grad_out, input, mean, rstd, weight, N, C, HxW, group, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_group_norm_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, int64_t N, int64_t C, int64_t HxW, int64_t group, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out(grad_out, input, mean, rstd, weight, N, C, HxW, group, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, int64_t N, int64_t C, int64_t HxW, int64_t group, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out(grad_out, input, mean, rstd, weight, N, C, HxW, group, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out(grad_out, input, mean, rstd, weight, N, C, HxW, group, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_group_norm_backward_symint_outf(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_group_norm_backward_out(grad_out, input, mean, rstd, weight, N, C, HxW, group, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor__unsafe_index(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_index(self, indices);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unsafe_index.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__unsafe_index));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _unsafe_index(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices) {
return wrapper_CompositeExplicitAutograd_Tensor__unsafe_index(self, indices);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___unsafe_masked_index(const at::Tensor & self, const at::Tensor & mask, const c10::List<::std::optional<at::Tensor>> & indices, const at::Scalar & fill) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_masked_index(self, mask, indices, fill);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unsafe_masked_index",
TORCH_FN(wrapper_CompositeExplicitAutograd___unsafe_masked_index));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _unsafe_masked_index(const at::Tensor & self, const at::Tensor & mask, const c10::List<::std::optional<at::Tensor>> & indices, const at::Scalar & fill) {
return wrapper_CompositeExplicitAutograd___unsafe_masked_index(self, mask, indices, fill);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___unsafe_masked_index_put_accumulate(const at::Tensor & self, const at::Tensor & mask, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_masked_index_put_accumulate(self, mask, indices, values);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unsafe_masked_index_put_accumulate",
TORCH_FN(wrapper_CompositeExplicitAutograd___unsafe_masked_index_put_accumulate));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _unsafe_masked_index_put_accumulate(const at::Tensor & self, const at::Tensor & mask, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values) {
return wrapper_CompositeExplicitAutograd___unsafe_masked_index_put_accumulate(self, mask, indices, values);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__index_put(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_put(self, indices, values, accumulate);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_index_put_out(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_put_out(self, indices, values, accumulate, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__index_put_(at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_put_(self, indices, values, accumulate);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("index_put",
TORCH_FN(wrapper_CompositeExplicitAutograd__index_put));
m.impl("index_put.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_index_put_out));
m.impl("index_put_",
TORCH_FN(wrapper_CompositeExplicitAutograd__index_put_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor index_put(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
return wrapper_CompositeExplicitAutograd__index_put(self, indices, values, accumulate);
}
at::Tensor & index_put_out(at::Tensor & out, const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
return wrapper_CompositeExplicitAutograd_out_index_put_out(self, indices, values, accumulate, out);
}
at::Tensor & index_put_outf(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_index_put_out(self, indices, values, accumulate, out);
}
at::Tensor & index_put_(at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
return wrapper_CompositeExplicitAutograd__index_put_(self, indices, values, accumulate);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___unsafe_index_put(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_index_put(self, indices, values, accumulate);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unsafe_index_put",
TORCH_FN(wrapper_CompositeExplicitAutograd___unsafe_index_put));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _unsafe_index_put(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate) {
return wrapper_CompositeExplicitAutograd___unsafe_index_put(self, indices, values, accumulate);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___index_put_impl(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, bool unsafe) {
    // No device check
  // DeviceGuard omitted
  return at::native::_index_put_impl(self, indices, values, accumulate, unsafe);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__index_put_impl_out(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, bool unsafe, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_index_put_impl_out(self, indices, values, accumulate, unsafe, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_index_put_impl",
TORCH_FN(wrapper_CompositeExplicitAutograd___index_put_impl));
m.impl("_index_put_impl.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__index_put_impl_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _index_put_impl(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, bool unsafe) {
return wrapper_CompositeExplicitAutograd___index_put_impl(self, indices, values, accumulate, unsafe);
}
at::Tensor & _index_put_impl_out(at::Tensor & out, const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, bool unsafe) {
return wrapper_CompositeExplicitAutograd_out__index_put_impl_out(self, indices, values, accumulate, unsafe, out);
}
at::Tensor & _index_put_impl_outf(const at::Tensor & self, const c10::List<::std::optional<at::Tensor>> & indices, const at::Tensor & values, bool accumulate, bool unsafe, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__index_put_impl_out(self, indices, values, accumulate, unsafe, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_isnan_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::isnan_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("isnan.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_isnan_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & isnan_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_isnan_out(self, out);
}
at::Tensor & isnan_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_isnan_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
bool wrapper_CompositeExplicitAutograd__is_same_size(const at::Tensor & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::is_same_size(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("is_same_size",
TORCH_FN(wrapper_CompositeExplicitAutograd__is_same_size));
}
} // anonymous namespace
namespace compositeexplicitautograd {
bool is_same_size(const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd__is_same_size(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__kthvalue(const at::Tensor & self, int64_t k, int64_t dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::kthvalue(self, k, dim, keepdim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("kthvalue",
TORCH_FN(wrapper_CompositeExplicitAutograd__kthvalue));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> kthvalue(const at::Tensor & self, int64_t k, int64_t dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd__kthvalue(self, k, dim, keepdim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__native_layer_norm(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::math_native_layer_norm(input, C10_AS_INTARRAYREF_SLOW(normalized_shape), weight, bias, eps);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_layer_norm_out(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_layer_norm_out_symint(input, normalized_shape, weight, bias, eps, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_layer_norm",
TORCH_FN(wrapper_CompositeExplicitAutograd__native_layer_norm));
m.impl("native_layer_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_layer_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm(const at::Tensor & input, at::IntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps) {
return wrapper_CompositeExplicitAutograd__native_layer_norm(input, c10::fromIntArrayRefSlow(normalized_shape), weight, bias, eps);
}
::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_symint(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps) {
return wrapper_CompositeExplicitAutograd__native_layer_norm(input, normalized_shape, weight, bias, eps);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, at::IntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_out(input, c10::fromIntArrayRefSlow(normalized_shape), weight, bias, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_outf(const at::Tensor & input, at::IntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_out(input, c10::fromIntArrayRefSlow(normalized_shape), weight, bias, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_out(input, normalized_shape, weight, bias, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_symint_outf(const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_out(input, normalized_shape, weight, bias, eps, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_layer_norm_backward_out_symint(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_layer_norm_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_symint_outf(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_layer_norm_backward_out(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__nan_to_num(const at::Tensor & self, ::std::optional<double> nan, ::std::optional<double> posinf, ::std::optional<double> neginf) {
    // No device check
  // DeviceGuard omitted
  return at::native::nan_to_num(self, nan, posinf, neginf);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__nan_to_num_(at::Tensor & self, ::std::optional<double> nan, ::std::optional<double> posinf, ::std::optional<double> neginf) {
    // No device check
  // DeviceGuard omitted
  return at::native::nan_to_num_(self, nan, posinf, neginf);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("nan_to_num",
TORCH_FN(wrapper_CompositeExplicitAutograd__nan_to_num));
m.impl("nan_to_num_",
TORCH_FN(wrapper_CompositeExplicitAutograd__nan_to_num_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor nan_to_num(const at::Tensor & self, ::std::optional<double> nan, ::std::optional<double> posinf, ::std::optional<double> neginf) {
return wrapper_CompositeExplicitAutograd__nan_to_num(self, nan, posinf, neginf);
}
at::Tensor & nan_to_num_(at::Tensor & self, ::std::optional<double> nan, ::std::optional<double> posinf, ::std::optional<double> neginf) {
return wrapper_CompositeExplicitAutograd__nan_to_num_(self, nan, posinf, neginf);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_linear_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linear_out(input, weight, bias, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linear.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_linear_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & linear_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias) {
return wrapper_CompositeExplicitAutograd_out_linear_out(input, weight, bias, out);
}
at::Tensor & linear_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_linear_out(input, weight, bias, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_linear_backward_out(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linear_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_linear_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linear_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> linear_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_linear_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_linear_out(self, weight, bias, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_linear.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_linear_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_linear_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_out(self, weight, bias, out);
}
at::Tensor & mkldnn_linear_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_out(self, weight, bias, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_input_out(at::IntArrayRef input_size, const at::Tensor & grad_output, const at::Tensor & weight, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_linear_backward_input_out(input_size, grad_output, weight, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_linear_backward_input.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_input_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_linear_backward_input_out(at::Tensor & out, at::IntArrayRef input_size, const at::Tensor & grad_output, const at::Tensor & weight) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_input_out(input_size, grad_output, weight, out);
}
at::Tensor & mkldnn_linear_backward_input_outf(at::IntArrayRef input_size, const at::Tensor & grad_output, const at::Tensor & weight, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_input_out(input_size, grad_output, weight, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_weights_out(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, bool bias_defined, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_linear_backward_weights_out(grad_output, input, weight, bias_defined, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_linear_backward_weights.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_weights_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> mkldnn_linear_backward_weights_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, bool bias_defined) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_weights_out(grad_output, input, weight, bias_defined, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> mkldnn_linear_backward_weights_outf(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & weight, bool bias_defined, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_weights_out(grad_output, input, weight, bias_defined, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_out(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_linear_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_linear_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_linear_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_linear_backward_out(self, grad_output, weight, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__linspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace(start, end, steps, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linspace",
TORCH_FN(wrapper_CompositeExplicitAutograd__linspace));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor linspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__linspace(start, end, steps, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor linspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__linspace(start, end, steps, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Tensor_linspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace(start, end, steps, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_linspace_out(const at::Tensor & start, const at::Tensor & end, int64_t steps, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace_out(start, end, steps, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linspace.Tensor_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Tensor_linspace));
m.impl("linspace.Tensor_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_linspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor linspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_linspace(start, end, steps, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor linspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_linspace(start, end, steps, dtype, layout, device, pin_memory);
}
at::Tensor & linspace_out(at::Tensor & out, const at::Tensor & start, const at::Tensor & end, int64_t steps) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_linspace_out(start, end, steps, out);
}
at::Tensor & linspace_outf(const at::Tensor & start, const at::Tensor & end, int64_t steps, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_linspace_out(start, end, steps, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Scalar_linspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace(start, end, steps, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_linspace_out(const at::Tensor & start, const at::Scalar & end, int64_t steps, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace_out(start, end, steps, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linspace.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_linspace));
m.impl("linspace.Tensor_Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_linspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor linspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_linspace(start, end, steps, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor linspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_linspace(start, end, steps, dtype, layout, device, pin_memory);
}
at::Tensor & linspace_out(at::Tensor & out, const at::Tensor & start, const at::Scalar & end, int64_t steps) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_linspace_out(start, end, steps, out);
}
at::Tensor & linspace_outf(const at::Tensor & start, const at::Scalar & end, int64_t steps, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_linspace_out(start, end, steps, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_linspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace(start, end, steps, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_linspace_out(const at::Scalar & start, const at::Tensor & end, int64_t steps, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linspace_out(start, end, steps, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linspace.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_linspace));
m.impl("linspace.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_linspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor linspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_linspace(start, end, steps, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor linspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_linspace(start, end, steps, dtype, layout, device, pin_memory);
}
at::Tensor & linspace_out(at::Tensor & out, const at::Scalar & start, const at::Tensor & end, int64_t steps) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_linspace_out(start, end, steps, out);
}
at::Tensor & linspace_outf(const at::Scalar & start, const at::Tensor & end, int64_t steps, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_linspace_out(start, end, steps, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Self_xlogy(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::xlogy(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_OutScalar_Self_xlogy_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::xlogy_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("xlogy.Scalar_Self",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Self_xlogy));
m.impl("xlogy.OutScalar_Self",
TORCH_FN(wrapper_CompositeExplicitAutograd_OutScalar_Self_xlogy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor xlogy(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Self_xlogy(self, other);
}
at::Tensor & xlogy_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_OutScalar_Self_xlogy_out(self, other, out);
}
at::Tensor & xlogy_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_OutScalar_Self_xlogy_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::xlogy(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_OutScalar_Other_xlogy_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::xlogy_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::xlogy_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("xlogy.Scalar_Other",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy));
m.impl("xlogy.OutScalar_Other",
TORCH_FN(wrapper_CompositeExplicitAutograd_OutScalar_Other_xlogy_out));
m.impl("xlogy_.Scalar_Other",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor xlogy(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy(self, other);
}
at::Tensor & xlogy_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_OutScalar_Other_xlogy_out(self, other, out);
}
at::Tensor & xlogy_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_OutScalar_Other_xlogy_out(self, other, out);
}
at::Tensor & xlogy_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Other_xlogy_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logspace",
TORCH_FN(wrapper_CompositeExplicitAutograd__logspace));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, double base, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__logspace(start, end, steps, base, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor logspace(const at::Scalar & start, const at::Scalar & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Tensor_logspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_logspace_out(const at::Tensor & start, const at::Tensor & end, int64_t steps, double base, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace_out(start, end, steps, base, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logspace.Tensor_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Tensor_logspace));
m.impl("logspace.Tensor_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_logspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, double base, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_logspace(start, end, steps, base, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor logspace(const at::Tensor & start, const at::Tensor & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
at::Tensor & logspace_out(at::Tensor & out, const at::Tensor & start, const at::Tensor & end, int64_t steps, double base) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_logspace_out(start, end, steps, base, out);
}
at::Tensor & logspace_outf(const at::Tensor & start, const at::Tensor & end, int64_t steps, double base, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Tensor_out_logspace_out(start, end, steps, base, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Scalar_logspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_logspace_out(const at::Tensor & start, const at::Scalar & end, int64_t steps, double base, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace_out(start, end, steps, base, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logspace.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_logspace));
m.impl("logspace.Tensor_Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_logspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, double base, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_logspace(start, end, steps, base, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor logspace(const at::Tensor & start, const at::Scalar & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
at::Tensor & logspace_out(at::Tensor & out, const at::Tensor & start, const at::Scalar & end, int64_t steps, double base) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_logspace_out(start, end, steps, base, out);
}
at::Tensor & logspace_outf(const at::Tensor & start, const at::Scalar & end, int64_t steps, double base, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_logspace_out(start, end, steps, base, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_logspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_logspace_out(const at::Scalar & start, const at::Tensor & end, int64_t steps, double base, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::logspace_out(start, end, steps, base, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logspace.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_logspace));
m.impl("logspace.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_logspace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, double base, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_logspace(start, end, steps, base, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor logspace(const at::Scalar & start, const at::Tensor & end, int64_t steps, double base, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_logspace(start, end, steps, base, dtype, layout, device, pin_memory);
}
at::Tensor & logspace_out(at::Tensor & out, const at::Scalar & start, const at::Tensor & end, int64_t steps, double base) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_logspace_out(start, end, steps, base, out);
}
at::Tensor & logspace_outf(const at::Scalar & start, const at::Tensor & end, int64_t steps, double base, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_logspace_out(start, end, steps, base, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_out_log_softmax_out(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::log_softmax_out(self, dim, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("log_softmax.int_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_out_log_softmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & log_softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_int_out_log_softmax_out(self, dim, dtype, out);
}
at::Tensor & log_softmax_outf(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_out_log_softmax_out(self, dim, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logcumsumexp(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::logcumsumexp(self, dim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_logcumsumexp_out(const at::Tensor & self, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::logcumsumexp_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logcumsumexp",
TORCH_FN(wrapper_CompositeExplicitAutograd__logcumsumexp));
m.impl("logcumsumexp.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_logcumsumexp_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logcumsumexp(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd__logcumsumexp(self, dim);
}
at::Tensor & logcumsumexp_out(at::Tensor & out, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_logcumsumexp_out(self, dim, out);
}
at::Tensor & logcumsumexp_outf(const at::Tensor & self, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_logcumsumexp_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__logsumexp(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::logsumexp(self, dim, keepdim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("logsumexp",
TORCH_FN(wrapper_CompositeExplicitAutograd__logsumexp));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor logsumexp(const at::Tensor & self, at::IntArrayRef dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd__logsumexp(self, dim, keepdim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_matmul_backward_out(const at::Tensor & grad, const at::Tensor & self, const at::Tensor & other, ::std::array<bool,2> mask, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::matmul_backward_out(grad, self, other, mask, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("matmul_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_matmul_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> matmul_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & grad, const at::Tensor & self, const at::Tensor & other, ::std::array<bool,2> mask) {
return wrapper_CompositeExplicitAutograd_out_matmul_backward_out(grad, self, other, mask, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> matmul_backward_outf(const at::Tensor & grad, const at::Tensor & self, const at::Tensor & other, ::std::array<bool,2> mask, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_matmul_backward_out(grad, self, other, mask, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__aminmax_out(const at::Tensor & self, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_aminmax_out(self, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_aminmax.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__aminmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _aminmax_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__aminmax_out(self, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _aminmax_outf(const at::Tensor & self, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__aminmax_out(self, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_dim_out__aminmax_out(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_aminmax_dim_out(self, dim, keepdim, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_aminmax.dim_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_out__aminmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _aminmax_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, int64_t dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dim_out__aminmax_out(self, dim, keepdim, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _aminmax_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_dim_out__aminmax_out(self, dim, keepdim, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_max_pool2d_backward_out(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::max_pool2d_backward_out(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("max_pool2d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_max_pool2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & max_pool2d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_max_pool2d_backward_out(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & max_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_max_pool2d_backward_out(grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_max_pool2d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_max_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & mkldnn_max_pool2d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_backward_out(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_max_pool2d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_max_pool2d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_max_pool2d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & mkldnn_max_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool2d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_max_pool3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_max_pool3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & mkldnn_max_pool3d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_backward_out(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_max_pool3d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_max_pool3d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_max_pool3d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & mkldnn_max_pool3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & input, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_max_pool3d_backward_out(grad_output, output, input, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantized_max_pool1d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantized_max_pool1d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantized_max_pool1d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantized_max_pool1d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantized_max_pool1d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool1d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & quantized_max_pool1d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool1d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantized_max_pool2d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantized_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantized_max_pool2d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantized_max_pool2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantized_max_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & quantized_max_pool2d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool2d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantized_max_pool3d_out(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantized_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantized_max_pool3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantized_max_pool3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantized_max_pool3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
at::Tensor & quantized_max_pool3d_outf(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantized_max_pool3d_out(self, kernel_size, stride, padding, dilation, ceil_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__mean(const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::mean(self, dtype);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dtype_out_mean_out(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mean_dtype_out(self, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mean",
TORCH_FN(wrapper_CompositeExplicitAutograd__mean));
m.impl("mean.dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dtype_out_mean_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor mean(const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd__mean(self, dtype);
}
at::Tensor & mean_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_dtype_out_mean_out(self, dtype, out);
}
at::Tensor & mean_outf(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dtype_out_mean_out(self, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_median_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::median_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("median.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_median_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & median_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_median_out(self, out);
}
at::Tensor & median_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_median_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd_dim_median(const at::Tensor & self, int64_t dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::median(self, dim, keepdim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("median.dim",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_median));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> median(const at::Tensor & self, int64_t dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dim_median(self, dim, keepdim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_nanmedian_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::nanmedian_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("nanmedian.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_nanmedian_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & nanmedian_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_nanmedian_out(self, out);
}
at::Tensor & nanmedian_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_nanmedian_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd_dim_nanmedian(const at::Tensor & self, int64_t dim, bool keepdim) {
    // No device check
  // DeviceGuard omitted
  return at::native::nanmedian(self, dim, keepdim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("nanmedian.dim",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_nanmedian));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> nanmedian(const at::Tensor & self, int64_t dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_dim_nanmedian(self, dim, keepdim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__mps_convolution_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_mps_convolution_out_symint(self, weight, bias, padding, stride, dilation, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_mps_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__mps_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _mps_convolution_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & _mps_convolution_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & _mps_convolution_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_out(self, weight, bias, padding, stride, dilation, groups, out);
}
at::Tensor & _mps_convolution_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mps_convolution_out(self, weight, bias, padding, stride, dilation, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::mps_convolution_backward_out_symint(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mps_convolution_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> mps_convolution_backward_symint_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_mps_convolution_backward_out(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__mkldnn_convolution(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_convolution(self, weight, bias, C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(stride), C10_AS_INTARRAYREF_SLOW(dilation), groups.guard_int(__FILE__, __LINE__));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_convolution_out_symint(self, weight, bias, padding, stride, dilation, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_convolution",
TORCH_FN(wrapper_CompositeExplicitAutograd__mkldnn_convolution));
m.impl("mkldnn_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor mkldnn_convolution(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd__mkldnn_convolution(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups);
}
at::Tensor mkldnn_convolution_symint(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd__mkldnn_convolution(self, weight, bias, padding, stride, dilation, groups);
}
at::Tensor & mkldnn_convolution_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & mkldnn_convolution_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, out);
}
at::Tensor & mkldnn_convolution_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out(self, weight, bias, padding, stride, dilation, groups, out);
}
at::Tensor & mkldnn_convolution_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_convolution_out(self, weight, bias, padding, stride, dilation, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_out(const at::Tensor & input, const at::Tensor & weight0, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & hx_, const at::Tensor & cx_, bool reverse, at::IntArrayRef batch_sizes, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool bidirectional, bool batch_first, bool train, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_rnn_layer_out(input, weight0, weight1, weight2, weight3, hx_, cx_, reverse, batch_sizes, mode, hidden_size, num_layers, has_biases, bidirectional, batch_first, train, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_rnn_layer.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_rnn_layer_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & input, const at::Tensor & weight0, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & hx_, const at::Tensor & cx_, bool reverse, at::IntArrayRef batch_sizes, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool bidirectional, bool batch_first, bool train) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_out(input, weight0, weight1, weight2, weight3, hx_, cx_, reverse, batch_sizes, mode, hidden_size, num_layers, has_biases, bidirectional, batch_first, train, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_rnn_layer_outf(const at::Tensor & input, const at::Tensor & weight0, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & hx_, const at::Tensor & cx_, bool reverse, at::IntArrayRef batch_sizes, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool bidirectional, bool batch_first, bool train, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_out(input, weight0, weight1, weight2, weight3, hx_, cx_, reverse, batch_sizes, mode, hidden_size, num_layers, has_biases, bidirectional, batch_first, train, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_backward_out(const at::Tensor & input, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & weight4, const at::Tensor & hx_, const at::Tensor & cx_tmp, const at::Tensor & output, const at::Tensor & hy_, const at::Tensor & cy_, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, bool reverse, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool train, bool bidirectional, at::IntArrayRef batch_sizes, bool batch_first, const at::Tensor & workspace, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5, at::Tensor & out6) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_rnn_layer_backward_out(input, weight1, weight2, weight3, weight4, hx_, cx_tmp, output, hy_, cy_, grad_output, grad_hy, grad_cy, reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, workspace, out0, out1, out2, out3, out4, out5, out6);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_rnn_layer_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_rnn_layer_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5, at::Tensor & out6, const at::Tensor & input, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & weight4, const at::Tensor & hx_, const at::Tensor & cx_tmp, const at::Tensor & output, const at::Tensor & hy_, const at::Tensor & cy_, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, bool reverse, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool train, bool bidirectional, at::IntArrayRef batch_sizes, bool batch_first, const at::Tensor & workspace) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_backward_out(input, weight1, weight2, weight3, weight4, hx_, cx_tmp, output, hy_, cy_, grad_output, grad_hy, grad_cy, reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, workspace, out0, out1, out2, out3, out4, out5, out6);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> mkldnn_rnn_layer_backward_outf(const at::Tensor & input, const at::Tensor & weight1, const at::Tensor & weight2, const at::Tensor & weight3, const at::Tensor & weight4, const at::Tensor & hx_, const at::Tensor & cx_tmp, const at::Tensor & output, const at::Tensor & hy_, const at::Tensor & cy_, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, bool reverse, int64_t mode, int64_t hidden_size, int64_t num_layers, bool has_biases, bool train, bool bidirectional, at::IntArrayRef batch_sizes, bool batch_first, const at::Tensor & workspace, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5, at::Tensor & out6) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_rnn_layer_backward_out(input, weight1, weight2, weight3, weight4, hx_, cx_tmp, output, hy_, cy_, grad_output, grad_hy, grad_cy, reverse, mode, hidden_size, num_layers, has_biases, train, bidirectional, batch_sizes, batch_first, workspace, out0, out1, out2, out3, out4, out5, out6);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_batch_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> miopen_batch_norm_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon) {
return wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> miopen_batch_norm_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, bool training, double exponential_average_factor, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_out(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_backward_out(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_batch_norm_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> miopen_batch_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon) {
return wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> miopen_batch_norm_backward_outf(const at::Tensor & input, const at::Tensor & grad_output, const at::Tensor & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_var, double epsilon, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_miopen_batch_norm_backward_out(input, grad_output, weight, running_mean, running_var, save_mean, save_var, epsilon, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_miopen_convolution_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_convolution_out_symint(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & miopen_convolution_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_out(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_out(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_convolution_transpose_out_symint(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_convolution_transpose.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & miopen_convolution_transpose_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_transpose_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_transpose_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic, out);
}
at::Tensor & miopen_convolution_transpose_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_convolution_transpose_out(self, weight, bias, padding, output_padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_depthwise_convolution_out_symint(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_depthwise_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & miopen_depthwise_convolution_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_depthwise_convolution_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out(self, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, benchmark, deterministic, out);
}
at::Tensor & miopen_depthwise_convolution_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic) {
return wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
at::Tensor & miopen_depthwise_convolution_symint_outf(const at::Tensor & self, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, bool benchmark, bool deterministic, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_miopen_depthwise_convolution_out(self, weight, bias, padding, stride, dilation, groups, benchmark, deterministic, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_miopen_rnn_out(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_rnn_out(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_rnn.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_rnn_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> miopen_rnn_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state) {
return wrapper_CompositeExplicitAutograd_out_miopen_rnn_out(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> miopen_rnn_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
return wrapper_CompositeExplicitAutograd_out_miopen_rnn_out(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state, out0, out1, out2, out3, out4);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_out_miopen_rnn_backward_out(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::miopen_rnn_backward_out(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, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("miopen_rnn_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_miopen_rnn_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void miopen_rnn_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3, const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask) {
return wrapper_CompositeExplicitAutograd_out_miopen_rnn_backward_out(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, out0, out1, out2, out3);
}
void miopen_rnn_backward_outf(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & weight_buf, const at::Tensor & hx, const ::std::optional<at::Tensor> & cx, const at::Tensor & output, const ::std::optional<at::Tensor> & grad_output, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const ::std::optional<at::Tensor> & dropout_state, const at::Tensor & reserve, ::std::array<bool,4> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::TensorList out3) {
return wrapper_CompositeExplicitAutograd_out_miopen_rnn_backward_out(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, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_sparse_matmul_out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_sparse_matmul_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_sparse_matmul.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_sparse_matmul_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_sparse_matmul_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_out__sparse_sparse_matmul_out(self, other, out);
}
at::Tensor & _sparse_sparse_matmul_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_sparse_matmul_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_values_mode_out(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices) {
    // No device check
  // DeviceGuard omitted
  return at::native::mode_out(self, dim, keepdim, values, indices);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mode.values",
TORCH_FN(wrapper_CompositeExplicitAutograd_values_mode_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> mode_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim, bool keepdim) {
return wrapper_CompositeExplicitAutograd_values_mode_out(self, dim, keepdim, values, indices);
}
::std::tuple<at::Tensor &,at::Tensor &> mode_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices) {
return wrapper_CompositeExplicitAutograd_values_mode_out(self, dim, keepdim, values, indices);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_mul(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::mul(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_mul_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mul_Scalar_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_mul_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::mul_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mul.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_mul));
m.impl("mul.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_mul_out));
m.impl("mul_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_mul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor mul(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_mul(self, other);
}
at::Tensor & mul_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_mul_out(self, other, out);
}
at::Tensor & mul_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_mul_out(self, other, out);
}
at::Tensor & mul_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_mul_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__mv(const at::Tensor & self, const at::Tensor & vec) {
    // No device check
  // DeviceGuard omitted
  return at::native::mv(self, vec);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mv_out(const at::Tensor & self, const at::Tensor & vec, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mv_out(self, vec, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mv",
TORCH_FN(wrapper_CompositeExplicitAutograd__mv));
m.impl("mv.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mv_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor mv(const at::Tensor & self, const at::Tensor & vec) {
return wrapper_CompositeExplicitAutograd__mv(self, vec);
}
at::Tensor & mv_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & vec) {
return wrapper_CompositeExplicitAutograd_out_mv_out(self, vec, out);
}
at::Tensor & mv_outf(const at::Tensor & self, const at::Tensor & vec, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mv_out(self, vec, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__mvlgamma(const at::Tensor & self, int64_t p) {
    // No device check
  // DeviceGuard omitted
  return at::native::mvlgamma(self, p);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__mvlgamma_(at::Tensor & self, int64_t p) {
    // No device check
  // DeviceGuard omitted
  return at::native::mvlgamma_(self, p);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mvlgamma",
TORCH_FN(wrapper_CompositeExplicitAutograd__mvlgamma));
m.impl("mvlgamma_",
TORCH_FN(wrapper_CompositeExplicitAutograd__mvlgamma_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor mvlgamma(const at::Tensor & self, int64_t p) {
return wrapper_CompositeExplicitAutograd__mvlgamma(self, p);
}
at::Tensor & mvlgamma_(at::Tensor & self, int64_t p) {
return wrapper_CompositeExplicitAutograd__mvlgamma_(self, p);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___native_batch_norm_legit_functional(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::_native_batch_norm_legit_functional(input, weight, bias, running_mean, running_var, training, momentum, eps);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_native_batch_norm_legit_functional",
TORCH_FN(wrapper_CompositeExplicitAutograd___native_batch_norm_legit_functional));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> _native_batch_norm_legit_functional(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, bool training, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd___native_batch_norm_legit_functional(input, weight, bias, running_mean, running_var, training, momentum, eps);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___native_batch_norm_legit_no_training(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::_batch_norm_legit_no_training(input, weight, bias, running_mean, running_var, momentum, eps);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__native_batch_norm_legit_no_training_out(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_native_batch_norm_legit_no_training_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_native_batch_norm_legit_no_training",
TORCH_FN(wrapper_CompositeExplicitAutograd___native_batch_norm_legit_no_training));
m.impl("_native_batch_norm_legit_no_training.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__native_batch_norm_legit_no_training_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor> _native_batch_norm_legit_no_training(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd___native_batch_norm_legit_no_training(input, weight, bias, running_mean, running_var, momentum, eps);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_no_training_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd_out__native_batch_norm_legit_no_training_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _native_batch_norm_legit_no_training_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out__native_batch_norm_legit_no_training_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_batch_norm_stats_out(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_stats_out(input, eps, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_stats.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_stats_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, double eps) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_stats_out(input, eps, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_stats_outf(const at::Tensor & input, double eps, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_stats_out(input, eps, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_out(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, int64_t count, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_gather_stats_out(input, mean, invstd, running_mean, running_var, momentum, eps, count, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_gather_stats.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_gather_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, int64_t count) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_out(input, mean, invstd, running_mean, running_var, momentum, eps, count, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_gather_stats_outf(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, int64_t count, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_out(input, mean, invstd, running_mean, running_var, momentum, eps, count, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_with_counts_out(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_gather_stats_with_counts_out(input, mean, invstd, running_mean, running_var, momentum, eps, counts, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_gather_stats_with_counts.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_with_counts_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_gather_stats_with_counts_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_with_counts_out(input, mean, invstd, running_mean, running_var, momentum, eps, counts, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_gather_stats_with_counts_outf(const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, const at::Tensor & counts, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_gather_stats_with_counts_out(input, mean, invstd, running_mean, running_var, momentum, eps, counts, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_native_batch_norm_backward_out(const at::Tensor & grad_out, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_invstd, bool train, double eps, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_batch_norm_backward_out(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_batch_norm_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_batch_norm_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_batch_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_invstd, bool train, double eps, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_out_native_batch_norm_backward_out(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_batch_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, const ::std::optional<at::Tensor> & save_mean, const ::std::optional<at::Tensor> & save_invstd, bool train, double eps, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_native_batch_norm_backward_out(grad_out, input, weight, running_mean, running_var, save_mean, save_invstd, train, eps, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_batch_norm_backward_reduce_out(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, bool input_g, bool weight_g, bool bias_g, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_backward_reduce_out(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_backward_reduce.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_backward_reduce_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> batch_norm_backward_reduce_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, bool input_g, bool weight_g, bool bias_g) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_backward_reduce_out(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> batch_norm_backward_reduce_outf(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, bool input_g, bool weight_g, bool bias_g, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_backward_reduce_out(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_batch_norm_backward_elemt_out(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, const at::Tensor & sum_dy, const at::Tensor & sum_dy_xmu, const at::Tensor & count, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_backward_elemt_out(grad_out, input, mean, invstd, weight, sum_dy, sum_dy_xmu, count, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_backward_elemt.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_backward_elemt_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & batch_norm_backward_elemt_out(at::Tensor & out, const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, const at::Tensor & sum_dy, const at::Tensor & sum_dy_xmu, const at::Tensor & count) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_backward_elemt_out(grad_out, input, mean, invstd, weight, sum_dy, sum_dy_xmu, count, out);
}
at::Tensor & batch_norm_backward_elemt_outf(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & invstd, const ::std::optional<at::Tensor> & weight, const at::Tensor & sum_dy, const at::Tensor & sum_dy_xmu, const at::Tensor & count, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_backward_elemt_out(grad_out, input, mean, invstd, weight, sum_dy, sum_dy_xmu, count, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_batch_norm_update_stats_out(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::batch_norm_update_stats_out(input, running_mean, running_var, momentum, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("batch_norm_update_stats.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_batch_norm_update_stats_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_update_stats_out(input, running_mean, running_var, momentum, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> batch_norm_update_stats_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_batch_norm_update_stats_out(input, running_mean, running_var, momentum, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___nnpack_spatial_convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nnpack_spatial_convolution(input, weight, bias, C10_AS_INTARRAYREF_SLOW(padding), C10_AS_INTARRAYREF_SLOW(stride));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nnpack_spatial_convolution_out_symint(input, weight, bias, padding, stride, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nnpack_spatial_convolution",
TORCH_FN(wrapper_CompositeExplicitAutograd___nnpack_spatial_convolution));
m.impl("_nnpack_spatial_convolution.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _nnpack_spatial_convolution(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd___nnpack_spatial_convolution(input, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride));
}
at::Tensor _nnpack_spatial_convolution_symint(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd___nnpack_spatial_convolution(input, weight, bias, padding, stride);
}
at::Tensor & _nnpack_spatial_convolution_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & _nnpack_spatial_convolution_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, at::IntArrayRef padding, at::IntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out(input, weight, bias, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & _nnpack_spatial_convolution_symint_out(at::Tensor & out, const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out(input, weight, bias, padding, stride, out);
}
at::Tensor & _nnpack_spatial_convolution_symint_outf(const at::Tensor & input, const at::Tensor & weight, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nnpack_spatial_convolution_out(input, weight, bias, padding, stride, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_ones(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones(size, names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_ones_out(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones_names_out(size, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("ones.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_ones));
m.impl("ones.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_ones_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor ones(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_ones(size, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor ones(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_ones(size, names, dtype, layout, device, pin_memory);
}
at::Tensor & ones_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_ones_out(size, names, out);
}
at::Tensor & ones_outf(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_ones_out(size, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__ones(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones(C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_ones_out(c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones_out(C10_AS_INTARRAYREF_SLOW(size), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("ones",
TORCH_FN(wrapper_CompositeExplicitAutograd__ones));
m.impl("ones.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_ones_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor ones(at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__ones(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor ones(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__ones(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor ones_symint(c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__ones(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor ones_symint(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__ones(size, dtype, layout, device, pin_memory);
}
at::Tensor & ones_out(at::Tensor & out, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_ones_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & ones_outf(at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_ones_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & ones_symint_out(at::Tensor & out, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_ones_out(size, out);
}
at::Tensor & ones_symint_outf(c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_ones_out(size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__ones_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones_like(self, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_ones_like_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::ones_like_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("ones_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__ones_like));
m.impl("ones_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_ones_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor ones_like(const at::Tensor & self, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__ones_like(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor ones_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__ones_like(self, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & ones_like_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_ones_like_out(self, memory_format, out);
}
at::Tensor & ones_like_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_ones_like_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___euclidean_dist(const at::Tensor & x1, const at::Tensor & x2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_euclidean_dist(x1, x2);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__euclidean_dist_out(const at::Tensor & x1, const at::Tensor & x2, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_euclidean_dist_out(x1, x2, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_euclidean_dist",
TORCH_FN(wrapper_CompositeExplicitAutograd___euclidean_dist));
m.impl("_euclidean_dist.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__euclidean_dist_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _euclidean_dist(const at::Tensor & x1, const at::Tensor & x2) {
return wrapper_CompositeExplicitAutograd___euclidean_dist(x1, x2);
}
at::Tensor & _euclidean_dist_out(at::Tensor & out, const at::Tensor & x1, const at::Tensor & x2) {
return wrapper_CompositeExplicitAutograd_out__euclidean_dist_out(x1, x2, out);
}
at::Tensor & _euclidean_dist_outf(const at::Tensor & x1, const at::Tensor & x2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__euclidean_dist_out(x1, x2, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__cdist_forward_out(const at::Tensor & x1, const at::Tensor & x2, double p, ::std::optional<int64_t> compute_mode, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cdist_forward_out(x1, x2, p, compute_mode, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cdist_forward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cdist_forward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _cdist_forward_out(at::Tensor & out, const at::Tensor & x1, const at::Tensor & x2, double p, ::std::optional<int64_t> compute_mode) {
return wrapper_CompositeExplicitAutograd_out__cdist_forward_out(x1, x2, p, compute_mode, out);
}
at::Tensor & _cdist_forward_outf(const at::Tensor & x1, const at::Tensor & x2, double p, ::std::optional<int64_t> compute_mode, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cdist_forward_out(x1, x2, p, compute_mode, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__cdist_backward_out(const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cdist_backward_out(grad, x1, x2, p, cdist, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cdist_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cdist_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _cdist_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist) {
return wrapper_CompositeExplicitAutograd_out__cdist_backward_out(grad, x1, x2, p, cdist, out);
}
at::Tensor & _cdist_backward_outf(const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cdist_backward_out(grad, x1, x2, p, cdist, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__pdist_forward_out(const at::Tensor & self, double p, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pdist_forward_out(self, p, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_pdist_forward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__pdist_forward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _pdist_forward_out(at::Tensor & out, const at::Tensor & self, double p) {
return wrapper_CompositeExplicitAutograd_out__pdist_forward_out(self, p, out);
}
at::Tensor & _pdist_forward_outf(const at::Tensor & self, double p, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__pdist_forward_out(self, p, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__pdist_backward_out(const at::Tensor & grad, const at::Tensor & self, double p, const at::Tensor & pdist, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pdist_backward_out(grad, self, p, pdist, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_pdist_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__pdist_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _pdist_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & self, double p, const at::Tensor & pdist) {
return wrapper_CompositeExplicitAutograd_out__pdist_backward_out(grad, self, p, pdist, out);
}
at::Tensor & _pdist_backward_outf(const at::Tensor & grad, const at::Tensor & self, double p, const at::Tensor & pdist, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__pdist_backward_out(grad, self, p, pdist, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__permute(const at::Tensor & self, at::IntArrayRef dims) {
    // No device check
  // DeviceGuard omitted
  return at::native::permute(self, dims);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("permute",
TORCH_FN(wrapper_CompositeExplicitAutograd__permute));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor permute(const at::Tensor & self, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd__permute(self, dims);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_pixel_shuffle_out(const at::Tensor & self, int64_t upscale_factor, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::pixel_shuffle_out(self, upscale_factor, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("pixel_shuffle.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_pixel_shuffle_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & pixel_shuffle_out(at::Tensor & out, const at::Tensor & self, int64_t upscale_factor) {
return wrapper_CompositeExplicitAutograd_out_pixel_shuffle_out(self, upscale_factor, out);
}
at::Tensor & pixel_shuffle_outf(const at::Tensor & self, int64_t upscale_factor, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_pixel_shuffle_out(self, upscale_factor, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_pixel_unshuffle_out(const at::Tensor & self, int64_t downscale_factor, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::pixel_unshuffle_out(self, downscale_factor, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("pixel_unshuffle.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_pixel_unshuffle_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & pixel_unshuffle_out(at::Tensor & out, const at::Tensor & self, int64_t downscale_factor) {
return wrapper_CompositeExplicitAutograd_out_pixel_unshuffle_out(self, downscale_factor, out);
}
at::Tensor & pixel_unshuffle_outf(const at::Tensor & self, int64_t downscale_factor, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_pixel_unshuffle_out(self, downscale_factor, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_channel_shuffle_out(const at::Tensor & self, c10::SymInt groups, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::channel_shuffle_out_symint(self, groups, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("channel_shuffle.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_channel_shuffle_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & channel_shuffle_out(at::Tensor & out, const at::Tensor & self, int64_t groups) {
return wrapper_CompositeExplicitAutograd_out_channel_shuffle_out(self, groups, out);
}
at::Tensor & channel_shuffle_outf(const at::Tensor & self, int64_t groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_channel_shuffle_out(self, groups, out);
}
at::Tensor & channel_shuffle_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymInt groups) {
return wrapper_CompositeExplicitAutograd_out_channel_shuffle_out(self, groups, out);
}
at::Tensor & channel_shuffle_symint_outf(const at::Tensor & self, c10::SymInt groups, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_channel_shuffle_out(self, groups, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
bool wrapper_CompositeExplicitAutograd__is_pinned(const at::Tensor & self, ::std::optional<at::Device> device) {
    // No device check
  // DeviceGuard omitted
  return at::native::is_pinned(self, device);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("is_pinned",
TORCH_FN(wrapper_CompositeExplicitAutograd__is_pinned));
}
} // anonymous namespace
namespace compositeexplicitautograd {
bool is_pinned(const at::Tensor & self, ::std::optional<at::Device> device) {
return wrapper_CompositeExplicitAutograd__is_pinned(self, device);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___pin_memory(const at::Tensor & self, ::std::optional<at::Device> device) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pin_memory(self, device);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__pin_memory_out(const at::Tensor & self, ::std::optional<at::Device> device, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pin_memory_out(self, device, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_pin_memory",
TORCH_FN(wrapper_CompositeExplicitAutograd___pin_memory));
m.impl("_pin_memory.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__pin_memory_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _pin_memory(const at::Tensor & self, ::std::optional<at::Device> device) {
return wrapper_CompositeExplicitAutograd___pin_memory(self, device);
}
at::Tensor & _pin_memory_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Device> device) {
return wrapper_CompositeExplicitAutograd_out__pin_memory_out(self, device, out);
}
at::Tensor & _pin_memory_outf(const at::Tensor & self, ::std::optional<at::Device> device, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__pin_memory_out(self, device, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__rad2deg(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::rad2deg(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_rad2deg_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rad2deg_out(self, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__rad2deg_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::rad2deg_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rad2deg",
TORCH_FN(wrapper_CompositeExplicitAutograd__rad2deg));
m.impl("rad2deg.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_rad2deg_out));
m.impl("rad2deg_",
TORCH_FN(wrapper_CompositeExplicitAutograd__rad2deg_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rad2deg(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__rad2deg(self);
}
at::Tensor & rad2deg_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_rad2deg_out(self, out);
}
at::Tensor & rad2deg_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rad2deg_out(self, out);
}
at::Tensor & rad2deg_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__rad2deg_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__deg2rad(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::deg2rad(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_deg2rad_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::deg2rad_out(self, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__deg2rad_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::deg2rad_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("deg2rad",
TORCH_FN(wrapper_CompositeExplicitAutograd__deg2rad));
m.impl("deg2rad.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_deg2rad_out));
m.impl("deg2rad_",
TORCH_FN(wrapper_CompositeExplicitAutograd__deg2rad_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor deg2rad(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__deg2rad(self);
}
at::Tensor & deg2rad_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_deg2rad_out(self, out);
}
at::Tensor & deg2rad_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_deg2rad_out(self, out);
}
at::Tensor & deg2rad_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__deg2rad_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__scalar_tensor(const at::Scalar & s, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::scalar_tensor(s, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_scalar_tensor_out(const at::Scalar & s, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::scalar_tensor_out(s, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("scalar_tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd__scalar_tensor));
m.impl("scalar_tensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_scalar_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor scalar_tensor(const at::Scalar & s, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__scalar_tensor(s, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor scalar_tensor(const at::Scalar & s, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__scalar_tensor(s, dtype, layout, device, pin_memory);
}
at::Tensor & scalar_tensor_out(at::Tensor & out, const at::Scalar & s) {
return wrapper_CompositeExplicitAutograd_out_scalar_tensor_out(s, out);
}
at::Tensor & scalar_tensor_outf(const at::Scalar & s, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_scalar_tensor_out(s, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_rand(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand(C10_AS_INTARRAYREF_SLOW(size), names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_rand_out(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand_names_out_symint(size, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rand.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_rand));
m.impl("rand.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_rand_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_rand(c10::fromIntArrayRefSlow(size), names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_rand(c10::fromIntArrayRefSlow(size), names, dtype, layout, device, pin_memory);
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_rand(size, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_rand(size, names, dtype, layout, device, pin_memory);
}
at::Tensor & rand_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_rand_out(c10::fromIntArrayRefSlow(size), names, out);
}
at::Tensor & rand_outf(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_rand_out(c10::fromIntArrayRefSlow(size), names, out);
}
at::Tensor & rand_symint_out(at::Tensor & out, c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_rand_out(size, names, out);
}
at::Tensor & rand_symint_outf(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_rand_out(size, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_with_names_rand(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand(C10_AS_INTARRAYREF_SLOW(size), generator, names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand_generator_with_names_out_symint(size, generator, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rand.generator_with_names",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_with_names_rand));
m.impl("rand.generator_with_names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_with_names_rand(c10::fromIntArrayRefSlow(size), generator, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_with_names_rand(c10::fromIntArrayRefSlow(size), generator, names, dtype, layout, device, pin_memory);
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_with_names_rand(size, generator, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_with_names_rand(size, generator, names, dtype, layout, device, pin_memory);
}
at::Tensor & rand_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out(c10::fromIntArrayRefSlow(size), generator, names, out);
}
at::Tensor & rand_outf(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out(c10::fromIntArrayRefSlow(size), generator, names, out);
}
at::Tensor & rand_symint_out(at::Tensor & out, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out(size, generator, names, out);
}
at::Tensor & rand_symint_outf(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_rand_out(size, generator, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__rand(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand(C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_rand_out(c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand_out(C10_AS_INTARRAYREF_SLOW(size), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rand",
TORCH_FN(wrapper_CompositeExplicitAutograd__rand));
m.impl("rand.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_rand_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rand(at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__rand(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__rand(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor rand_symint(c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__rand(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__rand(size, dtype, layout, device, pin_memory);
}
at::Tensor & rand_out(at::Tensor & out, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_rand_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & rand_outf(at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rand_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & rand_symint_out(at::Tensor & out, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_rand_out(size, out);
}
at::Tensor & rand_symint_outf(c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rand_out(size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_rand(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand(C10_AS_INTARRAYREF_SLOW(size), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rand.generator",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_rand));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_rand(c10::fromIntArrayRefSlow(size), generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_rand(c10::fromIntArrayRefSlow(size), generator, dtype, layout, device, pin_memory);
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_rand(size, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor rand_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_rand(size, generator, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__rand_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand_like(self, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_rand_like_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rand_like_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rand_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__rand_like));
m.impl("rand_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_rand_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rand_like(const at::Tensor & self, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__rand_like(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor rand_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__rand_like(self, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & rand_like_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_rand_like_out(self, memory_format, out);
}
at::Tensor & rand_like_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rand_like_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__randint(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint(high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_randint_out(c10::SymInt high, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_out(high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint",
TORCH_FN(wrapper_CompositeExplicitAutograd__randint));
m.impl("randint.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_randint_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint(int64_t high, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randint(high, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint(int64_t high, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randint(high, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor randint_symint(c10::SymInt high, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randint(high, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint_symint(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randint(high, size, dtype, layout, device, pin_memory);
}
at::Tensor & randint_out(at::Tensor & out, int64_t high, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_randint_out(high, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & randint_outf(int64_t high, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randint_out(high, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & randint_symint_out(at::Tensor & out, c10::SymInt high, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_randint_out(high, size, out);
}
at::Tensor & randint_symint_outf(c10::SymInt high, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randint_out(high, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_randint(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint(high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_generator_out_randint_out(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_out(high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint.generator",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_randint));
m.impl("randint.generator_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_out_randint_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint(int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randint(high, c10::fromIntArrayRefSlow(size), generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint(int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randint(high, c10::fromIntArrayRefSlow(size), generator, dtype, layout, device, pin_memory);
}
at::Tensor randint_symint(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randint(high, size, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint_symint(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randint(high, size, generator, dtype, layout, device, pin_memory);
}
at::Tensor & randint_out(at::Tensor & out, int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_generator_out_randint_out(high, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & randint_outf(int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_out_randint_out(high, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & randint_symint_out(at::Tensor & out, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_generator_out_randint_out(high, size, generator, out);
}
at::Tensor & randint_symint_outf(c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_out_randint_out(high, size, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_low_randint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint(low.guard_int(__FILE__, __LINE__), high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_low_out_randint_out(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_out(low.guard_int(__FILE__, __LINE__), high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint.low",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_randint));
m.impl("randint.low_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_out_randint_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint(int64_t low, int64_t high, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_low_randint(low, high, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint(int64_t low, int64_t high, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_low_randint(low, high, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor randint_symint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_low_randint(low, high, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint_symint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_low_randint(low, high, size, dtype, layout, device, pin_memory);
}
at::Tensor & randint_out(at::Tensor & out, int64_t low, int64_t high, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_low_out_randint_out(low, high, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & randint_outf(int64_t low, int64_t high, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_out_randint_out(low, high, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & randint_symint_out(at::Tensor & out, c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_low_out_randint_out(low, high, size, out);
}
at::Tensor & randint_symint_outf(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_out_randint_out(low, high, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_low_generator_randint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint(low.guard_int(__FILE__, __LINE__), high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_low_generator_out_randint_out(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_out(low.guard_int(__FILE__, __LINE__), high.guard_int(__FILE__, __LINE__), C10_AS_INTARRAYREF_SLOW(size), generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint.low_generator",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_generator_randint));
m.impl("randint.low_generator_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_generator_out_randint_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint(int64_t low, int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_low_generator_randint(low, high, c10::fromIntArrayRefSlow(size), generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint(int64_t low, int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_low_generator_randint(low, high, c10::fromIntArrayRefSlow(size), generator, dtype, layout, device, pin_memory);
}
at::Tensor randint_symint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_low_generator_randint(low, high, size, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randint_symint(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_low_generator_randint(low, high, size, generator, dtype, layout, device, pin_memory);
}
at::Tensor & randint_out(at::Tensor & out, int64_t low, int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_low_generator_out_randint_out(low, high, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & randint_outf(int64_t low, int64_t high, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_generator_out_randint_out(low, high, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & randint_symint_out(at::Tensor & out, c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_low_generator_out_randint_out(low, high, size, generator, out);
}
at::Tensor & randint_symint_outf(c10::SymInt low, c10::SymInt high, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_generator_out_randint_out(low, high, size, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__randint_like(const at::Tensor & self, c10::SymInt high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_like(self, high.guard_int(__FILE__, __LINE__), dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_randint_like_out(const at::Tensor & self, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_like_out_symint(self, high, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__randint_like));
m.impl("randint_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_randint_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint_like(const at::Tensor & self, int64_t high, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randint_like(self, high, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor randint_like(const at::Tensor & self, int64_t high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randint_like(self, high, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor randint_like_symint(const at::Tensor & self, c10::SymInt high, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randint_like(self, high, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor randint_like_symint(const at::Tensor & self, c10::SymInt high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randint_like(self, high, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & randint_like_out(at::Tensor & out, const at::Tensor & self, int64_t high, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_randint_like_out(self, high, memory_format, out);
}
at::Tensor & randint_like_outf(const at::Tensor & self, int64_t high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randint_like_out(self, high, memory_format, out);
}
at::Tensor & randint_like_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_randint_like_out(self, high, memory_format, out);
}
at::Tensor & randint_like_symint_outf(const at::Tensor & self, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randint_like_out(self, high, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_low_dtype_randint_like(const at::Tensor & self, c10::SymInt low, c10::SymInt high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_like(self, low.guard_int(__FILE__, __LINE__), high.guard_int(__FILE__, __LINE__), dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out(const at::Tensor & self, c10::SymInt low, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randint_like_low_dtype_out_symint(self, low, high, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randint_like.low_dtype",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_dtype_randint_like));
m.impl("randint_like.low_dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randint_like(const at::Tensor & self, int64_t low, int64_t high, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_randint_like(self, low, high, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor randint_like(const at::Tensor & self, int64_t low, int64_t high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_randint_like(self, low, high, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor randint_like_symint(const at::Tensor & self, c10::SymInt low, c10::SymInt high, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_randint_like(self, low, high, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor randint_like_symint(const at::Tensor & self, c10::SymInt low, c10::SymInt high, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_randint_like(self, low, high, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & randint_like_out(at::Tensor & out, const at::Tensor & self, int64_t low, int64_t high, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out(self, low, high, memory_format, out);
}
at::Tensor & randint_like_outf(const at::Tensor & self, int64_t low, int64_t high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out(self, low, high, memory_format, out);
}
at::Tensor & randint_like_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymInt low, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out(self, low, high, memory_format, out);
}
at::Tensor & randint_like_symint_outf(const at::Tensor & self, c10::SymInt low, c10::SymInt high, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_low_dtype_out_randint_like_out(self, low, high, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__randn(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn(C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randn",
TORCH_FN(wrapper_CompositeExplicitAutograd__randn));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randn(at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randn(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randn(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor randn_symint(c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randn(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randn(size, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_randn(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn(C10_AS_INTARRAYREF_SLOW(size), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randn.generator",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_randn));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randn(c10::fromIntArrayRefSlow(size), generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randn(c10::fromIntArrayRefSlow(size), generator, dtype, layout, device, pin_memory);
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randn(size, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randn(size, generator, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_randn(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn(C10_AS_INTARRAYREF_SLOW(size), names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_randn_out(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn_names_out_symint(size, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randn.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_randn));
m.impl("randn.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_randn_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_randn(c10::fromIntArrayRefSlow(size), names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_randn(c10::fromIntArrayRefSlow(size), names, dtype, layout, device, pin_memory);
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_randn(size, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_randn(size, names, dtype, layout, device, pin_memory);
}
at::Tensor & randn_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_randn_out(c10::fromIntArrayRefSlow(size), names, out);
}
at::Tensor & randn_outf(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_randn_out(c10::fromIntArrayRefSlow(size), names, out);
}
at::Tensor & randn_symint_out(at::Tensor & out, c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_randn_out(size, names, out);
}
at::Tensor & randn_symint_outf(c10::SymIntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_randn_out(size, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_with_names_randn(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn(C10_AS_INTARRAYREF_SLOW(size), generator, names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn_generator_with_names_out_symint(size, generator, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randn.generator_with_names",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_with_names_randn));
m.impl("randn.generator_with_names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_with_names_randn(c10::fromIntArrayRefSlow(size), generator, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_with_names_randn(c10::fromIntArrayRefSlow(size), generator, names, dtype, layout, device, pin_memory);
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_with_names_randn(size, generator, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randn_symint(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_with_names_randn(size, generator, names, dtype, layout, device, pin_memory);
}
at::Tensor & randn_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out(c10::fromIntArrayRefSlow(size), generator, names, out);
}
at::Tensor & randn_outf(at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out(c10::fromIntArrayRefSlow(size), generator, names, out);
}
at::Tensor & randn_symint_out(at::Tensor & out, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out(size, generator, names, out);
}
at::Tensor & randn_symint_outf(c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_generator_with_names_out_randn_out(size, generator, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__randn_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn_like(self, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_randn_like_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randn_like_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randn_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__randn_like));
m.impl("randn_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_randn_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randn_like(const at::Tensor & self, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randn_like(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor randn_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__randn_like(self, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & randn_like_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_randn_like_out(self, memory_format, out);
}
at::Tensor & randn_like_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randn_like_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__randperm(c10::SymInt n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randperm(n.guard_int(__FILE__, __LINE__), dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_randperm_out(c10::SymInt n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::randperm_out(n.guard_int(__FILE__, __LINE__), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randperm",
TORCH_FN(wrapper_CompositeExplicitAutograd__randperm));
m.impl("randperm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_randperm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randperm(int64_t n, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randperm(n, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randperm(int64_t n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randperm(n, dtype, layout, device, pin_memory);
}
at::Tensor randperm_symint(c10::SymInt n, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__randperm(n, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randperm_symint(c10::SymInt n, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__randperm(n, dtype, layout, device, pin_memory);
}
at::Tensor & randperm_out(at::Tensor & out, int64_t n) {
return wrapper_CompositeExplicitAutograd_out_randperm_out(n, out);
}
at::Tensor & randperm_outf(int64_t n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randperm_out(n, out);
}
at::Tensor & randperm_symint_out(at::Tensor & out, c10::SymInt n) {
return wrapper_CompositeExplicitAutograd_out_randperm_out(n, out);
}
at::Tensor & randperm_symint_outf(c10::SymInt n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_randperm_out(n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_generator_randperm(c10::SymInt n, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::randperm(n.guard_int(__FILE__, __LINE__), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("randperm.generator",
TORCH_FN(wrapper_CompositeExplicitAutograd_generator_randperm));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor randperm(int64_t n, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randperm(n, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randperm(int64_t n, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randperm(n, generator, dtype, layout, device, pin_memory);
}
at::Tensor randperm_symint(c10::SymInt n, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_generator_randperm(n, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor randperm_symint(c10::SymInt n, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_generator_randperm(n, generator, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_step_range(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::range(start, end, step, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("range.step",
TORCH_FN(wrapper_CompositeExplicitAutograd_step_range));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor range(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_step_range(start, end, step, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor range(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_step_range(start, end, step, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__range(const at::Scalar & start, const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::range(start, end, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__range_out(const at::Scalar & start, const at::Scalar & end, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::range_out_no_step(start, end, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("range",
TORCH_FN(wrapper_CompositeExplicitAutograd__range));
m.impl("range.out_",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__range_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor range(const at::Scalar & start, const at::Scalar & end, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__range(start, end, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor range(const at::Scalar & start, const at::Scalar & end, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__range(start, end, dtype, layout, device, pin_memory);
}
at::Tensor & range_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end) {
return wrapper_CompositeExplicitAutograd_out__range_out(start, end, out);
}
at::Tensor & range_outf(const at::Scalar & start, const at::Scalar & end, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__range_out(start, end, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__repeat(const at::Tensor & self, c10::SymIntArrayRef repeats) {
    // No device check
  // DeviceGuard omitted
  return at::native::repeat(self, C10_AS_INTARRAYREF_SLOW(repeats));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_repeat_out(const at::Tensor & self, c10::SymIntArrayRef repeats, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::repeat_out_symint(self, repeats, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("repeat",
TORCH_FN(wrapper_CompositeExplicitAutograd__repeat));
m.impl("repeat.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_repeat_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor repeat(const at::Tensor & self, at::IntArrayRef repeats) {
return wrapper_CompositeExplicitAutograd__repeat(self, c10::fromIntArrayRefSlow(repeats));
}
at::Tensor repeat_symint(const at::Tensor & self, c10::SymIntArrayRef repeats) {
return wrapper_CompositeExplicitAutograd__repeat(self, repeats);
}
at::Tensor & repeat_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef repeats) {
return wrapper_CompositeExplicitAutograd_out_repeat_out(self, c10::fromIntArrayRefSlow(repeats), out);
}
at::Tensor & repeat_outf(const at::Tensor & self, at::IntArrayRef repeats, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_repeat_out(self, c10::fromIntArrayRefSlow(repeats), out);
}
at::Tensor & repeat_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef repeats) {
return wrapper_CompositeExplicitAutograd_out_repeat_out(self, repeats, out);
}
at::Tensor & repeat_symint_outf(const at::Tensor & self, c10::SymIntArrayRef repeats, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_repeat_out(self, repeats, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out(const at::Tensor & repeats, ::std::optional<c10::SymInt> output_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::repeat_interleave_Tensor_out_symint(repeats, output_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("repeat_interleave.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & repeat_interleave_out(at::Tensor & out, const at::Tensor & repeats, ::std::optional<int64_t> output_size) {
return wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out(repeats, output_size.has_value() ? ::std::make_optional(c10::SymInt(*output_size)) : ::std::nullopt, out);
}
at::Tensor & repeat_interleave_outf(const at::Tensor & repeats, ::std::optional<int64_t> output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out(repeats, output_size.has_value() ? ::std::make_optional(c10::SymInt(*output_size)) : ::std::nullopt, out);
}
at::Tensor & repeat_interleave_symint_out(at::Tensor & out, const at::Tensor & repeats, ::std::optional<c10::SymInt> output_size) {
return wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out(repeats, output_size, out);
}
at::Tensor & repeat_interleave_symint_outf(const at::Tensor & repeats, ::std::optional<c10::SymInt> output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_repeat_interleave_out(repeats, output_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___reshape_copy(const at::Tensor & self, c10::SymIntArrayRef size) {
    // No device check
  // DeviceGuard omitted
  return at::native::_reshape_copy_symint(self, size);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_reshape_copy",
TORCH_FN(wrapper_CompositeExplicitAutograd___reshape_copy));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _reshape_copy(const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd___reshape_copy(self, c10::fromIntArrayRefSlow(size));
}
at::Tensor _reshape_copy_symint(const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd___reshape_copy(self, size);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__mkldnn_reshape_out(const at::Tensor & self, at::IntArrayRef shape, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_mkldnn_reshape_out(self, shape, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_mkldnn_reshape.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__mkldnn_reshape_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _mkldnn_reshape_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef shape) {
return wrapper_CompositeExplicitAutograd_out__mkldnn_reshape_out(self, shape, out);
}
at::Tensor & _mkldnn_reshape_outf(const at::Tensor & self, at::IntArrayRef shape, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mkldnn_reshape_out(self, shape, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_relu_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::relu_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("relu.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_relu_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & relu_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_relu_out(self, out);
}
at::Tensor & relu_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_relu_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_int_select(const at::Tensor & self, int64_t dim, c10::SymInt index) {
    // No device check
  // DeviceGuard omitted
  return at::native::select_symint(self, dim, index);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("select.int",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_select));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor select(const at::Tensor & self, int64_t dim, int64_t index) {
return wrapper_CompositeExplicitAutograd_int_select(self, dim, index);
}
at::Tensor select_symint(const at::Tensor & self, int64_t dim, c10::SymInt index) {
return wrapper_CompositeExplicitAutograd_int_select(self, dim, index);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_select_backward_out(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt index, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::select_backward_out_symint(grad_output, input_sizes, dim, index, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("select_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_select_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & select_backward_out(at::Tensor & out, const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t dim, int64_t index) {
return wrapper_CompositeExplicitAutograd_out_select_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), dim, index, out);
}
at::Tensor & select_backward_outf(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t dim, int64_t index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_select_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), dim, index, out);
}
at::Tensor & select_backward_symint_out(at::Tensor & out, const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt index) {
return wrapper_CompositeExplicitAutograd_out_select_backward_out(grad_output, input_sizes, dim, index, out);
}
at::Tensor & select_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_select_backward_out(grad_output, input_sizes, dim, index, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__celu(const at::Tensor & self, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::celu(self, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_celu_out(const at::Tensor & self, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::celu_out(self, alpha, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__celu_(at::Tensor & self, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::celu_(self, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("celu",
TORCH_FN(wrapper_CompositeExplicitAutograd__celu));
m.impl("celu.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_celu_out));
m.impl("celu_",
TORCH_FN(wrapper_CompositeExplicitAutograd__celu_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor celu(const at::Tensor & self, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd__celu(self, alpha);
}
at::Tensor & celu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_out_celu_out(self, alpha, out);
}
at::Tensor & celu_outf(const at::Tensor & self, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_celu_out(self, alpha, out);
}
at::Tensor & celu_(at::Tensor & self, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd__celu_(self, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__detach(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::detach(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("detach",
TORCH_FN(wrapper_CompositeExplicitAutograd__detach));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor detach(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__detach(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__detach_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::detach_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("detach_",
TORCH_FN(wrapper_CompositeExplicitAutograd__detach_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & detach_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__detach_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_slice(const at::Tensor & self, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice(self, dim, start.has_value() ? ::std::make_optional(start->guard_int(__FILE__, __LINE__)) : ::std::nullopt, end.has_value() ? ::std::make_optional(end->guard_int(__FILE__, __LINE__)) : ::std::nullopt, step.guard_int(__FILE__, __LINE__));
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slice.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_slice));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor slice(const at::Tensor & self, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step) {
return wrapper_CompositeExplicitAutograd_Tensor_slice(self, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step);
}
at::Tensor slice_symint(const at::Tensor & self, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd_Tensor_slice(self, dim, start, end, step);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__slice_backward(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt start, c10::SymInt end, c10::SymInt step) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice_backward(grad_output, C10_AS_INTARRAYREF_SLOW(input_sizes), dim, start.guard_int(__FILE__, __LINE__), end.guard_int(__FILE__, __LINE__), step.guard_int(__FILE__, __LINE__));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_slice_backward_out(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt start, c10::SymInt end, c10::SymInt step, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice_backward_out_symint(grad_output, input_sizes, dim, start, end, step, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slice_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__slice_backward));
m.impl("slice_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_slice_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor slice_backward(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t dim, int64_t start, int64_t end, int64_t step) {
return wrapper_CompositeExplicitAutograd__slice_backward(grad_output, c10::fromIntArrayRefSlow(input_sizes), dim, start, end, step);
}
at::Tensor slice_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt start, c10::SymInt end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd__slice_backward(grad_output, input_sizes, dim, start, end, step);
}
at::Tensor & slice_backward_out(at::Tensor & out, const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t dim, int64_t start, int64_t end, int64_t step) {
return wrapper_CompositeExplicitAutograd_out_slice_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), dim, start, end, step, out);
}
at::Tensor & slice_backward_outf(const at::Tensor & grad_output, at::IntArrayRef input_sizes, int64_t dim, int64_t start, int64_t end, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slice_backward_out(grad_output, c10::fromIntArrayRefSlow(input_sizes), dim, start, end, step, out);
}
at::Tensor & slice_backward_symint_out(at::Tensor & out, const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt start, c10::SymInt end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd_out_slice_backward_out(grad_output, input_sizes, dim, start, end, step, out);
}
at::Tensor & slice_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef input_sizes, int64_t dim, c10::SymInt start, c10::SymInt end, c10::SymInt step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slice_backward_out(grad_output, input_sizes, dim, start, end, step, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__slice_inverse(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice_inverse_symint(self, src, dim, start, end, step);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slice_inverse",
TORCH_FN(wrapper_CompositeExplicitAutograd__slice_inverse));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor slice_inverse(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step) {
return wrapper_CompositeExplicitAutograd__slice_inverse(self, src, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step);
}
at::Tensor slice_inverse_symint(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd__slice_inverse(self, src, dim, start, end, step);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_slice_scatter_out(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice_scatter_out_symint(self, src, dim, start, end, step, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slice_scatter.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_slice_scatter_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & slice_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step) {
return wrapper_CompositeExplicitAutograd_out_slice_scatter_out(self, src, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step, out);
}
at::Tensor & slice_scatter_outf(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slice_scatter_out(self, src, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step, out);
}
at::Tensor & slice_scatter_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd_out_slice_scatter_out(self, src, dim, start, end, step, out);
}
at::Tensor & slice_scatter_symint_outf(const at::Tensor & self, const at::Tensor & src, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slice_scatter_out(self, src, dim, start, end, step, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_select_scatter_out(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::select_scatter_out_symint(self, src, dim, index, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("select_scatter.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_select_scatter_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & select_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, int64_t dim, int64_t index) {
return wrapper_CompositeExplicitAutograd_out_select_scatter_out(self, src, dim, index, out);
}
at::Tensor & select_scatter_outf(const at::Tensor & self, const at::Tensor & src, int64_t dim, int64_t index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_select_scatter_out(self, src, dim, index, out);
}
at::Tensor & select_scatter_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index) {
return wrapper_CompositeExplicitAutograd_out_select_scatter_out(self, src, dim, index, out);
}
at::Tensor & select_scatter_symint_outf(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_select_scatter_out(self, src, dim, index, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_diagonal_scatter_out(const at::Tensor & self, const at::Tensor & src, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::diagonal_scatter_out(self, src, offset, dim1, dim2, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("diagonal_scatter.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_diagonal_scatter_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & diagonal_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd_out_diagonal_scatter_out(self, src, offset, dim1, dim2, out);
}
at::Tensor & diagonal_scatter_outf(const at::Tensor & self, const at::Tensor & src, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_diagonal_scatter_out(self, src, offset, dim1, dim2, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::as_strided_scatter_out_symint(self, src, size, stride, storage_offset, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("as_strided_scatter.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & as_strided_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, ::std::optional<int64_t> storage_offset) {
return wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? ::std::make_optional(c10::SymInt(*storage_offset)) : ::std::nullopt, out);
}
at::Tensor & as_strided_scatter_outf(const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, ::std::optional<int64_t> storage_offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? ::std::make_optional(c10::SymInt(*storage_offset)) : ::std::nullopt, out);
}
at::Tensor & as_strided_scatter_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset) {
return wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out(self, src, size, stride, storage_offset, out);
}
at::Tensor & as_strided_scatter_symint_outf(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_as_strided_scatter_out(self, src, size, stride, storage_offset, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_out_softmax_out(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::softmax_out(self, dim, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("softmax.int_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_out_softmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_int_out_softmax_out(self, dim, dtype, out);
}
at::Tensor & softmax_outf(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_out_softmax_out(self, dim, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor_unsafe_split(const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsafe_split(self, split_size.guard_int(__FILE__, __LINE__), dim);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out(const at::Tensor & self, c10::SymInt split_size, int64_t dim, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsafe_split_Tensor_out_symint(self, split_size, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unsafe_split.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_unsafe_split));
m.impl("unsafe_split.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> unsafe_split(const at::Tensor & self, int64_t split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_unsafe_split(self, split_size, dim);
}
::std::vector<at::Tensor> unsafe_split_symint(const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_unsafe_split(self, split_size, dim);
}
void unsafe_split_out(at::TensorList out, const at::Tensor & self, int64_t split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out(self, split_size, dim, out);
}
void unsafe_split_outf(const at::Tensor & self, int64_t split_size, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out(self, split_size, dim, out);
}
void unsafe_split_symint_out(at::TensorList out, const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out(self, split_size, dim, out);
}
void unsafe_split_symint_outf(const at::Tensor & self, c10::SymInt split_size, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_unsafe_split_out(self, split_size, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor_split(const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::split(self, split_size.guard_int(__FILE__, __LINE__), dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("split.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_split));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> split(const at::Tensor & self, int64_t split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_split(self, split_size, dim);
}
::std::vector<at::Tensor> split_symint(const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_split(self, split_size, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd__unsafe_split_with_sizes(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsafe_split_with_sizes(self, C10_AS_INTARRAYREF_SLOW(split_sizes), dim);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsafe_split_with_sizes_out_symint(self, split_sizes, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unsafe_split_with_sizes",
TORCH_FN(wrapper_CompositeExplicitAutograd__unsafe_split_with_sizes));
m.impl("unsafe_split_with_sizes.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> unsafe_split_with_sizes(const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd__unsafe_split_with_sizes(self, c10::fromIntArrayRefSlow(split_sizes), dim);
}
::std::vector<at::Tensor> unsafe_split_with_sizes_symint(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd__unsafe_split_with_sizes(self, split_sizes, dim);
}
void unsafe_split_with_sizes_out(at::TensorList out, const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out(self, c10::fromIntArrayRefSlow(split_sizes), dim, out);
}
void unsafe_split_with_sizes_outf(const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out(self, c10::fromIntArrayRefSlow(split_sizes), dim, out);
}
void unsafe_split_with_sizes_symint_out(at::TensorList out, const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out(self, split_sizes, dim, out);
}
void unsafe_split_with_sizes_symint_outf(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out_unsafe_split_with_sizes_out(self, split_sizes, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd__split_with_sizes(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::split_with_sizes(self, C10_AS_INTARRAYREF_SLOW(split_sizes), dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("split_with_sizes",
TORCH_FN(wrapper_CompositeExplicitAutograd__split_with_sizes));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> split_with_sizes(const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd__split_with_sizes(self, c10::fromIntArrayRefSlow(split_sizes), dim);
}
::std::vector<at::Tensor> split_with_sizes_symint(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd__split_with_sizes(self, split_sizes, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__squeeze(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze",
TORCH_FN(wrapper_CompositeExplicitAutograd__squeeze));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor squeeze(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__squeeze(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__squeeze_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_",
TORCH_FN(wrapper_CompositeExplicitAutograd__squeeze_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__squeeze_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dim_squeeze(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze.dim",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_squeeze));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor squeeze(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_dim_squeeze(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_squeeze_(at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_.dim",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_squeeze_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_(at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_dim_squeeze_(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dims_squeeze(const at::Tensor & self, at::IntArrayRef dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze.dims",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_squeeze));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor squeeze(const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dims_squeeze(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dims_squeeze_(at::Tensor & self, at::IntArrayRef dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_.dims",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_squeeze_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_(at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dims_squeeze_(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___chunk_cat(at::TensorList tensors, int64_t dim, int64_t num_chunks) {
    // No device check
  // DeviceGuard omitted
  return at::native::_chunk_cat(tensors, dim, num_chunks);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__chunk_cat_out(at::TensorList tensors, int64_t dim, int64_t num_chunks, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_chunk_cat_out(tensors, dim, num_chunks, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_chunk_cat",
TORCH_FN(wrapper_CompositeExplicitAutograd___chunk_cat));
m.impl("_chunk_cat.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__chunk_cat_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _chunk_cat(at::TensorList tensors, int64_t dim, int64_t num_chunks) {
return wrapper_CompositeExplicitAutograd___chunk_cat(tensors, dim, num_chunks);
}
at::Tensor & _chunk_cat_out(at::Tensor & out, at::TensorList tensors, int64_t dim, int64_t num_chunks) {
return wrapper_CompositeExplicitAutograd_out__chunk_cat_out(tensors, dim, num_chunks, out);
}
at::Tensor & _chunk_cat_outf(at::TensorList tensors, int64_t dim, int64_t num_chunks, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__chunk_cat_out(tensors, dim, num_chunks, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__stack(at::TensorList tensors, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::stack(tensors, dim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_stack_out(at::TensorList tensors, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::stack_out(tensors, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("stack",
TORCH_FN(wrapper_CompositeExplicitAutograd__stack));
m.impl("stack.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_stack_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor stack(at::TensorList tensors, int64_t dim) {
return wrapper_CompositeExplicitAutograd__stack(tensors, dim);
}
at::Tensor & stack_out(at::Tensor & out, at::TensorList tensors, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_stack_out(tensors, dim, out);
}
at::Tensor & stack_outf(at::TensorList tensors, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_stack_out(tensors, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___stack(at::TensorList tensors, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::_stack(tensors, dim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__stack_out(at::TensorList tensors, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_stack_out(tensors, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_stack",
TORCH_FN(wrapper_CompositeExplicitAutograd___stack));
m.impl("_stack.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__stack_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _stack(at::TensorList tensors, int64_t dim) {
return wrapper_CompositeExplicitAutograd___stack(tensors, dim);
}
at::Tensor & _stack_out(at::Tensor & out, at::TensorList tensors, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out__stack_out(tensors, dim, out);
}
at::Tensor & _stack_outf(at::TensorList tensors, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__stack_out(tensors, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__sum(const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::sum(self, dtype);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_sum_out(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sum_out(self, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sum",
TORCH_FN(wrapper_CompositeExplicitAutograd__sum));
m.impl("sum.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_sum_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sum(const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd__sum(self, dtype);
}
at::Tensor & sum_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_out_sum_out(self, dtype, out);
}
at::Tensor & sum_outf(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_sum_out(self, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_correction_out_std_mean_out(const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::std_mean_correction_out(self, dim, correction, keepdim, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("std_mean.correction_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_correction_out_std_mean_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> std_mean_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim) {
return wrapper_CompositeExplicitAutograd_correction_out_std_mean_out(self, dim, correction, keepdim, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> std_mean_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_correction_out_std_mean_out(self, dim, correction, keepdim, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_prod_out(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::prod_out(self, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("prod.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_prod_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & prod_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_out_prod_out(self, dtype, out);
}
at::Tensor & prod_outf(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_prod_out(self, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__t(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::t(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("t",
TORCH_FN(wrapper_CompositeExplicitAutograd__t));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor t(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__t(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__t_(at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::t_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("t_",
TORCH_FN(wrapper_CompositeExplicitAutograd__t_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & t_(at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__t_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_int_transpose(const at::Tensor & self, int64_t dim0, int64_t dim1) {
    // No device check
  // DeviceGuard omitted
  return at::native::transpose(self, dim0, dim1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("transpose.int",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_transpose));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor transpose(const at::Tensor & self, int64_t dim0, int64_t dim1) {
return wrapper_CompositeExplicitAutograd_int_transpose(self, dim0, dim1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__transpose_(at::Tensor & self, int64_t dim0, int64_t dim1) {
    // No device check
  // DeviceGuard omitted
  return at::native::transpose_(self, dim0, dim1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("transpose_",
TORCH_FN(wrapper_CompositeExplicitAutograd__transpose_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & transpose_(at::Tensor & self, int64_t dim0, int64_t dim1) {
return wrapper_CompositeExplicitAutograd__transpose_(self, dim0, dim1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__mkldnn_transpose_out(const at::Tensor & self, int64_t dim0, int64_t dim1, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_mkldnn_transpose_out(self, dim0, dim1, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_mkldnn_transpose.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__mkldnn_transpose_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _mkldnn_transpose_out(at::Tensor & out, const at::Tensor & self, int64_t dim0, int64_t dim1) {
return wrapper_CompositeExplicitAutograd_out__mkldnn_transpose_out(self, dim0, dim1, out);
}
at::Tensor & _mkldnn_transpose_outf(const at::Tensor & self, int64_t dim0, int64_t dim1, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__mkldnn_transpose_out(self, dim0, dim1, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_flip_out(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::flip_out(self, dims, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("flip.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_flip_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & flip_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd_out_flip_out(self, dims, out);
}
at::Tensor & flip_outf(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_flip_out(self, dims, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_roll_out(const at::Tensor & self, c10::SymIntArrayRef shifts, at::IntArrayRef dims, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::roll_out_symint(self, shifts, dims, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("roll.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_roll_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & roll_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef shifts, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd_out_roll_out(self, c10::fromIntArrayRefSlow(shifts), dims, out);
}
at::Tensor & roll_outf(const at::Tensor & self, at::IntArrayRef shifts, at::IntArrayRef dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_roll_out(self, c10::fromIntArrayRefSlow(shifts), dims, out);
}
at::Tensor & roll_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef shifts, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd_out_roll_out(self, shifts, dims, out);
}
at::Tensor & roll_symint_outf(const at::Tensor & self, c10::SymIntArrayRef shifts, at::IntArrayRef dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_roll_out(self, shifts, dims, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__rot90(const at::Tensor & self, int64_t k, at::IntArrayRef dims) {
    // No device check
  // DeviceGuard omitted
  return at::native::rot90(self, k, dims);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_rot90_out(const at::Tensor & self, int64_t k, at::IntArrayRef dims, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rot90_out(self, k, dims, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rot90",
TORCH_FN(wrapper_CompositeExplicitAutograd__rot90));
m.impl("rot90.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_rot90_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rot90(const at::Tensor & self, int64_t k, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd__rot90(self, k, dims);
}
at::Tensor & rot90_out(at::Tensor & out, const at::Tensor & self, int64_t k, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd_out_rot90_out(self, k, dims, out);
}
at::Tensor & rot90_outf(const at::Tensor & self, int64_t k, at::IntArrayRef dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rot90_out(self, k, dims, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__transform_bias_rescale_qkv_out(const at::Tensor & qkv, const at::Tensor & qkv_bias, int64_t num_heads, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_transform_bias_rescale_qkv_out(qkv, qkv_bias, num_heads, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_transform_bias_rescale_qkv.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__transform_bias_rescale_qkv_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _transform_bias_rescale_qkv_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & qkv, const at::Tensor & qkv_bias, int64_t num_heads) {
return wrapper_CompositeExplicitAutograd_out__transform_bias_rescale_qkv_out(qkv, qkv_bias, num_heads, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _transform_bias_rescale_qkv_outf(const at::Tensor & qkv, const at::Tensor & qkv_bias, int64_t num_heads, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out__transform_bias_rescale_qkv_out(qkv, qkv_bias, num_heads, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_tensor_from_mask_out(const at::Tensor & t, const at::Tensor & mask, bool mask_check, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_from_mask_out(t, mask, mask_check, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_tensor_from_mask.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_tensor_from_mask_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_tensor_from_mask_out(at::Tensor & out, const at::Tensor & t, const at::Tensor & mask, bool mask_check) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_from_mask_out(t, mask, mask_check, out);
}
at::Tensor & _nested_tensor_from_mask_outf(const at::Tensor & t, const at::Tensor & mask, bool mask_check, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_from_mask_out(t, mask, mask_check, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_from_padded_out(const at::Tensor & padded, const at::Tensor & cpu_nested_shape_example, bool fuse_transform_0213, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_from_padded_out(padded, cpu_nested_shape_example, fuse_transform_0213, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_from_padded.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_from_padded_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_from_padded_out(at::Tensor & out, const at::Tensor & padded, const at::Tensor & cpu_nested_shape_example, bool fuse_transform_0213) {
return wrapper_CompositeExplicitAutograd_out__nested_from_padded_out(padded, cpu_nested_shape_example, fuse_transform_0213, out);
}
at::Tensor & _nested_from_padded_outf(const at::Tensor & padded, const at::Tensor & cpu_nested_shape_example, bool fuse_transform_0213, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_from_padded_out(padded, cpu_nested_shape_example, fuse_transform_0213, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_tensor_size_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_size_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_tensor_size.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_tensor_size_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_tensor_size_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_size_out(self, out);
}
at::Tensor & _nested_tensor_size_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_size_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_tensor_strides_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_strides_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_tensor_strides.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_tensor_strides_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_tensor_strides_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_strides_out(self, out);
}
at::Tensor & _nested_tensor_strides_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_strides_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_tensor_storage_offsets_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_storage_offsets_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_tensor_storage_offsets.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_tensor_storage_offsets_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_tensor_storage_offsets_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_storage_offsets_out(self, out);
}
at::Tensor & _nested_tensor_storage_offsets_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_storage_offsets_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_from_padded_and_nested_example_out(const at::Tensor & padded, const at::Tensor & nt_example, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_from_padded_and_nested_example_out(padded, nt_example, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_from_padded_and_nested_example.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_from_padded_and_nested_example_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_from_padded_and_nested_example_out(at::Tensor & out, const at::Tensor & padded, const at::Tensor & nt_example) {
return wrapper_CompositeExplicitAutograd_out__nested_from_padded_and_nested_example_out(padded, nt_example, out);
}
at::Tensor & _nested_from_padded_and_nested_example_outf(const at::Tensor & padded, const at::Tensor & nt_example, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_from_padded_and_nested_example_out(padded, nt_example, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_view_from_buffer_copy_out(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_view_from_buffer_copy_out(self, nested_size, nested_strides, offsets, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_view_from_buffer_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_view_from_buffer_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_view_from_buffer_copy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets) {
return wrapper_CompositeExplicitAutograd_out__nested_view_from_buffer_copy_out(self, nested_size, nested_strides, offsets, out);
}
at::Tensor & _nested_view_from_buffer_copy_outf(const at::Tensor & self, const at::Tensor & nested_size, const at::Tensor & nested_strides, const at::Tensor & offsets, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_view_from_buffer_copy_out(self, nested_size, nested_strides, offsets, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_view_from_jagged_copy_out(const at::Tensor & self, const at::Tensor & offsets, const at::Tensor & dummy, const ::std::optional<at::Tensor> & lengths, int64_t ragged_idx, const ::std::optional<at::Tensor> & min_seqlen, const ::std::optional<at::Tensor> & max_seqlen, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_view_from_jagged_copy_out(self, offsets, dummy, lengths, ragged_idx, min_seqlen, max_seqlen, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_view_from_jagged_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_view_from_jagged_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_view_from_jagged_copy_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & offsets, const at::Tensor & dummy, const ::std::optional<at::Tensor> & lengths, int64_t ragged_idx, const ::std::optional<at::Tensor> & min_seqlen, const ::std::optional<at::Tensor> & max_seqlen) {
return wrapper_CompositeExplicitAutograd_out__nested_view_from_jagged_copy_out(self, offsets, dummy, lengths, ragged_idx, min_seqlen, max_seqlen, out);
}
at::Tensor & _nested_view_from_jagged_copy_outf(const at::Tensor & self, const at::Tensor & offsets, const at::Tensor & dummy, const ::std::optional<at::Tensor> & lengths, int64_t ragged_idx, const ::std::optional<at::Tensor> & min_seqlen, const ::std::optional<at::Tensor> & max_seqlen, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_view_from_jagged_copy_out(self, offsets, dummy, lengths, ragged_idx, min_seqlen, max_seqlen, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_get_values_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_get_values_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_get_values_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_get_values_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _nested_get_values_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__nested_get_values_copy_out(self, out);
}
at::Tensor & _nested_get_values_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_get_values_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__trilinear_out(const at::Tensor & i1, const at::Tensor & i2, const at::Tensor & i3, at::IntArrayRef expand1, at::IntArrayRef expand2, at::IntArrayRef expand3, at::IntArrayRef sumdim, int64_t unroll_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_trilinear_out(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_trilinear.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__trilinear_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _trilinear_out(at::Tensor & out, const at::Tensor & i1, const at::Tensor & i2, const at::Tensor & i3, at::IntArrayRef expand1, at::IntArrayRef expand2, at::IntArrayRef expand3, at::IntArrayRef sumdim, int64_t unroll_dim) {
return wrapper_CompositeExplicitAutograd_out__trilinear_out(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim, out);
}
at::Tensor & _trilinear_outf(const at::Tensor & i1, const at::Tensor & i2, const at::Tensor & i3, at::IntArrayRef expand1, at::IntArrayRef expand2, at::IntArrayRef expand3, at::IntArrayRef sumdim, int64_t unroll_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__trilinear_out(i1, i2, i3, expand1, expand2, expand3, sumdim, unroll_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__unique_out(const at::Tensor & self, bool sorted, bool return_inverse, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unique_out(self, sorted, return_inverse, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unique.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__unique_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _unique_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, bool sorted, bool return_inverse) {
return wrapper_CompositeExplicitAutograd_out__unique_out(self, sorted, return_inverse, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _unique_outf(const at::Tensor & self, bool sorted, bool return_inverse, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__unique_out(self, sorted, return_inverse, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_unique_dim_out(const at::Tensor & self, int64_t dim, bool sorted, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::unique_dim_out(self, dim, sorted, return_inverse, return_counts, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unique_dim.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unique_dim_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_dim_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, int64_t dim, bool sorted, bool return_inverse, bool return_counts) {
return wrapper_CompositeExplicitAutograd_out_unique_dim_out(self, dim, sorted, return_inverse, return_counts, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_dim_outf(const at::Tensor & self, int64_t dim, bool sorted, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_unique_dim_out(self, dim, sorted, return_inverse, return_counts, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_unique_consecutive_out(const at::Tensor & self, bool return_inverse, bool return_counts, ::std::optional<int64_t> dim, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::unique_consecutive_out(self, return_inverse, return_counts, dim, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unique_consecutive.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unique_consecutive_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_consecutive_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, bool return_inverse, bool return_counts, ::std::optional<int64_t> dim) {
return wrapper_CompositeExplicitAutograd_out_unique_consecutive_out(self, return_inverse, return_counts, dim, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_consecutive_outf(const at::Tensor & self, bool return_inverse, bool return_counts, ::std::optional<int64_t> dim, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_unique_consecutive_out(self, return_inverse, return_counts, dim, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_unique_dim_consecutive_out(const at::Tensor & self, int64_t dim, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::unique_dim_consecutive_out(self, dim, return_inverse, return_counts, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unique_dim_consecutive.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unique_dim_consecutive_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_dim_consecutive_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, int64_t dim, bool return_inverse, bool return_counts) {
return wrapper_CompositeExplicitAutograd_out_unique_dim_consecutive_out(self, dim, return_inverse, return_counts, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> unique_dim_consecutive_outf(const at::Tensor & self, int64_t dim, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out_unique_dim_consecutive_out(self, dim, return_inverse, return_counts, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__unique2_out(const at::Tensor & self, bool sorted, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unique2_out(self, sorted, return_inverse, return_counts, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unique2.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__unique2_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _unique2_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, bool sorted, bool return_inverse, bool return_counts) {
return wrapper_CompositeExplicitAutograd_out__unique2_out(self, sorted, return_inverse, return_counts, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _unique2_outf(const at::Tensor & self, bool sorted, bool return_inverse, bool return_counts, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out__unique2_out(self, sorted, return_inverse, return_counts, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___unsafe_view(const at::Tensor & self, c10::SymIntArrayRef size) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_view(self, C10_AS_INTARRAYREF_SLOW(size));
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__unsafe_view_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_unsafe_view_out_symint(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_unsafe_view",
TORCH_FN(wrapper_CompositeExplicitAutograd___unsafe_view));
m.impl("_unsafe_view.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__unsafe_view_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _unsafe_view(const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd___unsafe_view(self, c10::fromIntArrayRefSlow(size));
}
at::Tensor _unsafe_view_symint(const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd___unsafe_view(self, size);
}
at::Tensor & _unsafe_view_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__unsafe_view_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & _unsafe_view_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__unsafe_view_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & _unsafe_view_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__unsafe_view_out(self, size, out);
}
at::Tensor & _unsafe_view_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__unsafe_view_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__unsqueeze(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsqueeze(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unsqueeze",
TORCH_FN(wrapper_CompositeExplicitAutograd__unsqueeze));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor unsqueeze(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd__unsqueeze(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__unsqueeze_(at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsqueeze_(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unsqueeze_",
TORCH_FN(wrapper_CompositeExplicitAutograd__unsqueeze_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & unsqueeze_(at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd__unsqueeze_(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_correction_out_var_mean_out(const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::var_mean_correction_out(self, dim, correction, keepdim, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("var_mean.correction_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_correction_out_var_mean_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> var_mean_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim) {
return wrapper_CompositeExplicitAutograd_correction_out_var_mean_out(self, dim, correction, keepdim, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> var_mean_outf(const at::Tensor & self, at::OptionalIntArrayRef dim, const ::std::optional<at::Scalar> & correction, bool keepdim, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_correction_out_var_mean_out(self, dim, correction, keepdim, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__weight_norm_interface_out(const at::Tensor & v, const at::Tensor & g, int64_t dim, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_weight_norm_interface_out(v, g, dim, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_weight_norm_interface.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__weight_norm_interface_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & v, const at::Tensor & g, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out__weight_norm_interface_out(v, g, dim, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_outf(const at::Tensor & v, const at::Tensor & g, int64_t dim, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__weight_norm_interface_out(v, g, dim, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__weight_norm_interface_backward_out(const at::Tensor & grad_w, const at::Tensor & saved_v, const at::Tensor & saved_g, const at::Tensor & saved_norms, int64_t dim, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_weight_norm_interface_backward_out(grad_w, saved_v, saved_g, saved_norms, dim, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_weight_norm_interface_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__weight_norm_interface_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_backward_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & grad_w, const at::Tensor & saved_v, const at::Tensor & saved_g, const at::Tensor & saved_norms, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out__weight_norm_interface_backward_out(grad_w, saved_v, saved_g, saved_norms, dim, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_backward_outf(const at::Tensor & grad_w, const at::Tensor & saved_v, const at::Tensor & saved_g, const at::Tensor & saved_norms, int64_t dim, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__weight_norm_interface_backward_out(grad_w, saved_v, saved_g, saved_norms, dim, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_names_zeros(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros(size, names, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_names_out_zeros_out(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros_names_out(size, names, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("zeros.names",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_zeros));
m.impl("zeros.names_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_names_out_zeros_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor zeros(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_names_zeros(size, names, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor zeros(at::IntArrayRef size, ::std::optional<at::DimnameList> names, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_names_zeros(size, names, dtype, layout, device, pin_memory);
}
at::Tensor & zeros_out(at::Tensor & out, at::IntArrayRef size, ::std::optional<at::DimnameList> names) {
return wrapper_CompositeExplicitAutograd_names_out_zeros_out(size, names, out);
}
at::Tensor & zeros_outf(at::IntArrayRef size, ::std::optional<at::DimnameList> names, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_names_out_zeros_out(size, names, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out(c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_efficientzerotensor_out_symint(size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_efficientzerotensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _efficientzerotensor_out(at::Tensor & out, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & _efficientzerotensor_outf(at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & _efficientzerotensor_symint_out(at::Tensor & out, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out(size, out);
}
at::Tensor & _efficientzerotensor_symint_outf(c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__efficientzerotensor_out(size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__zeros(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros_symint(size, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_zeros_out(c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros_out(C10_AS_INTARRAYREF_SLOW(size), out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("zeros",
TORCH_FN(wrapper_CompositeExplicitAutograd__zeros));
m.impl("zeros.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_zeros_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor zeros(at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__zeros(c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor zeros(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__zeros(c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor zeros_symint(c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__zeros(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor zeros_symint(c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__zeros(size, dtype, layout, device, pin_memory);
}
at::Tensor & zeros_out(at::Tensor & out, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_zeros_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & zeros_outf(at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_zeros_out(c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & zeros_symint_out(at::Tensor & out, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_zeros_out(size, out);
}
at::Tensor & zeros_symint_outf(c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_zeros_out(size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__zeros_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros_like(self, dtype, layout, device, pin_memory, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_zeros_like_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::zeros_like_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("zeros_like",
TORCH_FN(wrapper_CompositeExplicitAutograd__zeros_like));
m.impl("zeros_like.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_zeros_like_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor zeros_like(const at::Tensor & self, at::TensorOptions options, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__zeros_like(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor zeros_like(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__zeros_like(self, dtype, layout, device, pin_memory, memory_format);
}
at::Tensor & zeros_like_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_zeros_like_out(self, memory_format, out);
}
at::Tensor & zeros_like_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_zeros_like_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__standard_gamma_grad_out(const at::Tensor & self, const at::Tensor & output, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_standard_gamma_grad_out(self, output, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_standard_gamma_grad.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__standard_gamma_grad_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _standard_gamma_grad_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & output) {
return wrapper_CompositeExplicitAutograd_out__standard_gamma_grad_out(self, output, out);
}
at::Tensor & _standard_gamma_grad_outf(const at::Tensor & self, const at::Tensor & output, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__standard_gamma_grad_out(self, output, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__standard_gamma_out(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_standard_gamma_out(self, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_standard_gamma.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__standard_gamma_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _standard_gamma_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out__standard_gamma_out(self, generator, out);
}
at::Tensor & _standard_gamma_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__standard_gamma_out(self, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__dirichlet_grad_out(const at::Tensor & x, const at::Tensor & alpha, const at::Tensor & total, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_dirichlet_grad_out(x, alpha, total, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_dirichlet_grad.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__dirichlet_grad_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _dirichlet_grad_out(at::Tensor & out, const at::Tensor & x, const at::Tensor & alpha, const at::Tensor & total) {
return wrapper_CompositeExplicitAutograd_out__dirichlet_grad_out(x, alpha, total, out);
}
at::Tensor & _dirichlet_grad_outf(const at::Tensor & x, const at::Tensor & alpha, const at::Tensor & total, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__dirichlet_grad_out(x, alpha, total, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sample_dirichlet_out(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sample_dirichlet_out(self, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sample_dirichlet.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sample_dirichlet_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sample_dirichlet_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out__sample_dirichlet_out(self, generator, out);
}
at::Tensor & _sample_dirichlet_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sample_dirichlet_out(self, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_poisson_out(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::poisson_out(self, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("poisson.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_poisson_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & poisson_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_poisson_out(self, generator, out);
}
at::Tensor & poisson_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_poisson_out(self, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_binomial_out(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::binomial_out(count, prob, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("binomial.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_binomial_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & binomial_out(at::Tensor & out, const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_binomial_out(count, prob, generator, out);
}
at::Tensor & binomial_outf(const at::Tensor & count, const at::Tensor & prob, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_binomial_out(count, prob, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_native_norm_out(const at::Tensor & self, const at::Scalar & p, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_norm_out(self, p, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_norm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_native_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & native_norm_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & p) {
return wrapper_CompositeExplicitAutograd_out_native_norm_out(self, p, out);
}
at::Tensor & native_norm_outf(const at::Tensor & self, const at::Scalar & p, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_native_norm_out(self, p, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_ScalarOpt_dim_dtype_out_native_norm_out(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::native_norm_ScalarOpt_dim_dtype_out(self, p, dim, keepdim, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("native_norm.ScalarOpt_dim_dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarOpt_dim_dtype_out_native_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & native_norm_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_ScalarOpt_dim_dtype_out_native_norm_out(self, p, dim, keepdim, dtype, out);
}
at::Tensor & native_norm_outf(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_ScalarOpt_dim_dtype_out_native_norm_out(self, p, dim, keepdim, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___batch_norm_with_update_functional(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::_batch_norm_with_update_functional(input, weight, bias, running_mean, running_var, momentum, eps);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_batch_norm_with_update_functional",
TORCH_FN(wrapper_CompositeExplicitAutograd___batch_norm_with_update_functional));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> _batch_norm_with_update_functional(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const at::Tensor & running_mean, const at::Tensor & running_var, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd___batch_norm_with_update_functional(input, weight, bias, running_mean, running_var, momentum, eps);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___batch_norm_no_update(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps) {
    // No device check
  // DeviceGuard omitted
  return at::native::_batch_norm_no_update(input, weight, bias, running_mean, running_var, momentum, eps);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__batch_norm_no_update_out(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
    // No device check
  // DeviceGuard omitted
  return at::native::_batch_norm_no_update_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2, out3);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_batch_norm_no_update",
TORCH_FN(wrapper_CompositeExplicitAutograd___batch_norm_no_update));
m.impl("_batch_norm_no_update.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__batch_norm_no_update_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> _batch_norm_no_update(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd___batch_norm_no_update(input, weight, bias, running_mean, running_var, momentum, eps);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _batch_norm_no_update_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps) {
return wrapper_CompositeExplicitAutograd_out__batch_norm_no_update_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2, out3);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _batch_norm_no_update_outf(const at::Tensor & input, const ::std::optional<at::Tensor> & weight, const ::std::optional<at::Tensor> & bias, const ::std::optional<at::Tensor> & running_mean, const ::std::optional<at::Tensor> & running_var, double momentum, double eps, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) {
return wrapper_CompositeExplicitAutograd_out__batch_norm_no_update_out(input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2, out3);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dim__sparse_sum(const at::Tensor & self, at::IntArrayRef dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_sum(self, dim);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_out__sparse_sum_out(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_sum_dim_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_sum.dim",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim__sparse_sum));
m.impl("_sparse_sum.dim_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_out__sparse_sum_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _sparse_sum(const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dim__sparse_sum(self, dim);
}
at::Tensor & _sparse_sum_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dim_out__sparse_sum_out(self, dim, out);
}
at::Tensor & _sparse_sum_outf(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dim_out__sparse_sum_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_sum_backward_out(const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_sum_backward_out(grad, self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_sum_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_sum_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_sum_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_out__sparse_sum_backward_out(grad, self, dim, out);
}
at::Tensor & _sparse_sum_backward_outf(const at::Tensor & grad, const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_sum_backward_out(grad, self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_sum_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_csr_sum_dim_dtype_out(self, dim, keepdim, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_csr_sum.dim_dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_sum_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_csr_sum_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_sum_out(self, dim, keepdim, dtype, out);
}
at::Tensor & _sparse_csr_sum_outf(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_sum_out(self, dim, keepdim, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_prod_out(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_csr_prod_dim_dtype_out(self, dim, keepdim, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_csr_prod.dim_dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_prod_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_csr_prod_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_prod_out(self, dim, keepdim, dtype, out);
}
at::Tensor & _sparse_csr_prod_outf(const at::Tensor & self, at::IntArrayRef dim, bool keepdim, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dim_dtype_out__sparse_csr_prod_out(self, dim, keepdim, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_softmax_out(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_softmax_out(self, dim, half_to_float, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_softmax.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_softmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool half_to_float) {
return wrapper_CompositeExplicitAutograd_out__sparse_softmax_out(self, dim, half_to_float, out);
}
at::Tensor & _sparse_softmax_outf(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_softmax_out(self, dim, half_to_float, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_softmax_backward_data_out(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_softmax_backward_data_out(grad_output, output, dim, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_softmax_backward_data.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_softmax_backward_data_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_softmax_backward_data_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__sparse_softmax_backward_data_out(grad_output, output, dim, self, out);
}
at::Tensor & _sparse_softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_softmax_backward_data_out(grad_output, output, dim, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_out(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_log_softmax_out(self, dim, half_to_float, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_log_softmax.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_log_softmax_out(at::Tensor & out, const at::Tensor & self, int64_t dim, bool half_to_float) {
return wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_out(self, dim, half_to_float, out);
}
at::Tensor & _sparse_log_softmax_outf(const at::Tensor & self, int64_t dim, bool half_to_float, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_out(self, dim, half_to_float, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_backward_data_out(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_log_softmax_backward_data_out(grad_output, output, dim, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_log_softmax_backward_data.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_backward_data_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_log_softmax_backward_data_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_backward_data_out(grad_output, output, dim, self, out);
}
at::Tensor & _sparse_log_softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_log_softmax_backward_data_out(grad_output, output, dim, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__spdiags_out(const at::Tensor & diagonals, const at::Tensor & offsets, at::IntArrayRef shape, ::std::optional<at::Layout> layout, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_spdiags_out(diagonals, offsets, shape, layout, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_spdiags.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__spdiags_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _spdiags_out(at::Tensor & out, const at::Tensor & diagonals, const at::Tensor & offsets, at::IntArrayRef shape, ::std::optional<at::Layout> layout) {
return wrapper_CompositeExplicitAutograd_out__spdiags_out(diagonals, offsets, shape, layout, out);
}
at::Tensor & _spdiags_outf(const at::Tensor & diagonals, const at::Tensor & offsets, at::IntArrayRef shape, ::std::optional<at::Layout> layout, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__spdiags_out(diagonals, offsets, shape, layout, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_norm(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::ScalarType dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::norm(self, p, dtype);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_out_norm_out(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::ScalarType dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::norm_ScalarOpt_dtype_out(self, p, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("norm.ScalarOpt_dtype",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_norm));
m.impl("norm.ScalarOpt_dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_out_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor norm(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_norm(self, p, dtype);
}
at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_out_norm_out(self, p, dtype, out);
}
at::Tensor & norm_outf(const at::Tensor & self, const ::std::optional<at::Scalar> & p, at::ScalarType dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_ScalarOpt_dtype_out_norm_out(self, p, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_norm(const at::Tensor & self, const at::Scalar & p) {
    // No device check
  // DeviceGuard omitted
  return at::native::norm(self, p);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_norm_out(const at::Tensor & self, const at::Scalar & p, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::norm_Scalar_out(self, p, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("norm.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_norm));
m.impl("norm.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor norm(const at::Tensor & self, const at::Scalar & p) {
return wrapper_CompositeExplicitAutograd_Scalar_norm(self, p);
}
at::Tensor & norm_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & p) {
return wrapper_CompositeExplicitAutograd_Scalar_out_norm_out(self, p, out);
}
at::Tensor & norm_outf(const at::Tensor & self, const at::Scalar & p, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_norm_out(self, p, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd_Tensor_frexp(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::frexp(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("frexp.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_frexp));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> frexp(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_Tensor_frexp(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__clone(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::clone(self, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_clone_out(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::clone_out(self, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("clone",
TORCH_FN(wrapper_CompositeExplicitAutograd__clone));
m.impl("clone.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_clone_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor clone(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__clone(self, memory_format);
}
at::Tensor & clone_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_clone_out(self, memory_format, out);
}
at::Tensor & clone_outf(const at::Tensor & self, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_clone_out(self, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__resize_as(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_as(self, the_template, memory_format);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out_resize_as_out(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_as_out(self, the_template, memory_format, out);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd__resize_as_(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_as_(self, the_template, memory_format);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("resize_as",
TORCH_FN(wrapper_CompositeExplicitAutograd__resize_as));
m.impl("resize_as.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_resize_as_out));
m.impl("resize_as_",
TORCH_FN(wrapper_CompositeExplicitAutograd__resize_as_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor resize_as(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__resize_as(self, the_template, memory_format);
}
const at::Tensor & resize_as_out(const at::Tensor & out, const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out_resize_as_out(self, the_template, memory_format, out);
}
const at::Tensor & resize_as_outf(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_resize_as_out(self, the_template, memory_format, out);
}
const at::Tensor & resize_as_(const at::Tensor & self, const at::Tensor & the_template, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd__resize_as_(self, the_template, memory_format);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__resize_as_sparse(const at::Tensor & self, const at::Tensor & the_template) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_as_sparse(self, the_template);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out_resize_as_sparse_out(const at::Tensor & self, const at::Tensor & the_template, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::resize_as_sparse_out(self, the_template, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("resize_as_sparse",
TORCH_FN(wrapper_CompositeExplicitAutograd__resize_as_sparse));
m.impl("resize_as_sparse.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_resize_as_sparse_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor resize_as_sparse(const at::Tensor & self, const at::Tensor & the_template) {
return wrapper_CompositeExplicitAutograd__resize_as_sparse(self, the_template);
}
const at::Tensor & resize_as_sparse_out(const at::Tensor & out, const at::Tensor & self, const at::Tensor & the_template) {
return wrapper_CompositeExplicitAutograd_out_resize_as_sparse_out(self, the_template, out);
}
const at::Tensor & resize_as_sparse_outf(const at::Tensor & self, const at::Tensor & the_template, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_resize_as_sparse_out(self, the_template, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__zero(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::zero(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_zero_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::zero_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("zero",
TORCH_FN(wrapper_CompositeExplicitAutograd__zero));
m.impl("zero.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_zero_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor zero(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__zero(self);
}
at::Tensor & zero_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_zero_out(self, out);
}
at::Tensor & zero_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_zero_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_sub(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::sub(self, other, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_sub_out(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sub_Scalar_out(self, other, alpha, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_sub_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::sub_(self, other, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sub.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_sub));
m.impl("sub.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_sub_out));
m.impl("sub_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_sub_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sub(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_sub(self, other, alpha);
}
at::Tensor & sub_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_out_sub_out(self, other, alpha, out);
}
at::Tensor & sub_outf(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_sub_out(self, other, alpha, out);
}
at::Tensor & sub_(at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_sub_(self, other, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_rsub_out(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rsub_Tensor_out(self, other, alpha, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rsub.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_rsub_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & rsub_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Tensor_out_rsub_out(self, other, alpha, out);
}
at::Tensor & rsub_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_rsub_out(self, other, alpha, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_rsub(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::rsub(self, other, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_rsub_out(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rsub_Scalar_out(self, other, alpha, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rsub.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_rsub));
m.impl("rsub.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_rsub_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rsub(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_rsub(self, other, alpha);
}
at::Tensor & rsub_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Scalar_out_rsub_out(self, other, alpha, out);
}
at::Tensor & rsub_outf(const at::Tensor & self, const at::Scalar & other, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_rsub_out(self, other, alpha, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___sparse_addmm(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_addmm(self, mat1, mat2, beta, alpha);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_addmm_out(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_addmm_out(self, mat1, mat2, beta, alpha, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_addmm",
TORCH_FN(wrapper_CompositeExplicitAutograd___sparse_addmm));
m.impl("_sparse_addmm.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_addmm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _sparse_addmm(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd___sparse_addmm(self, mat1, mat2, beta, alpha);
}
at::Tensor & _sparse_addmm_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_out__sparse_addmm_out(self, mat1, mat2, beta, alpha, out);
}
at::Tensor & _sparse_addmm_outf(const at::Tensor & self, const at::Tensor & mat1, const at::Tensor & mat2, const at::Scalar & beta, const at::Scalar & alpha, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_addmm_out(self, mat1, mat2, beta, alpha, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___sparse_compressed_tensor_with_dims(int64_t nnz, int64_t dense_dim, at::IntArrayRef size, at::IntArrayRef blocksize, at::ScalarType index_dtype, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_compressed_tensor_with_dims(nnz, dense_dim, size, blocksize, index_dtype, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_compressed_tensor_with_dims",
TORCH_FN(wrapper_CompositeExplicitAutograd___sparse_compressed_tensor_with_dims));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _sparse_compressed_tensor_with_dims(int64_t nnz, int64_t dense_dim, at::IntArrayRef size, at::IntArrayRef blocksize, at::ScalarType index_dtype, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd___sparse_compressed_tensor_with_dims(nnz, dense_dim, size, blocksize, index_dtype, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor _sparse_compressed_tensor_with_dims(int64_t nnz, int64_t dense_dim, at::IntArrayRef size, at::IntArrayRef blocksize, at::ScalarType index_dtype, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd___sparse_compressed_tensor_with_dims(nnz, dense_dim, size, blocksize, index_dtype, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_compressed_tensor(compressed_indices, plain_indices, values, C10_AS_INTARRAYREF_SLOW(size), dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_compressed_tensor.comp_plain_value_size",
TORCH_FN(wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor(compressed_indices, plain_indices, values, c10::fromIntArrayRefSlow(size), c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor(compressed_indices, plain_indices, values, c10::fromIntArrayRefSlow(size), dtype, layout, device, pin_memory);
}
at::Tensor sparse_compressed_tensor_symint(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::SymIntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor(compressed_indices, plain_indices, values, size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor sparse_compressed_tensor_symint(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, c10::SymIntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_size_sparse_compressed_tensor(compressed_indices, plain_indices, values, size, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_comp_plain_value_sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_compressed_tensor(compressed_indices, plain_indices, values, dtype, layout, device, pin_memory);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_compressed_tensor.comp_plain_value",
TORCH_FN(wrapper_CompositeExplicitAutograd_comp_plain_value_sparse_compressed_tensor));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_sparse_compressed_tensor(compressed_indices, plain_indices, values, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor sparse_compressed_tensor(const at::Tensor & compressed_indices, const at::Tensor & plain_indices, const at::Tensor & values, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_comp_plain_value_sparse_compressed_tensor(compressed_indices, plain_indices, values, dtype, layout, device, pin_memory);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_size_sparse_coo_tensor(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_coo_tensor(size, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_size_out_sparse_coo_tensor_out(at::IntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_coo_tensor_size_out(size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_coo_tensor.size",
TORCH_FN(wrapper_CompositeExplicitAutograd_size_sparse_coo_tensor));
m.impl("sparse_coo_tensor.size_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_size_out_sparse_coo_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sparse_coo_tensor(at::IntArrayRef size, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_size_sparse_coo_tensor(size, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor sparse_coo_tensor(at::IntArrayRef size, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_size_sparse_coo_tensor(size, dtype, layout, device, pin_memory);
}
at::Tensor & sparse_coo_tensor_out(at::Tensor & out, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_size_out_sparse_coo_tensor_out(size, out);
}
at::Tensor & sparse_coo_tensor_outf(at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_size_out_sparse_coo_tensor_out(size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_out(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_coo_tensor_with_dims_out(sparse_dim, dense_dim, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_coo_tensor_with_dims.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_coo_tensor_with_dims_out(at::Tensor & out, int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_out(sparse_dim, dense_dim, size, out);
}
at::Tensor & _sparse_coo_tensor_with_dims_outf(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_out(sparse_dim, dense_dim, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out(int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional<bool> is_coalesced, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_coo_tensor_with_dims_and_tensors_out_symint(sparse_dim, dense_dim, size, indices, values, is_coalesced, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_coo_tensor_with_dims_and_tensors.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_coo_tensor_with_dims_and_tensors_out(at::Tensor & out, int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional<bool> is_coalesced) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out(sparse_dim, dense_dim, c10::fromIntArrayRefSlow(size), indices, values, is_coalesced, out);
}
at::Tensor & _sparse_coo_tensor_with_dims_and_tensors_outf(int64_t sparse_dim, int64_t dense_dim, at::IntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional<bool> is_coalesced, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out(sparse_dim, dense_dim, c10::fromIntArrayRefSlow(size), indices, values, is_coalesced, out);
}
at::Tensor & _sparse_coo_tensor_with_dims_and_tensors_symint_out(at::Tensor & out, int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional<bool> is_coalesced) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out(sparse_dim, dense_dim, size, indices, values, is_coalesced, out);
}
at::Tensor & _sparse_coo_tensor_with_dims_and_tensors_symint_outf(int64_t sparse_dim, int64_t dense_dim, c10::SymIntArrayRef size, const at::Tensor & indices, const at::Tensor & values, ::std::optional<bool> is_coalesced, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_coo_tensor_with_dims_and_tensors_out(sparse_dim, dense_dim, size, indices, values, is_coalesced, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__sparse_resize(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_resize(self, size, sparse_dim, dense_dim);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out_sparse_resize_out(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_resize_out(self, size, sparse_dim, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_resize",
TORCH_FN(wrapper_CompositeExplicitAutograd__sparse_resize));
m.impl("sparse_resize.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_sparse_resize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sparse_resize(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
return wrapper_CompositeExplicitAutograd__sparse_resize(self, size, sparse_dim, dense_dim);
}
const at::Tensor & sparse_resize_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
return wrapper_CompositeExplicitAutograd_out_sparse_resize_out(self, size, sparse_dim, dense_dim, out);
}
const at::Tensor & sparse_resize_outf(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_sparse_resize_out(self, size, sparse_dim, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__sparse_resize_and_clear(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_resize_and_clear(self, size, sparse_dim, dense_dim);
}
} // anonymous namespace
namespace {
const at::Tensor & wrapper_CompositeExplicitAutograd_out_sparse_resize_and_clear_out(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_resize_and_clear_out(self, size, sparse_dim, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_resize_and_clear",
TORCH_FN(wrapper_CompositeExplicitAutograd__sparse_resize_and_clear));
m.impl("sparse_resize_and_clear.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_sparse_resize_and_clear_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor sparse_resize_and_clear(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
return wrapper_CompositeExplicitAutograd__sparse_resize_and_clear(self, size, sparse_dim, dense_dim);
}
const at::Tensor & sparse_resize_and_clear_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
return wrapper_CompositeExplicitAutograd_out_sparse_resize_and_clear_out(self, size, sparse_dim, dense_dim, out);
}
const at::Tensor & sparse_resize_and_clear_outf(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_sparse_resize_and_clear_out(self, size, sparse_dim, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_sparse_mask_out(const at::Tensor & self, const at::Tensor & mask, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_mask_out(self, mask, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_mask.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_sparse_mask_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & sparse_mask_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask) {
return wrapper_CompositeExplicitAutograd_out_sparse_mask_out(self, mask, out);
}
at::Tensor & sparse_mask_outf(const at::Tensor & self, const at::Tensor & mask, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_sparse_mask_out(self, mask, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_mask_projection_out(const at::Tensor & self, const at::Tensor & mask, bool accumulate_matches, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_mask_projection_out(self, mask, accumulate_matches, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_mask_projection.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_mask_projection_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_mask_projection_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, bool accumulate_matches) {
return wrapper_CompositeExplicitAutograd_out__sparse_mask_projection_out(self, mask, accumulate_matches, out);
}
at::Tensor & _sparse_mask_projection_outf(const at::Tensor & self, const at::Tensor & mask, bool accumulate_matches, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_mask_projection_out(self, mask, accumulate_matches, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_dense_out(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<bool> masked_grad, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_dense_out(self, dtype, masked_grad, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_dense.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_dense_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_dense_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<bool> masked_grad) {
return wrapper_CompositeExplicitAutograd_out__to_dense_out(self, dtype, masked_grad, out);
}
at::Tensor & _to_dense_outf(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<bool> masked_grad, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_dense_out(self, dtype, masked_grad, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
int64_t wrapper_CompositeExplicitAutograd__sparse_dim(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::sparse_dim_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sparse_dim",
TORCH_FN(wrapper_CompositeExplicitAutograd__sparse_dim));
}
} // anonymous namespace
namespace compositeexplicitautograd {
int64_t sparse_dim(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__sparse_dim(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
int64_t wrapper_CompositeExplicitAutograd__dense_dim(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::dense_dim_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("dense_dim",
TORCH_FN(wrapper_CompositeExplicitAutograd__dense_dim));
}
} // anonymous namespace
namespace compositeexplicitautograd {
int64_t dense_dim(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__dense_dim(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__coalesce_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_coalesce_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_coalesce.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__coalesce_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _coalesce_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__coalesce_out(self, out);
}
at::Tensor & _coalesce_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__coalesce_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
bool wrapper_CompositeExplicitAutograd__is_coalesced(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::is_coalesced_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("is_coalesced",
TORCH_FN(wrapper_CompositeExplicitAutograd__is_coalesced));
}
} // anonymous namespace
namespace compositeexplicitautograd {
bool is_coalesced(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__is_coalesced(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___coalesced(const at::Tensor & self, bool coalesced) {
    // No device check
  // DeviceGuard omitted
  return at::native::_coalesced(self, coalesced);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__coalesced_out(const at::Tensor & self, bool coalesced, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_coalesced_out(self, coalesced, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_coalesced",
TORCH_FN(wrapper_CompositeExplicitAutograd___coalesced));
m.impl("_coalesced.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__coalesced_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _coalesced(const at::Tensor & self, bool coalesced) {
return wrapper_CompositeExplicitAutograd___coalesced(self, coalesced);
}
at::Tensor & _coalesced_out(at::Tensor & out, const at::Tensor & self, bool coalesced) {
return wrapper_CompositeExplicitAutograd_out__coalesced_out(self, coalesced, out);
}
at::Tensor & _coalesced_outf(const at::Tensor & self, bool coalesced, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__coalesced_out(self, coalesced, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__indices(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::indices_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("indices",
TORCH_FN(wrapper_CompositeExplicitAutograd__indices));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor indices(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__indices(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__values(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::values_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("values",
TORCH_FN(wrapper_CompositeExplicitAutograd__values));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor values(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__values(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__crow_indices(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::crow_indices_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("crow_indices",
TORCH_FN(wrapper_CompositeExplicitAutograd__crow_indices));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor crow_indices(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__crow_indices(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__col_indices(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::col_indices_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("col_indices",
TORCH_FN(wrapper_CompositeExplicitAutograd__col_indices));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor col_indices(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__col_indices(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__ccol_indices(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::ccol_indices_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("ccol_indices",
TORCH_FN(wrapper_CompositeExplicitAutograd__ccol_indices));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor ccol_indices(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__ccol_indices(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__row_indices(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::row_indices_default(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("row_indices",
TORCH_FN(wrapper_CompositeExplicitAutograd__row_indices));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor row_indices(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__row_indices(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__copy_sparse_to_sparse(const at::Tensor & self, const at::Tensor & src, bool non_blocking) {
    // No device check
  // DeviceGuard omitted
  return at::native::copy_sparse_to_sparse(self, src, non_blocking);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_copy_sparse_to_sparse_out(const at::Tensor & self, const at::Tensor & src, bool non_blocking, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::copy_sparse_to_sparse_out(self, src, non_blocking, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("copy_sparse_to_sparse",
TORCH_FN(wrapper_CompositeExplicitAutograd__copy_sparse_to_sparse));
m.impl("copy_sparse_to_sparse.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_copy_sparse_to_sparse_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor copy_sparse_to_sparse(const at::Tensor & self, const at::Tensor & src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd__copy_sparse_to_sparse(self, src, non_blocking);
}
at::Tensor & copy_sparse_to_sparse_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd_out_copy_sparse_to_sparse_out(self, src, non_blocking, out);
}
at::Tensor & copy_sparse_to_sparse_outf(const at::Tensor & self, const at::Tensor & src, bool non_blocking, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_copy_sparse_to_sparse_out(self, src, non_blocking, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_int_unbind(const at::Tensor & self, int64_t dim) {
    // No device check
  // DeviceGuard omitted
  return at::native::unbind(self, dim);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unbind.int",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_unbind));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> unbind(const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_int_unbind(self, dim);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_sparse_dim_out__to_sparse_out(const at::Tensor & self, int64_t sparse_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_sparse_dim_out(self, sparse_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse.sparse_dim_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_sparse_dim_out__to_sparse_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_out(at::Tensor & out, const at::Tensor & self, int64_t sparse_dim) {
return wrapper_CompositeExplicitAutograd_sparse_dim_out__to_sparse_out(self, sparse_dim, out);
}
at::Tensor & _to_sparse_outf(const at::Tensor & self, int64_t sparse_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_sparse_dim_out__to_sparse_out(self, sparse_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_sparse_out(const at::Tensor & self, ::std::optional<at::Layout> layout, at::OptionalIntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_out(self, layout, blocksize, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_sparse_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Layout> layout, at::OptionalIntArrayRef blocksize, ::std::optional<int64_t> dense_dim) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_out(self, layout, blocksize, dense_dim, out);
}
at::Tensor & _to_sparse_outf(const at::Tensor & self, ::std::optional<at::Layout> layout, at::OptionalIntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_out(self, layout, blocksize, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_sparse_csr_out(const at::Tensor & self, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_csr_out(self, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse_csr.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_sparse_csr_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_csr_out(at::Tensor & out, const at::Tensor & self, ::std::optional<int64_t> dense_dim) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_csr_out(self, dense_dim, out);
}
at::Tensor & _to_sparse_csr_outf(const at::Tensor & self, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_csr_out(self, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_sparse_csc_out(const at::Tensor & self, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_csc_out(self, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse_csc.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_sparse_csc_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_csc_out(at::Tensor & out, const at::Tensor & self, ::std::optional<int64_t> dense_dim) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_csc_out(self, dense_dim, out);
}
at::Tensor & _to_sparse_csc_outf(const at::Tensor & self, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_csc_out(self, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_sparse_bsr_out(const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_bsr_out(self, blocksize, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse_bsr.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_sparse_bsr_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_bsr_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_bsr_out(self, blocksize, dense_dim, out);
}
at::Tensor & _to_sparse_bsr_outf(const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_bsr_out(self, blocksize, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_sparse_bsc_out(const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_sparse_bsc_out(self, blocksize, dense_dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_sparse_bsc.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_sparse_bsc_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _to_sparse_bsc_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_bsc_out(self, blocksize, dense_dim, out);
}
at::Tensor & _to_sparse_bsc_outf(const at::Tensor & self, at::IntArrayRef blocksize, ::std::optional<int64_t> dense_dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_sparse_bsc_out(self, blocksize, dense_dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_to_mkldnn_out(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::to_mkldnn_out(self, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("to_mkldnn.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_to_mkldnn_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & to_mkldnn_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_out_to_mkldnn_out(self, dtype, out);
}
at::Tensor & to_mkldnn_outf(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_to_mkldnn_out(self, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out(const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_reorder_conv2d_weight_out_symint(self, padding, stride, dilation, groups, input_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_reorder_conv2d_weight.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_reorder_conv2d_weight_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::OptionalIntArrayRef input_size) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out(self, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, input_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*input_size)) : ::std::nullopt, out);
}
at::Tensor & mkldnn_reorder_conv2d_weight_outf(const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::OptionalIntArrayRef input_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out(self, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, input_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*input_size)) : ::std::nullopt, out);
}
at::Tensor & mkldnn_reorder_conv2d_weight_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out(self, padding, stride, dilation, groups, input_size, out);
}
at::Tensor & mkldnn_reorder_conv2d_weight_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv2d_weight_out(self, padding, stride, dilation, groups, input_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out(const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_reorder_conv3d_weight_out_symint(self, padding, stride, dilation, groups, input_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_reorder_conv3d_weight.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_reorder_conv3d_weight_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::OptionalIntArrayRef input_size) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out(self, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, input_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*input_size)) : ::std::nullopt, out);
}
at::Tensor & mkldnn_reorder_conv3d_weight_outf(const at::Tensor & self, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, at::OptionalIntArrayRef input_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out(self, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, input_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*input_size)) : ::std::nullopt, out);
}
at::Tensor & mkldnn_reorder_conv3d_weight_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out(self, padding, stride, dilation, groups, input_size, out);
}
at::Tensor & mkldnn_reorder_conv3d_weight_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, at::OptionalSymIntArrayRef input_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_reorder_conv3d_weight_out(self, padding, stride, dilation, groups, input_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_dynamic_out(const at::Tensor & self, at::ScalarType dtype, bool reduce_range, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantize_per_tensor_dynamic_out(self, dtype, reduce_range, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantize_per_tensor_dynamic.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_dynamic_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantize_per_tensor_dynamic_out(at::Tensor & out, const at::Tensor & self, at::ScalarType dtype, bool reduce_range) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_dynamic_out(self, dtype, reduce_range, out);
}
at::Tensor & quantize_per_tensor_dynamic_outf(const at::Tensor & self, at::ScalarType dtype, bool reduce_range, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_dynamic_out(self, dtype, reduce_range, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_out(const at::Tensor & self, double scale, int64_t zero_point, at::ScalarType dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantize_per_tensor_out(self, scale, zero_point, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantize_per_tensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantize_per_tensor_out(at::Tensor & out, const at::Tensor & self, double scale, int64_t zero_point, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_out(self, scale, zero_point, dtype, out);
}
at::Tensor & quantize_per_tensor_outf(const at::Tensor & self, double scale, int64_t zero_point, at::ScalarType dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_tensor_out(self, scale, zero_point, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_tensor_qparams_out_quantize_per_tensor_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, at::ScalarType dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantize_per_tensor_tensor_qparams_out(self, scale, zero_point, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantize_per_tensor.tensor_qparams_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_qparams_out_quantize_per_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantize_per_tensor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_tensor_qparams_out_quantize_per_tensor_out(self, scale, zero_point, dtype, out);
}
at::Tensor & quantize_per_tensor_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, at::ScalarType dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_tensor_qparams_out_quantize_per_tensor_out(self, scale, zero_point, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_tensors_out_quantize_per_tensor_out(at::TensorList tensors, const at::Tensor & scales, const at::Tensor & zero_points, at::ScalarType dtype, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantize_per_tensor_tensors_out(tensors, scales, zero_points, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantize_per_tensor.tensors_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensors_out_quantize_per_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void quantize_per_tensor_out(at::TensorList out, at::TensorList tensors, const at::Tensor & scales, const at::Tensor & zero_points, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_tensors_out_quantize_per_tensor_out(tensors, scales, zero_points, dtype, out);
}
void quantize_per_tensor_outf(at::TensorList tensors, const at::Tensor & scales, const at::Tensor & zero_points, at::ScalarType dtype, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_tensors_out_quantize_per_tensor_out(tensors, scales, zero_points, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_quantize_per_channel_out(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::quantize_per_channel_out(self, scales, zero_points, axis, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("quantize_per_channel.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_quantize_per_channel_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & quantize_per_channel_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_channel_out(self, scales, zero_points, axis, dtype, out);
}
at::Tensor & quantize_per_channel_outf(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_quantize_per_channel_out(self, scales, zero_points, axis, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_self_out_dequantize_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::dequantize_self_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("dequantize.self_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_self_out_dequantize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & dequantize_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_self_out_dequantize_out(self, out);
}
at::Tensor & dequantize_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_self_out_dequantize_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_tensors_out_dequantize_out(at::TensorList tensors, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::dequantize_tensors_out(tensors, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("dequantize.tensors_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensors_out_dequantize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void dequantize_out(at::TensorList out, at::TensorList tensors) {
return wrapper_CompositeExplicitAutograd_tensors_out_dequantize_out(tensors, out);
}
void dequantize_outf(at::TensorList tensors, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_tensors_out_dequantize_out(tensors, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_q_per_channel_scales_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::q_per_channel_scales_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("q_per_channel_scales.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_q_per_channel_scales_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & q_per_channel_scales_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_q_per_channel_scales_out(self, out);
}
at::Tensor & q_per_channel_scales_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_q_per_channel_scales_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_q_per_channel_zero_points_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::q_per_channel_zero_points_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("q_per_channel_zero_points.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_q_per_channel_zero_points_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & q_per_channel_zero_points_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_q_per_channel_zero_points_out(self, out);
}
at::Tensor & q_per_channel_zero_points_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_q_per_channel_zero_points_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_int_repr_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::int_repr_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("int_repr.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_int_repr_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & int_repr_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_int_repr_out(self, out);
}
at::Tensor & int_repr_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_int_repr_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__make_per_tensor_quantized_tensor_out(const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_make_per_tensor_quantized_tensor_out(self, scale, zero_point, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_make_per_tensor_quantized_tensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__make_per_tensor_quantized_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _make_per_tensor_quantized_tensor_out(at::Tensor & out, const at::Tensor & self, double scale, int64_t zero_point) {
return wrapper_CompositeExplicitAutograd_out__make_per_tensor_quantized_tensor_out(self, scale, zero_point, out);
}
at::Tensor & _make_per_tensor_quantized_tensor_outf(const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__make_per_tensor_quantized_tensor_out(self, scale, zero_point, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__make_per_channel_quantized_tensor_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_make_per_channel_quantized_tensor_out(self, scale, zero_point, axis, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_make_per_channel_quantized_tensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__make_per_channel_quantized_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _make_per_channel_quantized_tensor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis) {
return wrapper_CompositeExplicitAutograd_out__make_per_channel_quantized_tensor_out(self, scale, zero_point, axis, out);
}
at::Tensor & _make_per_channel_quantized_tensor_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__make_per_channel_quantized_tensor_out(self, scale, zero_point, axis, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_fake_quantize_per_tensor_affine_cachemask_out(const at::Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::fake_quantize_per_tensor_affine_cachemask_out(self, scale, zero_point, quant_min, quant_max, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fake_quantize_per_tensor_affine_cachemask.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_fake_quantize_per_tensor_affine_cachemask_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> fake_quantize_per_tensor_affine_cachemask_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max) {
return wrapper_CompositeExplicitAutograd_out_fake_quantize_per_tensor_affine_cachemask_out(self, scale, zero_point, quant_min, quant_max, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> fake_quantize_per_tensor_affine_cachemask_outf(const at::Tensor & self, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_fake_quantize_per_tensor_affine_cachemask_out(self, scale, zero_point, quant_min, quant_max, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fake_quantize_per_tensor_affine_cachemask_tensor_qparams.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _fake_quantize_per_tensor_affine_cachemask_tensor_qparams_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, const at::Tensor & fake_quant_enabled, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_per_tensor_affine_cachemask_tensor_qparams_out(self, scale, zero_point, fake_quant_enabled, quant_min, quant_max, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_tensor_affine_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fake_quantize_learnable_per_tensor_affine_out(self, scale, zero_point, quant_min, quant_max, grad_factor, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fake_quantize_learnable_per_tensor_affine.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_tensor_affine_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _fake_quantize_learnable_per_tensor_affine_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_tensor_affine_out(self, scale, zero_point, quant_min, quant_max, grad_factor, out);
}
at::Tensor & _fake_quantize_learnable_per_tensor_affine_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t quant_min, int64_t quant_max, double grad_factor, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_tensor_affine_out(self, scale, zero_point, quant_min, quant_max, grad_factor, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out_fake_quantize_per_channel_affine_cachemask_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::fake_quantize_per_channel_affine_cachemask_out(self, scale, zero_point, axis, quant_min, quant_max, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fake_quantize_per_channel_affine_cachemask.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_fake_quantize_per_channel_affine_cachemask_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> fake_quantize_per_channel_affine_cachemask_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max) {
return wrapper_CompositeExplicitAutograd_out_fake_quantize_per_channel_affine_cachemask_out(self, scale, zero_point, axis, quant_min, quant_max, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> fake_quantize_per_channel_affine_cachemask_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out_fake_quantize_per_channel_affine_cachemask_out(self, scale, zero_point, axis, quant_min, quant_max, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_channel_affine_out(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, double grad_factor, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fake_quantize_learnable_per_channel_affine_out(self, scale, zero_point, axis, quant_min, quant_max, grad_factor, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fake_quantize_learnable_per_channel_affine.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_channel_affine_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _fake_quantize_learnable_per_channel_affine_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, double grad_factor) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_channel_affine_out(self, scale, zero_point, axis, quant_min, quant_max, grad_factor, out);
}
at::Tensor & _fake_quantize_learnable_per_channel_affine_outf(const at::Tensor & self, const at::Tensor & scale, const at::Tensor & zero_point, int64_t axis, int64_t quant_min, int64_t quant_max, double grad_factor, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__fake_quantize_learnable_per_channel_affine_out(self, scale, zero_point, axis, quant_min, quant_max, grad_factor, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___fused_moving_avg_obs_fq_helper_functional(const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, const at::Tensor & running_min, const at::Tensor & running_max, const at::Tensor & scale, const at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant, bool symmetric_quant) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_moving_avg_obs_fq_helper_functional(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant, symmetric_quant);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__fused_moving_avg_obs_fq_helper_out(const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, at::Tensor & running_min, at::Tensor & running_max, at::Tensor & scale, at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant, bool symmetric_quant, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_moving_avg_obs_fq_helper_out(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant, symmetric_quant, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_moving_avg_obs_fq_helper_functional",
TORCH_FN(wrapper_CompositeExplicitAutograd___fused_moving_avg_obs_fq_helper_functional));
m.impl("_fused_moving_avg_obs_fq_helper.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_moving_avg_obs_fq_helper_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor,at::Tensor> _fused_moving_avg_obs_fq_helper_functional(const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, const at::Tensor & running_min, const at::Tensor & running_max, const at::Tensor & scale, const at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant, bool symmetric_quant) {
return wrapper_CompositeExplicitAutograd___fused_moving_avg_obs_fq_helper_functional(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant, symmetric_quant);
}
::std::tuple<at::Tensor &,at::Tensor &> _fused_moving_avg_obs_fq_helper_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, at::Tensor & running_min, at::Tensor & running_max, at::Tensor & scale, at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant, bool symmetric_quant) {
return wrapper_CompositeExplicitAutograd_out__fused_moving_avg_obs_fq_helper_out(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant, symmetric_quant, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _fused_moving_avg_obs_fq_helper_outf(const at::Tensor & self, const at::Tensor & observer_on, const at::Tensor & fake_quant_on, at::Tensor & running_min, at::Tensor & running_max, at::Tensor & scale, at::Tensor & zero_point, double averaging_const, int64_t quant_min, int64_t quant_max, int64_t ch_axis, bool per_row_fake_quant, bool symmetric_quant, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__fused_moving_avg_obs_fq_helper_out(self, observer_on, fake_quant_on, running_min, running_max, scale, zero_point, averaging_const, quant_min, quant_max, ch_axis, per_row_fake_quant, symmetric_quant, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___to_copy(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_copy(self, dtype, layout, device, pin_memory, non_blocking, memory_format);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__to_copy_out(const at::Tensor & self, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_to_copy_out(self, non_blocking, memory_format, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_to_copy",
TORCH_FN(wrapper_CompositeExplicitAutograd___to_copy));
m.impl("_to_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__to_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _to_copy(const at::Tensor & self, at::TensorOptions options, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd___to_copy(self, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt(), non_blocking, c10::impl::check_tensor_options_and_extract_memory_format(options, memory_format));
}
at::Tensor _to_copy(const at::Tensor & self, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd___to_copy(self, dtype, layout, device, pin_memory, non_blocking, memory_format);
}
at::Tensor & _to_copy_out(at::Tensor & out, const at::Tensor & self, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format) {
return wrapper_CompositeExplicitAutograd_out__to_copy_out(self, non_blocking, memory_format, out);
}
at::Tensor & _to_copy_outf(const at::Tensor & self, bool non_blocking, ::std::optional<at::MemoryFormat> memory_format, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__to_copy_out(self, non_blocking, memory_format, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__lstm_mps_out(const at::Tensor & input, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5) {
    // No device check
  // DeviceGuard omitted
  return at::native::_lstm_mps_out(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2, out3, out4, out5);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_lstm_mps.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__lstm_mps_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _lstm_mps_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5, const at::Tensor & input, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
return wrapper_CompositeExplicitAutograd_out__lstm_mps_out(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2, out3, out4, out5);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _lstm_mps_outf(const at::Tensor & input, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, at::Tensor & out5) {
return wrapper_CompositeExplicitAutograd_out__lstm_mps_out(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2, out3, out4, out5);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_out_lstm_mps_backward_out(const ::std::optional<at::Tensor> & grad_y, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & z_state, const at::Tensor & cell_state_fwd, const at::Tensor & input, const at::Tensor & layersOutputs, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, at::Tensor & out0, at::TensorList out1, at::TensorList out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::lstm_mps_backward_out(grad_y, grad_hy, grad_cy, z_state, cell_state_fwd, input, layersOutputs, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("lstm_mps_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_lstm_mps_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void lstm_mps_backward_out(at::Tensor & out0, at::TensorList out1, at::TensorList out2, const ::std::optional<at::Tensor> & grad_y, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & z_state, const at::Tensor & cell_state_fwd, const at::Tensor & input, const at::Tensor & layersOutputs, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
return wrapper_CompositeExplicitAutograd_out_lstm_mps_backward_out(grad_y, grad_hy, grad_cy, z_state, cell_state_fwd, input, layersOutputs, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2);
}
void lstm_mps_backward_outf(const ::std::optional<at::Tensor> & grad_y, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & z_state, const at::Tensor & cell_state_fwd, const at::Tensor & input, const at::Tensor & layersOutputs, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, at::Tensor & out0, at::TensorList out1, at::TensorList out2) {
return wrapper_CompositeExplicitAutograd_out_lstm_mps_backward_out(grad_y, grad_hy, grad_cy, z_state, cell_state_fwd, input, layersOutputs, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_out(const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & cx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_thnn_fused_lstm_cell_out(input_gates, hidden_gates, cx, input_bias, hidden_bias, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_thnn_fused_lstm_cell.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_lstm_cell_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & cx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_out(input_gates, hidden_gates, cx, input_bias, hidden_bias, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_lstm_cell_outf(const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & cx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_out(input_gates, hidden_gates, cx, input_bias, hidden_bias, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_backward_impl_out(const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & cx, const at::Tensor & cy, const at::Tensor & workspace, bool has_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_thnn_fused_lstm_cell_backward_impl_out(grad_hy, grad_cy, cx, cy, workspace, has_bias, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_thnn_fused_lstm_cell_backward_impl.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_backward_impl_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_lstm_cell_backward_impl_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & cx, const at::Tensor & cy, const at::Tensor & workspace, bool has_bias) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_backward_impl_out(grad_hy, grad_cy, cx, cy, workspace, has_bias, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_lstm_cell_backward_impl_outf(const ::std::optional<at::Tensor> & grad_hy, const ::std::optional<at::Tensor> & grad_cy, const at::Tensor & cx, const at::Tensor & cy, const at::Tensor & workspace, bool has_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_lstm_cell_backward_impl_out(grad_hy, grad_cy, cx, cy, workspace, has_bias, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_out(const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & hx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_thnn_fused_gru_cell_out(input_gates, hidden_gates, hx, input_bias, hidden_bias, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_thnn_fused_gru_cell.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _thnn_fused_gru_cell_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & hx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_out(input_gates, hidden_gates, hx, input_bias, hidden_bias, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _thnn_fused_gru_cell_outf(const at::Tensor & input_gates, const at::Tensor & hidden_gates, const at::Tensor & hx, const ::std::optional<at::Tensor> & input_bias, const ::std::optional<at::Tensor> & hidden_bias, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_out(input_gates, hidden_gates, hx, input_bias, hidden_bias, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_backward_out(const at::Tensor & grad_hy, const at::Tensor & workspace, bool has_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
    // No device check
  // DeviceGuard omitted
  return at::native::_thnn_fused_gru_cell_backward_out(grad_hy, workspace, has_bias, out0, out1, out2, out3, out4);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_thnn_fused_gru_cell_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_gru_cell_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4, const at::Tensor & grad_hy, const at::Tensor & workspace, bool has_bias) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_backward_out(grad_hy, workspace, has_bias, out0, out1, out2, out3, out4);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &,at::Tensor &> _thnn_fused_gru_cell_backward_outf(const at::Tensor & grad_hy, const at::Tensor & workspace, bool has_bias, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4) {
return wrapper_CompositeExplicitAutograd_out__thnn_fused_gru_cell_backward_out(grad_hy, workspace, has_bias, out0, out1, out2, out3, out4);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___pack_padded_sequence(const at::Tensor & input, const at::Tensor & lengths, bool batch_first) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pack_padded_sequence(input, lengths, batch_first);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__pack_padded_sequence_out(const at::Tensor & input, const at::Tensor & lengths, bool batch_first, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_pack_padded_sequence_out(input, lengths, batch_first, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_pack_padded_sequence",
TORCH_FN(wrapper_CompositeExplicitAutograd___pack_padded_sequence));
m.impl("_pack_padded_sequence.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__pack_padded_sequence_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> _pack_padded_sequence(const at::Tensor & input, const at::Tensor & lengths, bool batch_first) {
return wrapper_CompositeExplicitAutograd___pack_padded_sequence(input, lengths, batch_first);
}
::std::tuple<at::Tensor &,at::Tensor &> _pack_padded_sequence_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & input, const at::Tensor & lengths, bool batch_first) {
return wrapper_CompositeExplicitAutograd_out__pack_padded_sequence_out(input, lengths, batch_first, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _pack_padded_sequence_outf(const at::Tensor & input, const at::Tensor & lengths, bool batch_first, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__pack_padded_sequence_out(input, lengths, batch_first, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_source_Storage_set(const at::Tensor & self, at::Storage source) {
    // No device check
  // DeviceGuard omitted
  return at::native::set(self, source);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_source_Storage_out_set_out(const at::Tensor & self, at::Storage source, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::set_source_Storage_out(self, source, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("set.source_Storage",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Storage_set));
m.impl("set.source_Storage_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Storage_out_set_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor set(const at::Tensor & self, at::Storage source) {
return wrapper_CompositeExplicitAutograd_source_Storage_set(self, source);
}
at::Tensor & set_out(at::Tensor & out, const at::Tensor & self, at::Storage source) {
return wrapper_CompositeExplicitAutograd_source_Storage_out_set_out(self, source, out);
}
at::Tensor & set_outf(const at::Tensor & self, at::Storage source, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_source_Storage_out_set_out(self, source, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_set(const at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
    // No device check
  // DeviceGuard omitted
  return at::native::set_symint(self, source, storage_offset, size, stride);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out(const at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::set_source_Storage_storage_offset_out_symint(self, source, storage_offset, size, stride, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("set.source_Storage_storage_offset",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_set));
m.impl("set.source_Storage_storage_offset_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor set(const at::Tensor & self, at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_set(self, source, storage_offset, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride));
}
at::Tensor set_symint(const at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_set(self, source, storage_offset, size, stride);
}
at::Tensor & set_out(at::Tensor & out, const at::Tensor & self, at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out(self, source, storage_offset, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & set_outf(const at::Tensor & self, at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out(self, source, storage_offset, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & set_symint_out(at::Tensor & out, const at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out(self, source, storage_offset, size, stride, out);
}
at::Tensor & set_symint_outf(const at::Tensor & self, at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_source_Storage_storage_offset_out_set_out(self, source, storage_offset, size, stride, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_source_Tensor_set(const at::Tensor & self, const at::Tensor & source) {
    // No device check
  // DeviceGuard omitted
  return at::native::set(self, source);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_source_Tensor_out_set_out(const at::Tensor & self, const at::Tensor & source, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::set_source_Tensor_out(self, source, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("set.source_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Tensor_set));
m.impl("set.source_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_source_Tensor_out_set_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor set(const at::Tensor & self, const at::Tensor & source) {
return wrapper_CompositeExplicitAutograd_source_Tensor_set(self, source);
}
at::Tensor & set_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & source) {
return wrapper_CompositeExplicitAutograd_source_Tensor_out_set_out(self, source, out);
}
at::Tensor & set_outf(const at::Tensor & self, const at::Tensor & source, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_source_Tensor_out_set_out(self, source, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__set(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::set(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_set_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::set_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("set",
TORCH_FN(wrapper_CompositeExplicitAutograd__set));
m.impl("set.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_set_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor set(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__set(self);
}
at::Tensor & set_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_set_out(self, out);
}
at::Tensor & set_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_set_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__lift(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::lift(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_lift_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::lift_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("lift",
TORCH_FN(wrapper_CompositeExplicitAutograd__lift));
m.impl("lift.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_lift_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor lift(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__lift(self);
}
at::Tensor & lift_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_lift_out(self, out);
}
at::Tensor & lift_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_lift_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__lift_fresh(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::lift_fresh(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("lift_fresh",
TORCH_FN(wrapper_CompositeExplicitAutograd__lift_fresh));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor lift_fresh(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__lift_fresh(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_lift_fresh_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::lift_fresh_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("lift_fresh_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_lift_fresh_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & lift_fresh_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_lift_fresh_copy_out(self, out);
}
at::Tensor & lift_fresh_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_lift_fresh_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_masked_fill(const at::Tensor & self, const at::Tensor & mask, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_fill(self, mask, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_masked_fill_out(const at::Tensor & self, const at::Tensor & mask, const at::Scalar & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_fill_Scalar_out(self, mask, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("masked_fill.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_masked_fill));
m.impl("masked_fill.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_masked_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor masked_fill(const at::Tensor & self, const at::Tensor & mask, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_masked_fill(self, mask, value);
}
at::Tensor & masked_fill_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_out_masked_fill_out(self, mask, value, out);
}
at::Tensor & masked_fill_outf(const at::Tensor & self, const at::Tensor & mask, const at::Scalar & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_masked_fill_out(self, mask, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_masked_fill(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_fill(self, mask, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_masked_fill_out(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_fill_Tensor_out(self, mask, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("masked_fill.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_masked_fill));
m.impl("masked_fill.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_masked_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor masked_fill(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_Tensor_masked_fill(self, mask, value);
}
at::Tensor & masked_fill_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_Tensor_out_masked_fill_out(self, mask, value, out);
}
at::Tensor & masked_fill_outf(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_masked_fill_out(self, mask, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__masked_scatter(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_scatter(self, mask, source);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_masked_scatter_out(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_scatter_out(self, mask, source, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("masked_scatter",
TORCH_FN(wrapper_CompositeExplicitAutograd__masked_scatter));
m.impl("masked_scatter.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_masked_scatter_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor masked_scatter(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) {
return wrapper_CompositeExplicitAutograd__masked_scatter(self, mask, source);
}
at::Tensor & masked_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source) {
return wrapper_CompositeExplicitAutograd_out_masked_scatter_out(self, mask, source, out);
}
at::Tensor & masked_scatter_outf(const at::Tensor & self, const at::Tensor & mask, const at::Tensor & source, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_masked_scatter_out(self, mask, source, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__masked_scatter_backward(const at::Tensor & grad_output, const at::Tensor & mask, c10::SymIntArrayRef sizes) {
    // No device check
  // DeviceGuard omitted
  return at::native::masked_scatter_backward_symint(grad_output, mask, sizes);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("masked_scatter_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__masked_scatter_backward));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor masked_scatter_backward(const at::Tensor & grad_output, const at::Tensor & mask, at::IntArrayRef sizes) {
return wrapper_CompositeExplicitAutograd__masked_scatter_backward(grad_output, mask, c10::fromIntArrayRefSlow(sizes));
}
at::Tensor masked_scatter_backward_symint(const at::Tensor & grad_output, const at::Tensor & mask, c10::SymIntArrayRef sizes) {
return wrapper_CompositeExplicitAutograd__masked_scatter_backward(grad_output, mask, sizes);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__masked_softmax_out(const at::Tensor & self, const at::Tensor & mask, ::std::optional<int64_t> dim, ::std::optional<int64_t> mask_type, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_masked_softmax_out(self, mask, dim, mask_type, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_masked_softmax.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__masked_softmax_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _masked_softmax_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & mask, ::std::optional<int64_t> dim, ::std::optional<int64_t> mask_type) {
return wrapper_CompositeExplicitAutograd_out__masked_softmax_out(self, mask, dim, mask_type, out);
}
at::Tensor & _masked_softmax_outf(const at::Tensor & self, const at::Tensor & mask, ::std::optional<int64_t> dim, ::std::optional<int64_t> mask_type, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__masked_softmax_out(self, mask, dim, mask_type, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__masked_softmax_backward_out(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, ::std::optional<int64_t> dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_masked_softmax_backward_out(grad_output, output, mask, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_masked_softmax_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__masked_softmax_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _masked_softmax_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, ::std::optional<int64_t> dim) {
return wrapper_CompositeExplicitAutograd_out__masked_softmax_backward_out(grad_output, output, mask, dim, out);
}
at::Tensor & _masked_softmax_backward_outf(const at::Tensor & grad_output, const at::Tensor & output, const at::Tensor & mask, ::std::optional<int64_t> dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__masked_softmax_backward_out(grad_output, output, mask, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_dtype_view(const at::Tensor & self, at::ScalarType dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::view_dtype(self, dtype);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("view.dtype",
TORCH_FN(wrapper_CompositeExplicitAutograd_dtype_view));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor view(const at::Tensor & self, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_dtype_view(self, dtype);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__put(const at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate) {
    // No device check
  // DeviceGuard omitted
  return at::native::put(self, index, source, accumulate);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_put_out(const at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::put_out(self, index, source, accumulate, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("put",
TORCH_FN(wrapper_CompositeExplicitAutograd__put));
m.impl("put.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_put_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor put(const at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate) {
return wrapper_CompositeExplicitAutograd__put(self, index, source, accumulate);
}
at::Tensor & put_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate) {
return wrapper_CompositeExplicitAutograd_out_put_out(self, index, source, accumulate, out);
}
at::Tensor & put_outf(const at::Tensor & self, const at::Tensor & index, const at::Tensor & source, bool accumulate, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_put_out(self, index, source, accumulate, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_int_Scalar_index_fill(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_fill(self, dim, index, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_Scalar_out_index_fill_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_fill_int_Scalar_out(self, dim, index, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("index_fill.int_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_Scalar_index_fill));
m.impl("index_fill.int_Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_Scalar_out_index_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor index_fill(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_int_Scalar_index_fill(self, dim, index, value);
}
at::Tensor & index_fill_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_int_Scalar_out_index_fill_out(self, dim, index, value, out);
}
at::Tensor & index_fill_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Scalar & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_Scalar_out_index_fill_out(self, dim, index, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_int_Tensor_index_fill(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_fill(self, dim, index, value);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_Tensor_out_index_fill_out(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::index_fill_int_Tensor_out(self, dim, index, value, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("index_fill.int_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_Tensor_index_fill));
m.impl("index_fill.int_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_Tensor_out_index_fill_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor index_fill(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_int_Tensor_index_fill(self, dim, index, value);
}
at::Tensor & index_fill_out(at::Tensor & out, const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value) {
return wrapper_CompositeExplicitAutograd_int_Tensor_out_index_fill_out(self, dim, index, value, out);
}
at::Tensor & index_fill_outf(const at::Tensor & self, int64_t dim, const at::Tensor & index, const at::Tensor & value, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_Tensor_out_index_fill_out(self, dim, index, value, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_bitwise_and(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_and(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_and_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_and_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_bitwise_and_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_and_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_and.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_and));
m.impl("bitwise_and.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_and_out));
m.impl("bitwise_and_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_and_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_and(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_and(self, other);
}
at::Tensor & bitwise_and_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_and_out(self, other, out);
}
at::Tensor & bitwise_and_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_and_out(self, other, out);
}
at::Tensor & bitwise_and_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_and_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_and(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_and(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_and_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_and_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_and.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_and));
m.impl("bitwise_and.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_and_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_and(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_and(self, other);
}
at::Tensor & bitwise_and_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_and_out(self, other, out);
}
at::Tensor & bitwise_and_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_and_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_bitwise_or(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_or(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_or_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_or_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_bitwise_or_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_or_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_or.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_or));
m.impl("bitwise_or.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_or_out));
m.impl("bitwise_or_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_or_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_or(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_or(self, other);
}
at::Tensor & bitwise_or_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_or_out(self, other, out);
}
at::Tensor & bitwise_or_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_or_out(self, other, out);
}
at::Tensor & bitwise_or_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_or_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_or(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_or(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_or_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_or_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_or.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_or));
m.impl("bitwise_or.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_or_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_or(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_or(self, other);
}
at::Tensor & bitwise_or_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_or_out(self, other, out);
}
at::Tensor & bitwise_or_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_or_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_xor(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_xor_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_xor_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_xor_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_xor.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor));
m.impl("bitwise_xor.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_xor_out));
m.impl("bitwise_xor_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_xor(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor(self, other);
}
at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_xor_out(self, other, out);
}
at::Tensor & bitwise_xor_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bitwise_xor_out(self, other, out);
}
at::Tensor & bitwise_xor_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_bitwise_xor_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_xor(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_xor(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_xor_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_xor_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_xor.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_xor));
m.impl("bitwise_xor.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_xor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_xor(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_xor(self, other);
}
at::Tensor & bitwise_xor_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_xor_out(self, other, out);
}
at::Tensor & bitwise_xor_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_xor_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out___lshift___out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::__lshift___Scalar_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("__lshift__.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out___lshift___out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & __lshift___out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out___lshift___out(self, other, out);
}
at::Tensor & __lshift___outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out___lshift___out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out___lshift___out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::__lshift___Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("__lshift__.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out___lshift___out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & __lshift___out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor_out___lshift___out(self, other, out);
}
at::Tensor & __lshift___outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out___lshift___out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_left_shift(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_left_shift_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_left_shift_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_left_shift_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_left_shift.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift));
m.impl("bitwise_left_shift.Tensor_Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_left_shift_out));
m.impl("bitwise_left_shift_.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_left_shift(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift(self, other);
}
at::Tensor & bitwise_left_shift_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_left_shift_out(self, other, out);
}
at::Tensor & bitwise_left_shift_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_left_shift_out(self, other, out);
}
at::Tensor & bitwise_left_shift_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_left_shift_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_left_shift(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_left_shift(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_left_shift_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_left_shift_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_left_shift.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_left_shift));
m.impl("bitwise_left_shift.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_left_shift_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_left_shift(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_left_shift(self, other);
}
at::Tensor & bitwise_left_shift_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_left_shift_out(self, other, out);
}
at::Tensor & bitwise_left_shift_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_left_shift_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out___rshift___out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::__rshift___Scalar_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("__rshift__.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out___rshift___out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & __rshift___out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out___rshift___out(self, other, out);
}
at::Tensor & __rshift___outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out___rshift___out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out___rshift___out(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::__rshift___Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("__rshift__.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out___rshift___out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & __rshift___out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor_out___rshift___out(self, other, out);
}
at::Tensor & __rshift___outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out___rshift___out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_right_shift(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_right_shift_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_right_shift_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_right_shift_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_right_shift.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift));
m.impl("bitwise_right_shift.Tensor_Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_right_shift_out));
m.impl("bitwise_right_shift_.Tensor_Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_right_shift(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift(self, other);
}
at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_right_shift_out(self, other, out);
}
at::Tensor & bitwise_right_shift_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_out_bitwise_right_shift_out(self, other, out);
}
at::Tensor & bitwise_right_shift_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Tensor_Scalar_bitwise_right_shift_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_right_shift(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_right_shift(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_right_shift_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bitwise_right_shift_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bitwise_right_shift.Scalar_Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_right_shift));
m.impl("bitwise_right_shift.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_right_shift_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor bitwise_right_shift(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_bitwise_right_shift(self, other);
}
at::Tensor & bitwise_right_shift_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_right_shift_out(self, other, out);
}
at::Tensor & bitwise_right_shift_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_bitwise_right_shift_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_from_random(const at::Tensor & self, int64_t from, ::std::optional<int64_t> to, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::random(self, from, to, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_from_out_random_out(const at::Tensor & self, int64_t from, ::std::optional<int64_t> to, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::random_from_out(self, from, to, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("random.from",
TORCH_FN(wrapper_CompositeExplicitAutograd_from_random));
m.impl("random.from_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_from_out_random_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor random(const at::Tensor & self, int64_t from, ::std::optional<int64_t> to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_from_random(self, from, to, generator);
}
at::Tensor & random_out(at::Tensor & out, const at::Tensor & self, int64_t from, ::std::optional<int64_t> to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_from_out_random_out(self, from, to, generator, out);
}
at::Tensor & random_outf(const at::Tensor & self, int64_t from, ::std::optional<int64_t> to, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_from_out_random_out(self, from, to, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_to_random(const at::Tensor & self, int64_t to, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::random(self, to, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_to_out_random_out(const at::Tensor & self, int64_t to, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::random_to_out(self, to, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("random.to",
TORCH_FN(wrapper_CompositeExplicitAutograd_to_random));
m.impl("random.to_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_to_out_random_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor random(const at::Tensor & self, int64_t to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_to_random(self, to, generator);
}
at::Tensor & random_out(at::Tensor & out, const at::Tensor & self, int64_t to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_to_out_random_out(self, to, generator, out);
}
at::Tensor & random_outf(const at::Tensor & self, int64_t to, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_to_out_random_out(self, to, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__random(const at::Tensor & self, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::random(self, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_random_out(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::random_out(self, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("random",
TORCH_FN(wrapper_CompositeExplicitAutograd__random));
m.impl("random.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_random_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor random(const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__random(self, generator);
}
at::Tensor & random_out(at::Tensor & out, const at::Tensor & self, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_random_out(self, generator, out);
}
at::Tensor & random_outf(const at::Tensor & self, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_random_out(self, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__uniform(const at::Tensor & self, double from, double to, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::uniform(self, from, to, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_uniform_out(const at::Tensor & self, double from, double to, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::uniform_out(self, from, to, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("uniform",
TORCH_FN(wrapper_CompositeExplicitAutograd__uniform));
m.impl("uniform.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_uniform_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor uniform(const at::Tensor & self, double from, double to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__uniform(self, from, to, generator);
}
at::Tensor & uniform_out(at::Tensor & out, const at::Tensor & self, double from, double to, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_uniform_out(self, from, to, generator, out);
}
at::Tensor & uniform_outf(const at::Tensor & self, double from, double to, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_uniform_out(self, from, to, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__cauchy(const at::Tensor & self, double median, double sigma, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::cauchy(self, median, sigma, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cauchy_out(const at::Tensor & self, double median, double sigma, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cauchy_out(self, median, sigma, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cauchy",
TORCH_FN(wrapper_CompositeExplicitAutograd__cauchy));
m.impl("cauchy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cauchy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor cauchy(const at::Tensor & self, double median, double sigma, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__cauchy(self, median, sigma, generator);
}
at::Tensor & cauchy_out(at::Tensor & out, const at::Tensor & self, double median, double sigma, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_cauchy_out(self, median, sigma, generator, out);
}
at::Tensor & cauchy_outf(const at::Tensor & self, double median, double sigma, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cauchy_out(self, median, sigma, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__log_normal(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::log_normal(self, mean, std, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_log_normal_out(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::log_normal_out(self, mean, std, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("log_normal",
TORCH_FN(wrapper_CompositeExplicitAutograd__log_normal));
m.impl("log_normal.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_log_normal_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor log_normal(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__log_normal(self, mean, std, generator);
}
at::Tensor & log_normal_out(at::Tensor & out, const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_log_normal_out(self, mean, std, generator, out);
}
at::Tensor & log_normal_outf(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_log_normal_out(self, mean, std, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__exponential(const at::Tensor & self, double lambd, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::exponential(self, lambd, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_exponential_out(const at::Tensor & self, double lambd, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::exponential_out(self, lambd, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("exponential",
TORCH_FN(wrapper_CompositeExplicitAutograd__exponential));
m.impl("exponential.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_exponential_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor exponential(const at::Tensor & self, double lambd, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__exponential(self, lambd, generator);
}
at::Tensor & exponential_out(at::Tensor & out, const at::Tensor & self, double lambd, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_exponential_out(self, lambd, generator, out);
}
at::Tensor & exponential_outf(const at::Tensor & self, double lambd, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_exponential_out(self, lambd, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__geometric(const at::Tensor & self, double p, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::geometric(self, p, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_geometric_out(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::geometric_out(self, p, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("geometric",
TORCH_FN(wrapper_CompositeExplicitAutograd__geometric));
m.impl("geometric.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_geometric_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor geometric(const at::Tensor & self, double p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__geometric(self, p, generator);
}
at::Tensor & geometric_out(at::Tensor & out, const at::Tensor & self, double p, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_geometric_out(self, p, generator, out);
}
at::Tensor & geometric_outf(const at::Tensor & self, double p, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_geometric_out(self, p, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_tril_indices_out(int64_t row, int64_t col, int64_t offset, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::tril_indices_out(row, col, offset, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("tril_indices.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_tril_indices_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & tril_indices_out(at::Tensor & out, int64_t row, int64_t col, int64_t offset) {
return wrapper_CompositeExplicitAutograd_out_tril_indices_out(row, col, offset, out);
}
at::Tensor & tril_indices_outf(int64_t row, int64_t col, int64_t offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_tril_indices_out(row, col, offset, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_triu_indices_out(int64_t row, int64_t col, int64_t offset, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::triu_indices_out(row, col, offset, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("triu_indices.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_triu_indices_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & triu_indices_out(at::Tensor & out, int64_t row, int64_t col, int64_t offset) {
return wrapper_CompositeExplicitAutograd_out_triu_indices_out(row, col, offset, out);
}
at::Tensor & triu_indices_outf(int64_t row, int64_t col, int64_t offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_triu_indices_out(row, col, offset, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_trace_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::trace_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("trace.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_trace_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & trace_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_trace_out(self, out);
}
at::Tensor & trace_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_trace_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd___linalg_check_errors(const at::Tensor & info, c10::string_view api_name, bool is_matrix) {
    // No device check
  // DeviceGuard omitted
  return at::native::_linalg_check_errors(info, api_name, is_matrix);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_linalg_check_errors",
TORCH_FN(wrapper_CompositeExplicitAutograd___linalg_check_errors));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _linalg_check_errors(const at::Tensor & info, c10::string_view api_name, bool is_matrix) {
return wrapper_CompositeExplicitAutograd___linalg_check_errors(info, api_name, is_matrix);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__cholesky_solve(const at::Tensor & self, const at::Tensor & input2, bool upper) {
    // No device check
  // DeviceGuard omitted
  return at::native::cholesky_solve(self, input2, upper);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_cholesky_solve_out(const at::Tensor & self, const at::Tensor & input2, bool upper, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::cholesky_solve_out(self, input2, upper, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("cholesky_solve",
TORCH_FN(wrapper_CompositeExplicitAutograd__cholesky_solve));
m.impl("cholesky_solve.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_cholesky_solve_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor cholesky_solve(const at::Tensor & self, const at::Tensor & input2, bool upper) {
return wrapper_CompositeExplicitAutograd__cholesky_solve(self, input2, upper);
}
at::Tensor & cholesky_solve_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & input2, bool upper) {
return wrapper_CompositeExplicitAutograd_out_cholesky_solve_out(self, input2, upper, out);
}
at::Tensor & cholesky_solve_outf(const at::Tensor & self, const at::Tensor & input2, bool upper, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_cholesky_solve_out(self, input2, upper, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__cholesky_solve_helper_out(const at::Tensor & self, const at::Tensor & A, bool upper, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_cholesky_solve_helper_out(self, A, upper, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_cholesky_solve_helper.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__cholesky_solve_helper_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _cholesky_solve_helper_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & A, bool upper) {
return wrapper_CompositeExplicitAutograd_out__cholesky_solve_helper_out(self, A, upper, out);
}
at::Tensor & _cholesky_solve_helper_outf(const at::Tensor & self, const at::Tensor & A, bool upper, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__cholesky_solve_helper_out(self, A, upper, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd__polygamma_(at::Tensor & self, int64_t n) {
    // No device check
  // DeviceGuard omitted
  return at::native::polygamma_(self, n);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("polygamma_",
TORCH_FN(wrapper_CompositeExplicitAutograd__polygamma_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & polygamma_(at::Tensor & self, int64_t n) {
return wrapper_CompositeExplicitAutograd__polygamma_(self, n);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__dist(const at::Tensor & self, const at::Tensor & other, const at::Scalar & p) {
    // No device check
  // DeviceGuard omitted
  return at::native::dist(self, other, p);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_dist_out(const at::Tensor & self, const at::Tensor & other, const at::Scalar & p, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::dist_out(self, other, p, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("dist",
TORCH_FN(wrapper_CompositeExplicitAutograd__dist));
m.impl("dist.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_dist_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor dist(const at::Tensor & self, const at::Tensor & other, const at::Scalar & p) {
return wrapper_CompositeExplicitAutograd__dist(self, other, p);
}
at::Tensor & dist_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other, const at::Scalar & p) {
return wrapper_CompositeExplicitAutograd_out_dist_out(self, other, p, out);
}
at::Tensor & dist_outf(const at::Tensor & self, const at::Tensor & other, const at::Scalar & p, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_dist_out(self, other, p, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_out__histogramdd_bin_edges_out(const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_histogramdd_bin_edges_out(self, bins, range, weight, density, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_histogramdd_bin_edges.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__histogramdd_bin_edges_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void _histogramdd_bin_edges_out(at::TensorList out, const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_bin_edges_out(self, bins, range, weight, density, out);
}
void _histogramdd_bin_edges_outf(const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_bin_edges_out(self, bins, range, weight, density, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_cts_out(const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_histogramdd_from_bin_cts_out(self, bins, range, weight, density, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_histogramdd_from_bin_cts.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_cts_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _histogramdd_from_bin_cts_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_cts_out(self, bins, range, weight, density, out);
}
at::Tensor & _histogramdd_from_bin_cts_outf(const at::Tensor & self, at::IntArrayRef bins, ::std::optional<at::ArrayRef<double>> range, const ::std::optional<at::Tensor> & weight, bool density, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_cts_out(self, bins, range, weight, density, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_tensors_out(const at::Tensor & self, at::TensorList bins, const ::std::optional<at::Tensor> & weight, bool density, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_histogramdd_from_bin_tensors_out(self, bins, weight, density, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_histogramdd_from_bin_tensors.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_tensors_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _histogramdd_from_bin_tensors_out(at::Tensor & out, const at::Tensor & self, at::TensorList bins, const ::std::optional<at::Tensor> & weight, bool density) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_tensors_out(self, bins, weight, density, out);
}
at::Tensor & _histogramdd_from_bin_tensors_outf(const at::Tensor & self, at::TensorList bins, const ::std::optional<at::Tensor> & weight, bool density, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__histogramdd_from_bin_tensors_out(self, bins, weight, density, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_fmod(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::fmod(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_fmod_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::fmod_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_fmod_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::fmod_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fmod.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_fmod));
m.impl("fmod.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_fmod_out));
m.impl("fmod_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_fmod_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor fmod(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_fmod(self, other);
}
at::Tensor & fmod_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_fmod_out(self, other, out);
}
at::Tensor & fmod_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_fmod_out(self, other, out);
}
at::Tensor & fmod_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_fmod_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_Scalar_remainder(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::remainder(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_remainder_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::remainder_out(self, other, out);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_remainder_(at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::remainder_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("remainder.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_remainder));
m.impl("remainder.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_remainder_out));
m.impl("remainder_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_remainder_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor remainder(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_remainder(self, other);
}
at::Tensor & remainder_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_out_remainder_out(self, other, out);
}
at::Tensor & remainder_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_remainder_out(self, other, out);
}
at::Tensor & remainder_(at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_Scalar_remainder_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_remainder_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::remainder_Scalar_Tensor_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("remainder.Scalar_Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_remainder_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & remainder_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_remainder_out(self, other, out);
}
at::Tensor & remainder_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_Tensor_out_remainder_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__sort(const at::Tensor & self, int64_t dim, bool descending) {
    // No device check
  // DeviceGuard omitted
  return at::native::sort(self, dim, descending);
}
} // anonymous namespace
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_values_sort_out(const at::Tensor & self, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) {
    // No device check
  // DeviceGuard omitted
  return at::native::sort_out(self, dim, descending, values, indices);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("sort",
TORCH_FN(wrapper_CompositeExplicitAutograd__sort));
m.impl("sort.values",
TORCH_FN(wrapper_CompositeExplicitAutograd_values_sort_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> sort(const at::Tensor & self, int64_t dim, bool descending) {
return wrapper_CompositeExplicitAutograd__sort(self, dim, descending);
}
::std::tuple<at::Tensor &,at::Tensor &> sort_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim, bool descending) {
return wrapper_CompositeExplicitAutograd_values_sort_out(self, dim, descending, values, indices);
}
::std::tuple<at::Tensor &,at::Tensor &> sort_outf(const at::Tensor & self, int64_t dim, bool descending, at::Tensor & values, at::Tensor & indices) {
return wrapper_CompositeExplicitAutograd_values_sort_out(self, dim, descending, values, indices);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_unfold_backward_out(const at::Tensor & grad_in, c10::SymIntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unfold_backward_out_symint(grad_in, input_sizes, dim, size, step, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unfold_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unfold_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & unfold_backward_out(at::Tensor & out, const at::Tensor & grad_in, at::IntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step) {
return wrapper_CompositeExplicitAutograd_out_unfold_backward_out(grad_in, c10::fromIntArrayRefSlow(input_sizes), dim, size, step, out);
}
at::Tensor & unfold_backward_outf(const at::Tensor & grad_in, at::IntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_unfold_backward_out(grad_in, c10::fromIntArrayRefSlow(input_sizes), dim, size, step, out);
}
at::Tensor & unfold_backward_symint_out(at::Tensor & out, const at::Tensor & grad_in, c10::SymIntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step) {
return wrapper_CompositeExplicitAutograd_out_unfold_backward_out(grad_in, input_sizes, dim, size, step, out);
}
at::Tensor & unfold_backward_symint_outf(const at::Tensor & grad_in, c10::SymIntArrayRef input_sizes, int64_t dim, int64_t size, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_unfold_backward_out(grad_in, input_sizes, dim, size, step, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__normal_functional(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::normal_functional(self, mean, std, generator);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_normal_out(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::normal_out(self, mean, std, generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("normal_functional",
TORCH_FN(wrapper_CompositeExplicitAutograd__normal_functional));
m.impl("normal.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_normal_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor normal_functional(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__normal_functional(self, mean, std, generator);
}
at::Tensor & normal_out(at::Tensor & out, const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_out_normal_out(self, mean, std, generator, out);
}
at::Tensor & normal_outf(const at::Tensor & self, double mean, double std, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_normal_out(self, mean, std, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_float_float_normal(double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::normal(mean, std, C10_AS_INTARRAYREF_SLOW(size), generator, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_float_float_out_normal_out(double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::normal_out(mean, std, C10_AS_INTARRAYREF_SLOW(size), generator, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("normal.float_float",
TORCH_FN(wrapper_CompositeExplicitAutograd_float_float_normal));
m.impl("normal.float_float_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_float_float_out_normal_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor normal(double mean, double std, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_float_float_normal(mean, std, c10::fromIntArrayRefSlow(size), generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor normal(double mean, double std, at::IntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_float_float_normal(mean, std, c10::fromIntArrayRefSlow(size), generator, dtype, layout, device, pin_memory);
}
at::Tensor normal_symint(double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd_float_float_normal(mean, std, size, generator, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor normal_symint(double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_float_float_normal(mean, std, size, generator, dtype, layout, device, pin_memory);
}
at::Tensor & normal_out(at::Tensor & out, double mean, double std, at::IntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_float_float_out_normal_out(mean, std, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & normal_outf(double mean, double std, at::IntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_float_float_out_normal_out(mean, std, c10::fromIntArrayRefSlow(size), generator, out);
}
at::Tensor & normal_symint_out(at::Tensor & out, double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd_float_float_out_normal_out(mean, std, size, generator, out);
}
at::Tensor & normal_symint_outf(double mean, double std, c10::SymIntArrayRef size, ::std::optional<at::Generator> generator, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_float_float_out_normal_out(mean, std, size, generator, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__alias(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::alias(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("alias",
TORCH_FN(wrapper_CompositeExplicitAutograd__alias));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor alias(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__alias(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,at::Tensor> wrapper_CompositeExplicitAutograd___amp_foreach_non_finite_check_and_unscale(at::TensorList self, const at::Tensor & found_inf, const at::Tensor & inv_scale) {
    // No device check
  // DeviceGuard omitted
  return at::native::_amp_foreach_non_finite_check_and_unscale(self, found_inf, inv_scale);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__amp_foreach_non_finite_check_and_unscale_out(at::TensorList self, at::Tensor & found_inf, const at::Tensor & inv_scale, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_amp_foreach_non_finite_check_and_unscale_out(self, found_inf, inv_scale, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_amp_foreach_non_finite_check_and_unscale",
TORCH_FN(wrapper_CompositeExplicitAutograd___amp_foreach_non_finite_check_and_unscale));
m.impl("_amp_foreach_non_finite_check_and_unscale.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__amp_foreach_non_finite_check_and_unscale_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,at::Tensor> _amp_foreach_non_finite_check_and_unscale(at::TensorList self, const at::Tensor & found_inf, const at::Tensor & inv_scale) {
return wrapper_CompositeExplicitAutograd___amp_foreach_non_finite_check_and_unscale(self, found_inf, inv_scale);
}
void _amp_foreach_non_finite_check_and_unscale_out(at::TensorList out, at::TensorList self, at::Tensor & found_inf, const at::Tensor & inv_scale) {
return wrapper_CompositeExplicitAutograd_out__amp_foreach_non_finite_check_and_unscale_out(self, found_inf, inv_scale, out);
}
void _amp_foreach_non_finite_check_and_unscale_outf(at::TensorList self, at::Tensor & found_inf, const at::Tensor & inv_scale, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__amp_foreach_non_finite_check_and_unscale_out(self, found_inf, inv_scale, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___amp_update_scale(const at::Tensor & self, const at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) {
    // No device check
  // DeviceGuard omitted
  return at::native::_amp_update_scale(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__amp_update_scale_out(const at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_amp_update_scale_out(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_amp_update_scale",
TORCH_FN(wrapper_CompositeExplicitAutograd___amp_update_scale));
m.impl("_amp_update_scale.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__amp_update_scale_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> _amp_update_scale(const at::Tensor & self, const at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) {
return wrapper_CompositeExplicitAutograd___amp_update_scale(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval);
}
at::Tensor & _amp_update_scale_out(at::Tensor & out, const at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval) {
return wrapper_CompositeExplicitAutograd_out__amp_update_scale_out(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval, out);
}
at::Tensor & _amp_update_scale_outf(const at::Tensor & self, at::Tensor & growth_tracker, const at::Tensor & found_inf, double scale_growth_factor, double scale_backoff_factor, int64_t growth_interval, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__amp_update_scale_out(self, growth_tracker, found_inf, scale_growth_factor, scale_backoff_factor, growth_interval, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_add(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_add_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_add_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_add_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_add.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_add));
m.impl("_foreach_add.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_add_out));
m.impl("_foreach_add_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_add_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_add(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_add(self, scalar);
}
void _foreach_add_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_add_out(self, scalar, out);
}
void _foreach_add_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_add_out(self, scalar, out);
}
void _foreach_add_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_add_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_add(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_list_kernel_slow(self, other, alpha);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_add_out(at::TensorList self, at::TensorList other, const at::Scalar & alpha, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_add_List_out(self, other, alpha, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_add_(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_list_kernel_slow_(self, other, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_add.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_add));
m.impl("_foreach_add.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_add_out));
m.impl("_foreach_add_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_add_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_add(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List__foreach_add(self, other, alpha);
}
void _foreach_add_out(at::TensorList out, at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_add_out(self, other, alpha, out);
}
void _foreach_add_outf(at::TensorList self, at::TensorList other, const at::Scalar & alpha, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_add_out(self, other, alpha, out);
}
void _foreach_add_(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List__foreach_add_(self, other, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_add(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_add_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_add_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_add_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_add.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_add));
m.impl("_foreach_add.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_add_out));
m.impl("_foreach_add_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_add_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_add(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_add(self, scalars);
}
void _foreach_add_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_add_out(self, scalars, out);
}
void _foreach_add_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_add_out(self, scalars, out);
}
void _foreach_add_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_add_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor__foreach_add(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_tensor_kernel_slow(self, other, alpha);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out__foreach_add_out(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_add_Tensor_out(self, other, alpha, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor__foreach_add_(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_add_tensor_kernel_slow_(self, other, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_add.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_add));
m.impl("_foreach_add.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__foreach_add_out));
m.impl("_foreach_add_.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_add_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_add(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_add(self, other, alpha);
}
void _foreach_add_out(at::TensorList out, at::TensorList self, const at::Tensor & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_add_out(self, other, alpha, out);
}
void _foreach_add_outf(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_add_out(self, other, alpha, out);
}
void _foreach_add_(at::TensorList self, const at::Tensor & other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_add_(self, other, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_sub(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_sub_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sub_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_sub_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sub.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_sub));
m.impl("_foreach_sub.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_sub_out));
m.impl("_foreach_sub_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_sub_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sub(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_sub(self, scalar);
}
void _foreach_sub_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_sub_out(self, scalar, out);
}
void _foreach_sub_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_sub_out(self, scalar, out);
}
void _foreach_sub_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_sub_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_sub(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_list_kernel_slow(self, other, alpha);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_sub_out(at::TensorList self, at::TensorList other, const at::Scalar & alpha, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sub_List_out(self, other, alpha, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_sub_(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_list_kernel_slow_(self, other, alpha);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sub.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_sub));
m.impl("_foreach_sub.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_sub_out));
m.impl("_foreach_sub_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_sub_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sub(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List__foreach_sub(self, other, alpha);
}
void _foreach_sub_out(at::TensorList out, at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_sub_out(self, other, alpha, out);
}
void _foreach_sub_outf(at::TensorList self, at::TensorList other, const at::Scalar & alpha, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_sub_out(self, other, alpha, out);
}
void _foreach_sub_(at::TensorList self, at::TensorList other, const at::Scalar & alpha) {
return wrapper_CompositeExplicitAutograd_List__foreach_sub_(self, other, alpha);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_sub_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sub_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sub_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sub.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub));
m.impl("_foreach_sub.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_sub_out));
m.impl("_foreach_sub_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sub(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub(self, scalars);
}
void _foreach_sub_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_sub_out(self, scalars, out);
}
void _foreach_sub_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_sub_out(self, scalars, out);
}
void _foreach_sub_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_sub_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_mul(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_mul_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_mul_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_mul_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_mul.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_mul));
m.impl("_foreach_mul.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_mul_out));
m.impl("_foreach_mul_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_mul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_mul(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_mul(self, scalar);
}
void _foreach_mul_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_mul_out(self, scalar, out);
}
void _foreach_mul_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_mul_out(self, scalar, out);
}
void _foreach_mul_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_mul_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_mul(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_mul_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_mul_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_mul_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_mul.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_mul));
m.impl("_foreach_mul.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_mul_out));
m.impl("_foreach_mul_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_mul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_mul(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_mul(self, other);
}
void _foreach_mul_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_mul_out(self, other, out);
}
void _foreach_mul_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_mul_out(self, other, out);
}
void _foreach_mul_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_mul_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_mul_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_mul_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_mul.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul));
m.impl("_foreach_mul.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_mul_out));
m.impl("_foreach_mul_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_mul(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul(self, scalars);
}
void _foreach_mul_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_mul_out(self, scalars, out);
}
void _foreach_mul_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_mul_out(self, scalars, out);
}
void _foreach_mul_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_mul_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor__foreach_mul(at::TensorList self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_tensor_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out__foreach_mul_out(at::TensorList self, const at::Tensor & other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_mul_Tensor_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor__foreach_mul_(at::TensorList self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_mul_tensor_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_mul.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_mul));
m.impl("_foreach_mul.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__foreach_mul_out));
m.impl("_foreach_mul_.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_mul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_mul(at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_mul(self, other);
}
void _foreach_mul_out(at::TensorList out, at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_mul_out(self, other, out);
}
void _foreach_mul_outf(at::TensorList self, const at::Tensor & other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_mul_out(self, other, out);
}
void _foreach_mul_(at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_mul_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_div(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_div_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_div_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_div_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_div.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_div));
m.impl("_foreach_div.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_div_out));
m.impl("_foreach_div_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_div(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_div(self, scalar);
}
void _foreach_div_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_div_out(self, scalar, out);
}
void _foreach_div_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_div_out(self, scalar, out);
}
void _foreach_div_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_div_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_div(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_div_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_div_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_div_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_div.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_div));
m.impl("_foreach_div.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_div_out));
m.impl("_foreach_div_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_div(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_div(self, other);
}
void _foreach_div_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_div_out(self, other, out);
}
void _foreach_div_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_div_out(self, other, out);
}
void _foreach_div_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_div_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_div(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_div_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_div_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_div_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_div.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_div));
m.impl("_foreach_div.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_div_out));
m.impl("_foreach_div_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_div(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_div(self, scalars);
}
void _foreach_div_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_div_out(self, scalars, out);
}
void _foreach_div_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_div_out(self, scalars, out);
}
void _foreach_div_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_div_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor__foreach_div(at::TensorList self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_tensor_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out__foreach_div_out(at::TensorList self, const at::Tensor & other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_div_Tensor_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor__foreach_div_(at::TensorList self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_div_tensor_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_div.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_div));
m.impl("_foreach_div.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__foreach_div_out));
m.impl("_foreach_div_.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_div_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_div(at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_div(self, other);
}
void _foreach_div_out(at::TensorList out, at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_div_out(self, other, out);
}
void _foreach_div_outf(at::TensorList self, const at::Tensor & other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_div_out(self, other, out);
}
void _foreach_div_(at::TensorList self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_div_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_max_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_max_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_max.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max));
m.impl("_foreach_clamp_max.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_max_out));
m.impl("_foreach_clamp_max_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_max(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max(self, scalar);
}
void _foreach_clamp_max_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_max_out(self, scalar, out);
}
void _foreach_clamp_max_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_max_out(self, scalar, out);
}
void _foreach_clamp_max_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_max_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_clamp_max(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_max_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_max_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_clamp_max_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_max.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_clamp_max));
m.impl("_foreach_clamp_max.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_max_out));
m.impl("_foreach_clamp_max_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_clamp_max_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_max(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_clamp_max(self, other);
}
void _foreach_clamp_max_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_max_out(self, other, out);
}
void _foreach_clamp_max_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_max_out(self, other, out);
}
void _foreach_clamp_max_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_clamp_max_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_max_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_max_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_max.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max));
m.impl("_foreach_clamp_max.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_max_out));
m.impl("_foreach_clamp_max_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_max(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max(self, scalars);
}
void _foreach_clamp_max_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_max_out(self, scalars, out);
}
void _foreach_clamp_max_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_max_out(self, scalars, out);
}
void _foreach_clamp_max_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_max_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_min_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_min_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_min.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min));
m.impl("_foreach_clamp_min.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_min_out));
m.impl("_foreach_clamp_min_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_min(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min(self, scalar);
}
void _foreach_clamp_min_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_min_out(self, scalar, out);
}
void _foreach_clamp_min_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_clamp_min_out(self, scalar, out);
}
void _foreach_clamp_min_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_clamp_min_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_clamp_min(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_min_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_min_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_clamp_min_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_min.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_clamp_min));
m.impl("_foreach_clamp_min.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_min_out));
m.impl("_foreach_clamp_min_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_clamp_min_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_min(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_clamp_min(self, other);
}
void _foreach_clamp_min_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_min_out(self, other, out);
}
void _foreach_clamp_min_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_clamp_min_out(self, other, out);
}
void _foreach_clamp_min_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_clamp_min_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_min_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_clamp_min_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_clamp_min.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min));
m.impl("_foreach_clamp_min.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_min_out));
m.impl("_foreach_clamp_min_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_clamp_min(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min(self, scalars);
}
void _foreach_clamp_min_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_min_out(self, scalars, out);
}
void _foreach_clamp_min_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_clamp_min_out(self, scalars, out);
}
void _foreach_clamp_min_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_clamp_min_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_maximum_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_maximum_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_maximum.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum));
m.impl("_foreach_maximum.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_maximum_out));
m.impl("_foreach_maximum_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_maximum(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum(self, scalar);
}
void _foreach_maximum_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_maximum_out(self, scalar, out);
}
void _foreach_maximum_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_maximum_out(self, scalar, out);
}
void _foreach_maximum_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_maximum_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_maximum(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_maximum_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_maximum_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_maximum_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_maximum.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_maximum));
m.impl("_foreach_maximum.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_maximum_out));
m.impl("_foreach_maximum_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_maximum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_maximum(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_maximum(self, other);
}
void _foreach_maximum_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_maximum_out(self, other, out);
}
void _foreach_maximum_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_maximum_out(self, other, out);
}
void _foreach_maximum_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_maximum_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_maximum_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_maximum_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_min_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_maximum.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum));
m.impl("_foreach_maximum.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_maximum_out));
m.impl("_foreach_maximum_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_maximum(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum(self, scalars);
}
void _foreach_maximum_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_maximum_out(self, scalars, out);
}
void _foreach_maximum_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_maximum_out(self, scalars, out);
}
void _foreach_maximum_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_maximum_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalar_kernel_slow(self, scalar);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_minimum_out(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_minimum_Scalar_out(self, scalar, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum_(at::TensorList self, const at::Scalar & scalar) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalar_kernel_slow_(self, scalar);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_minimum.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum));
m.impl("_foreach_minimum.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_minimum_out));
m.impl("_foreach_minimum_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_minimum(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum(self, scalar);
}
void _foreach_minimum_out(at::TensorList out, at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_minimum_out(self, scalar, out);
}
void _foreach_minimum_outf(at::TensorList self, const at::Scalar & scalar, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_minimum_out(self, scalar, out);
}
void _foreach_minimum_(at::TensorList self, const at::Scalar & scalar) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_minimum_(self, scalar);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_minimum(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_list_kernel_slow(self, other);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_minimum_out(at::TensorList self, at::TensorList other, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_minimum_List_out(self, other, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_minimum_(at::TensorList self, at::TensorList other) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_list_kernel_slow_(self, other);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_minimum.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_minimum));
m.impl("_foreach_minimum.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_minimum_out));
m.impl("_foreach_minimum_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_minimum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_minimum(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_minimum(self, other);
}
void _foreach_minimum_out(at::TensorList out, at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_minimum_out(self, other, out);
}
void _foreach_minimum_outf(at::TensorList self, at::TensorList other, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_minimum_out(self, other, out);
}
void _foreach_minimum_(at::TensorList self, at::TensorList other) {
return wrapper_CompositeExplicitAutograd_List__foreach_minimum_(self, other);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalarlist_kernel_slow(self, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_minimum_out(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_minimum_ScalarList_out(self, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_clamp_max_scalarlist_kernel_slow_(self, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_minimum.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum));
m.impl("_foreach_minimum.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_minimum_out));
m.impl("_foreach_minimum_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_minimum(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum(self, scalars);
}
void _foreach_minimum_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_minimum_out(self, scalars, out);
}
void _foreach_minimum_outf(at::TensorList self, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_minimum_out(self, scalars, out);
}
void _foreach_minimum_(at::TensorList self, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_minimum_(self, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_scalar_slow(self, tensor1, tensor2, value);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcdiv_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcdiv_Scalar_out(self, tensor1, tensor2, value, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_scalar_slow_(self, tensor1, tensor2, value);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcdiv.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv));
m.impl("_foreach_addcdiv.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcdiv_out));
m.impl("_foreach_addcdiv_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv(self, tensor1, tensor2, value);
}
void _foreach_addcdiv_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcdiv_out(self, tensor1, tensor2, value, out);
}
void _foreach_addcdiv_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcdiv_out(self, tensor1, tensor2, value, out);
}
void _foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_addcdiv_(self, tensor1, tensor2, value);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_scalarlist_slow(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcdiv_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcdiv_ScalarList_out(self, tensor1, tensor2, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_scalarlist_slow_(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcdiv.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv));
m.impl("_foreach_addcdiv.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcdiv_out));
m.impl("_foreach_addcdiv_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv(self, tensor1, tensor2, scalars);
}
void _foreach_addcdiv_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcdiv_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcdiv_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcdiv_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcdiv_(self, tensor1, tensor2, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_tensor_slow(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcdiv_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcdiv_Tensor_out(self, tensor1, tensor2, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcdiv_tensor_slow_(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcdiv.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv));
m.impl("_foreach_addcdiv.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcdiv_out));
m.impl("_foreach_addcdiv_.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcdiv(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv(self, tensor1, tensor2, scalars);
}
void _foreach_addcdiv_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcdiv_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcdiv_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcdiv_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcdiv_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_addcdiv_(self, tensor1, tensor2, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_scalar_slow(self, tensor1, tensor2, value);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcmul_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcmul_Scalar_out(self, tensor1, tensor2, value, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_scalar_slow_(self, tensor1, tensor2, value);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcmul.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul));
m.impl("_foreach_addcmul.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcmul_out));
m.impl("_foreach_addcmul_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul(self, tensor1, tensor2, value);
}
void _foreach_addcmul_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcmul_out(self, tensor1, tensor2, value, out);
}
void _foreach_addcmul_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_addcmul_out(self, tensor1, tensor2, value, out);
}
void _foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Scalar & value) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_addcmul_(self, tensor1, tensor2, value);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_scalarlist_slow(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcmul_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcmul_ScalarList_out(self, tensor1, tensor2, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_scalarlist_slow_(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcmul.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul));
m.impl("_foreach_addcmul.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcmul_out));
m.impl("_foreach_addcmul_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul(self, tensor1, tensor2, scalars);
}
void _foreach_addcmul_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcmul_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcmul_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_addcmul_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, at::ArrayRef<at::Scalar> scalars) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_addcmul_(self, tensor1, tensor2, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_tensor_slow(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcmul_out(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_addcmul_Tensor_out(self, tensor1, tensor2, scalars, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_addcmul_tensor_slow_(self, tensor1, tensor2, scalars);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_addcmul.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul));
m.impl("_foreach_addcmul.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcmul_out));
m.impl("_foreach_addcmul_.Tensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_addcmul(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul(self, tensor1, tensor2, scalars);
}
void _foreach_addcmul_out(at::TensorList out, at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcmul_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcmul_outf(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out__foreach_addcmul_out(self, tensor1, tensor2, scalars, out);
}
void _foreach_addcmul_(at::TensorList self, at::TensorList tensor1, at::TensorList tensor2, const at::Tensor & scalars) {
return wrapper_CompositeExplicitAutograd_Tensor__foreach_addcmul_(self, tensor1, tensor2, scalars);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_abs(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_abs_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_abs_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_abs_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_abs_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_abs_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_abs",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_abs));
m.impl("_foreach_abs.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_abs_out));
m.impl("_foreach_abs_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_abs_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_abs(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_abs(self);
}
void _foreach_abs_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_abs_out(self, out);
}
void _foreach_abs_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_abs_out(self, out);
}
void _foreach_abs_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_abs_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_acos(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_acos_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_acos_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_acos_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_acos_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_acos_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_acos",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_acos));
m.impl("_foreach_acos.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_acos_out));
m.impl("_foreach_acos_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_acos_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_acos(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_acos(self);
}
void _foreach_acos_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_acos_out(self, out);
}
void _foreach_acos_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_acos_out(self, out);
}
void _foreach_acos_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_acos_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_asin(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_asin_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_asin_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_asin_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_asin_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_asin_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_asin",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_asin));
m.impl("_foreach_asin.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_asin_out));
m.impl("_foreach_asin_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_asin_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_asin(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_asin(self);
}
void _foreach_asin_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_asin_out(self, out);
}
void _foreach_asin_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_asin_out(self, out);
}
void _foreach_asin_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_asin_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_atan(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_atan_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_atan_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_atan_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_atan_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_atan_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_atan",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_atan));
m.impl("_foreach_atan.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_atan_out));
m.impl("_foreach_atan_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_atan_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_atan(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_atan(self);
}
void _foreach_atan_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_atan_out(self, out);
}
void _foreach_atan_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_atan_out(self, out);
}
void _foreach_atan_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_atan_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_ceil(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_ceil_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_ceil_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_ceil_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_ceil_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_ceil_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_ceil",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_ceil));
m.impl("_foreach_ceil.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_ceil_out));
m.impl("_foreach_ceil_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_ceil_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_ceil(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_ceil(self);
}
void _foreach_ceil_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_ceil_out(self, out);
}
void _foreach_ceil_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_ceil_out(self, out);
}
void _foreach_ceil_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_ceil_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_cos(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_cos_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_cos_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_cos_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_cos_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_cos_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_cos",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_cos));
m.impl("_foreach_cos.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_cos_out));
m.impl("_foreach_cos_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_cos_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_cos(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_cos(self);
}
void _foreach_cos_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_cos_out(self, out);
}
void _foreach_cos_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_cos_out(self, out);
}
void _foreach_cos_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_cos_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_cosh(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_cosh_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_cosh_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_cosh_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_cosh_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_cosh_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_cosh",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_cosh));
m.impl("_foreach_cosh.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_cosh_out));
m.impl("_foreach_cosh_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_cosh_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_cosh(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_cosh(self);
}
void _foreach_cosh_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_cosh_out(self, out);
}
void _foreach_cosh_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_cosh_out(self, out);
}
void _foreach_cosh_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_cosh_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_erf(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_erf_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_erf_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_erf_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_erf_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_erf_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_erf",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_erf));
m.impl("_foreach_erf.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_erf_out));
m.impl("_foreach_erf_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_erf_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_erf(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_erf(self);
}
void _foreach_erf_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_erf_out(self, out);
}
void _foreach_erf_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_erf_out(self, out);
}
void _foreach_erf_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_erf_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_erfc(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_erfc_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_erfc_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_erfc_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_erfc_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_erfc_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_erfc",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_erfc));
m.impl("_foreach_erfc.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_erfc_out));
m.impl("_foreach_erfc_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_erfc_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_erfc(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_erfc(self);
}
void _foreach_erfc_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_erfc_out(self, out);
}
void _foreach_erfc_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_erfc_out(self, out);
}
void _foreach_erfc_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_erfc_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_exp(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_exp_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_exp_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_exp_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_exp_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_exp_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_exp",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_exp));
m.impl("_foreach_exp.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_exp_out));
m.impl("_foreach_exp_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_exp_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_exp(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_exp(self);
}
void _foreach_exp_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_exp_out(self, out);
}
void _foreach_exp_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_exp_out(self, out);
}
void _foreach_exp_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_exp_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_expm1(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_expm1_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_expm1_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_expm1_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_expm1_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_expm1_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_expm1",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_expm1));
m.impl("_foreach_expm1.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_expm1_out));
m.impl("_foreach_expm1_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_expm1_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_expm1(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_expm1(self);
}
void _foreach_expm1_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_expm1_out(self, out);
}
void _foreach_expm1_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_expm1_out(self, out);
}
void _foreach_expm1_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_expm1_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_floor(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_floor_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_floor_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_floor_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_floor_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_floor_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_floor",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_floor));
m.impl("_foreach_floor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_floor_out));
m.impl("_foreach_floor_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_floor_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_floor(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_floor(self);
}
void _foreach_floor_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_floor_out(self, out);
}
void _foreach_floor_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_floor_out(self, out);
}
void _foreach_floor_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_floor_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_frac(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_frac_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_frac_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_frac_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_frac_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_frac_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_frac",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_frac));
m.impl("_foreach_frac.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_frac_out));
m.impl("_foreach_frac_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_frac_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_frac(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_frac(self);
}
void _foreach_frac_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_frac_out(self, out);
}
void _foreach_frac_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_frac_out(self, out);
}
void _foreach_frac_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_frac_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_lerp(at::TensorList self, at::TensorList tensors1, at::TensorList weights) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_ternary_lerp_slow(self, tensors1, weights);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_lerp_out(at::TensorList self, at::TensorList tensors1, at::TensorList weights, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_lerp_List_out(self, tensors1, weights, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_lerp_(at::TensorList self, at::TensorList tensors1, at::TensorList weights) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_ternary_lerp_slow_(self, tensors1, weights);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_lerp.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_lerp));
m.impl("_foreach_lerp.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_lerp_out));
m.impl("_foreach_lerp_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_lerp_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_lerp(at::TensorList self, at::TensorList tensors1, at::TensorList weights) {
return wrapper_CompositeExplicitAutograd_List__foreach_lerp(self, tensors1, weights);
}
void _foreach_lerp_out(at::TensorList out, at::TensorList self, at::TensorList tensors1, at::TensorList weights) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_lerp_out(self, tensors1, weights, out);
}
void _foreach_lerp_outf(at::TensorList self, at::TensorList tensors1, at::TensorList weights, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_lerp_out(self, tensors1, weights, out);
}
void _foreach_lerp_(at::TensorList self, at::TensorList tensors1, at::TensorList weights) {
return wrapper_CompositeExplicitAutograd_List__foreach_lerp_(self, tensors1, weights);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lerp_list_kernel_slow(self, tensors1, weight);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_lerp_out(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_lerp_Scalar_out(self, tensors1, weight, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp_(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lerp_list_kernel_slow_(self, tensors1, weight);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_lerp.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp));
m.impl("_foreach_lerp.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_lerp_out));
m.impl("_foreach_lerp_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_lerp(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp(self, tensors1, weight);
}
void _foreach_lerp_out(at::TensorList out, at::TensorList self, at::TensorList tensors1, const at::Scalar & weight) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_lerp_out(self, tensors1, weight, out);
}
void _foreach_lerp_outf(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_lerp_out(self, tensors1, weight, out);
}
void _foreach_lerp_(at::TensorList self, at::TensorList tensors1, const at::Scalar & weight) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_lerp_(self, tensors1, weight);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lerp_scalarlist_kernel_slow(self, tensors1, weight);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_lerp_out(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_lerp_ScalarList_out(self, tensors1, weight, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp_(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lerp_scalarlist_kernel_slow_(self, tensors1, weight);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_lerp.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp));
m.impl("_foreach_lerp.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_lerp_out));
m.impl("_foreach_lerp_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_lerp(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp(self, tensors1, weight);
}
void _foreach_lerp_out(at::TensorList out, at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_lerp_out(self, tensors1, weight, out);
}
void _foreach_lerp_outf(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_lerp_out(self, tensors1, weight, out);
}
void _foreach_lerp_(at::TensorList self, at::TensorList tensors1, at::ArrayRef<at::Scalar> weight) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_lerp_(self, tensors1, weight);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_lgamma(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lgamma_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_lgamma_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_lgamma_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_lgamma_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_lgamma_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_lgamma",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_lgamma));
m.impl("_foreach_lgamma.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_lgamma_out));
m.impl("_foreach_lgamma_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_lgamma_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_lgamma(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_lgamma(self);
}
void _foreach_lgamma_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_lgamma_out(self, out);
}
void _foreach_lgamma_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_lgamma_out(self, out);
}
void _foreach_lgamma_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_lgamma_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_log(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_log_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_log_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_log_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_log",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log));
m.impl("_foreach_log.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_log_out));
m.impl("_foreach_log_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_log(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log(self);
}
void _foreach_log_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_log_out(self, out);
}
void _foreach_log_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_log_out(self, out);
}
void _foreach_log_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_log10(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log10_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_log10_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_log10_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_log10_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log10_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_log10",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log10));
m.impl("_foreach_log10.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_log10_out));
m.impl("_foreach_log10_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log10_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_log10(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log10(self);
}
void _foreach_log10_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_log10_out(self, out);
}
void _foreach_log10_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_log10_out(self, out);
}
void _foreach_log10_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log10_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_log1p(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log1p_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_log1p_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_log1p_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_log1p_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log1p_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_log1p",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log1p));
m.impl("_foreach_log1p.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_log1p_out));
m.impl("_foreach_log1p_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log1p_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_log1p(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log1p(self);
}
void _foreach_log1p_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_log1p_out(self, out);
}
void _foreach_log1p_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_log1p_out(self, out);
}
void _foreach_log1p_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log1p_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_log2(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log2_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_log2_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_log2_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_log2_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_log2_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_log2",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log2));
m.impl("_foreach_log2.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_log2_out));
m.impl("_foreach_log2_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_log2_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_log2(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log2(self);
}
void _foreach_log2_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_log2_out(self, out);
}
void _foreach_log2_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_log2_out(self, out);
}
void _foreach_log2_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_log2_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_max(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_max_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_max_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_max_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_max",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_max));
m.impl("_foreach_max.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_max_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_max(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_max(self);
}
void _foreach_max_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_max_out(self, out);
}
void _foreach_max_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_max_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_neg(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_neg_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_neg_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_neg_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_neg_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_neg_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_neg",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_neg));
m.impl("_foreach_neg.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_neg_out));
m.impl("_foreach_neg_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_neg_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_neg(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_neg(self);
}
void _foreach_neg_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_neg_out(self, out);
}
void _foreach_neg_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_neg_out(self, out);
}
void _foreach_neg_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_neg_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_norm(at::TensorList self, const at::Scalar & ord, ::std::optional<at::ScalarType> dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_norm_slow(self, ord, dtype);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_norm_out(at::TensorList self, const at::Scalar & ord, ::std::optional<at::ScalarType> dtype, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_norm_Scalar_out(self, ord, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_norm.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_norm));
m.impl("_foreach_norm.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_norm_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_norm(at::TensorList self, const at::Scalar & ord, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_norm(self, ord, dtype);
}
void _foreach_norm_out(at::TensorList out, at::TensorList self, const at::Scalar & ord, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_norm_out(self, ord, dtype, out);
}
void _foreach_norm_outf(at::TensorList self, const at::Scalar & ord, ::std::optional<at::ScalarType> dtype, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_norm_out(self, ord, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_List__foreach_pow(at::TensorList self, at::TensorList exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_list_kernel_slow(self, exponent);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List_out__foreach_pow_out(at::TensorList self, at::TensorList exponent, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_pow_List_out(self, exponent, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_List__foreach_pow_(at::TensorList self, at::TensorList exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_list_kernel_slow_(self, exponent);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_pow.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_pow));
m.impl("_foreach_pow.List_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_List_out__foreach_pow_out));
m.impl("_foreach_pow_.List",
TORCH_FN(wrapper_CompositeExplicitAutograd_List__foreach_pow_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_pow(at::TensorList self, at::TensorList exponent) {
return wrapper_CompositeExplicitAutograd_List__foreach_pow(self, exponent);
}
void _foreach_pow_out(at::TensorList out, at::TensorList self, at::TensorList exponent) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_outf(at::TensorList self, at::TensorList exponent, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_List_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_(at::TensorList self, at::TensorList exponent) {
return wrapper_CompositeExplicitAutograd_List__foreach_pow_(self, exponent);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_Scalar__foreach_pow(at::TensorList self, const at::Scalar & exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_scalar_kernel_slow(self, exponent);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar_out__foreach_pow_out(at::TensorList self, const at::Scalar & exponent, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_pow_Scalar_out(self, exponent, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_Scalar__foreach_pow_(at::TensorList self, const at::Scalar & exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_scalar_kernel_slow_(self, exponent);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_pow.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_pow));
m.impl("_foreach_pow.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out__foreach_pow_out));
m.impl("_foreach_pow_.Scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar__foreach_pow_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_pow(at::TensorList self, const at::Scalar & exponent) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_pow(self, exponent);
}
void _foreach_pow_out(at::TensorList out, at::TensorList self, const at::Scalar & exponent) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_outf(at::TensorList self, const at::Scalar & exponent, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Scalar_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_(at::TensorList self, const at::Scalar & exponent) {
return wrapper_CompositeExplicitAutograd_Scalar__foreach_pow_(self, exponent);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow(at::TensorList self, at::ArrayRef<at::Scalar> exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_scalarlist_kernel_slow(self, exponent);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_pow_out(at::TensorList self, at::ArrayRef<at::Scalar> exponent, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_pow_ScalarList_out(self, exponent, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow_(at::TensorList self, at::ArrayRef<at::Scalar> exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_pow_scalarlist_kernel_slow_(self, exponent);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_pow.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow));
m.impl("_foreach_pow.ScalarList_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_pow_out));
m.impl("_foreach_pow_.ScalarList",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_pow(at::TensorList self, at::ArrayRef<at::Scalar> exponent) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow(self, exponent);
}
void _foreach_pow_out(at::TensorList out, at::TensorList self, at::ArrayRef<at::Scalar> exponent) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_outf(at::TensorList self, at::ArrayRef<at::Scalar> exponent, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_ScalarList_out__foreach_pow_out(self, exponent, out);
}
void _foreach_pow_(at::TensorList self, at::ArrayRef<at::Scalar> exponent) {
return wrapper_CompositeExplicitAutograd_ScalarList__foreach_pow_(self, exponent);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd_ScalarAndTensor__foreach_pow(const at::Scalar & self, at::TensorList exponent) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_scalar_pow_list_kernel_slow(self, exponent);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_pow.ScalarAndTensor",
TORCH_FN(wrapper_CompositeExplicitAutograd_ScalarAndTensor__foreach_pow));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_pow(const at::Scalar & self, at::TensorList exponent) {
return wrapper_CompositeExplicitAutograd_ScalarAndTensor__foreach_pow(self, exponent);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_reciprocal(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_reciprocal_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_reciprocal_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_reciprocal_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_reciprocal_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_reciprocal_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_reciprocal",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_reciprocal));
m.impl("_foreach_reciprocal.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_reciprocal_out));
m.impl("_foreach_reciprocal_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_reciprocal_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_reciprocal(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_reciprocal(self);
}
void _foreach_reciprocal_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_reciprocal_out(self, out);
}
void _foreach_reciprocal_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_reciprocal_out(self, out);
}
void _foreach_reciprocal_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_reciprocal_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_round(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_round_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_round_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_round_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_round_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_round_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_round",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_round));
m.impl("_foreach_round.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_round_out));
m.impl("_foreach_round_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_round_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_round(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_round(self);
}
void _foreach_round_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_round_out(self, out);
}
void _foreach_round_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_round_out(self, out);
}
void _foreach_round_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_round_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_rsqrt(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_rsqrt_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_rsqrt_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_rsqrt_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_rsqrt_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_rsqrt_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_rsqrt",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_rsqrt));
m.impl("_foreach_rsqrt.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_rsqrt_out));
m.impl("_foreach_rsqrt_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_rsqrt_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_rsqrt(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_rsqrt(self);
}
void _foreach_rsqrt_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_rsqrt_out(self, out);
}
void _foreach_rsqrt_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_rsqrt_out(self, out);
}
void _foreach_rsqrt_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_rsqrt_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_sigmoid(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sigmoid_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_sigmoid_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sigmoid_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_sigmoid_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sigmoid_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sigmoid",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sigmoid));
m.impl("_foreach_sigmoid.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_sigmoid_out));
m.impl("_foreach_sigmoid_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sigmoid_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sigmoid(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sigmoid(self);
}
void _foreach_sigmoid_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_sigmoid_out(self, out);
}
void _foreach_sigmoid_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_sigmoid_out(self, out);
}
void _foreach_sigmoid_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sigmoid_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_sign(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sign_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_sign_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sign_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_sign_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sign_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sign",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sign));
m.impl("_foreach_sign.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_sign_out));
m.impl("_foreach_sign_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sign_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sign(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sign(self);
}
void _foreach_sign_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_sign_out(self, out);
}
void _foreach_sign_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_sign_out(self, out);
}
void _foreach_sign_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sign_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_sin(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sin_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_sin_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sin_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_sin_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sin_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sin",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sin));
m.impl("_foreach_sin.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_sin_out));
m.impl("_foreach_sin_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sin_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sin(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sin(self);
}
void _foreach_sin_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_sin_out(self, out);
}
void _foreach_sin_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_sin_out(self, out);
}
void _foreach_sin_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sin_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_sinh(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sinh_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_sinh_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sinh_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_sinh_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sinh_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sinh",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sinh));
m.impl("_foreach_sinh.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_sinh_out));
m.impl("_foreach_sinh_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sinh_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sinh(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sinh(self);
}
void _foreach_sinh_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_sinh_out(self, out);
}
void _foreach_sinh_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_sinh_out(self, out);
}
void _foreach_sinh_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sinh_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_sqrt(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sqrt_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_sqrt_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_sqrt_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_sqrt_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_sqrt_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_sqrt",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sqrt));
m.impl("_foreach_sqrt.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_sqrt_out));
m.impl("_foreach_sqrt_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_sqrt_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_sqrt(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sqrt(self);
}
void _foreach_sqrt_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_sqrt_out(self, out);
}
void _foreach_sqrt_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_sqrt_out(self, out);
}
void _foreach_sqrt_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_sqrt_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_tan(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_tan_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_tan_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_tan_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_tan_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_tan_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_tan",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_tan));
m.impl("_foreach_tan.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_tan_out));
m.impl("_foreach_tan_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_tan_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_tan(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_tan(self);
}
void _foreach_tan_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_tan_out(self, out);
}
void _foreach_tan_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_tan_out(self, out);
}
void _foreach_tan_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_tan_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_tanh(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_tanh_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_tanh_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_tanh_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_tanh_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_tanh_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_tanh",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_tanh));
m.impl("_foreach_tanh.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_tanh_out));
m.impl("_foreach_tanh_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_tanh_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_tanh(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_tanh(self);
}
void _foreach_tanh_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_tanh_out(self, out);
}
void _foreach_tanh_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_tanh_out(self, out);
}
void _foreach_tanh_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_tanh_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_trunc(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_trunc_slow(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_trunc_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_trunc_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_trunc_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_trunc_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_trunc",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_trunc));
m.impl("_foreach_trunc.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_trunc_out));
m.impl("_foreach_trunc_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_trunc_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_trunc(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_trunc(self);
}
void _foreach_trunc_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_trunc_out(self, out);
}
void _foreach_trunc_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_trunc_out(self, out);
}
void _foreach_trunc_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_trunc_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_zero(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_zero(self);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_zero_out(at::TensorList self, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_zero_out(self, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_zero_(at::TensorList self) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_zero_slow_(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_zero",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_zero));
m.impl("_foreach_zero.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_zero_out));
m.impl("_foreach_zero_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_zero_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_zero(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_zero(self);
}
void _foreach_zero_out(at::TensorList out, at::TensorList self) {
return wrapper_CompositeExplicitAutograd_out__foreach_zero_out(self, out);
}
void _foreach_zero_outf(at::TensorList self, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_zero_out(self, out);
}
void _foreach_zero_(at::TensorList self) {
return wrapper_CompositeExplicitAutograd___foreach_zero_(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::vector<at::Tensor> wrapper_CompositeExplicitAutograd___foreach_copy(at::TensorList self, at::TensorList src, bool non_blocking) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_copy(self, src, non_blocking);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__foreach_copy_out(at::TensorList self, at::TensorList src, bool non_blocking, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foreach_copy_out(self, src, non_blocking, out);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd___foreach_copy_(at::TensorList self, at::TensorList src, bool non_blocking) {
    // No device check
  // DeviceGuard omitted
  return at::native::foreach_tensor_copy_list_kernel_slow_(self, src, non_blocking);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foreach_copy",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_copy));
m.impl("_foreach_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foreach_copy_out));
m.impl("_foreach_copy_",
TORCH_FN(wrapper_CompositeExplicitAutograd___foreach_copy_));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::vector<at::Tensor> _foreach_copy(at::TensorList self, at::TensorList src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd___foreach_copy(self, src, non_blocking);
}
void _foreach_copy_out(at::TensorList out, at::TensorList self, at::TensorList src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd_out__foreach_copy_out(self, src, non_blocking, out);
}
void _foreach_copy_outf(at::TensorList self, at::TensorList src, bool non_blocking, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__foreach_copy_out(self, src, non_blocking, out);
}
void _foreach_copy_(at::TensorList self, at::TensorList src, bool non_blocking) {
return wrapper_CompositeExplicitAutograd___foreach_copy_(self, src, non_blocking);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Scalar_out_bucketize_out(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::bucketize_Scalar_out(self, boundaries, out_int32, right, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("bucketize.Scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Scalar_out_bucketize_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & bucketize_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bucketize_out(self, boundaries, out_int32, right, out);
}
at::Tensor & bucketize_outf(const at::Scalar & self, const at::Tensor & boundaries, bool out_int32, bool right, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Scalar_out_bucketize_out(self, boundaries, out_int32, right, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__smooth_l1_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta) {
    // No device check
  // DeviceGuard omitted
  return at::native::smooth_l1_loss_backward(grad_output, self, target, reduction, beta);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("smooth_l1_loss_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__smooth_l1_loss_backward));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor smooth_l1_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta) {
return wrapper_CompositeExplicitAutograd__smooth_l1_loss_backward(grad_output, self, target, reduction, beta);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__huber_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double delta) {
    // No device check
  // DeviceGuard omitted
  return at::native::huber_loss_backward(grad_output, self, target, reduction, delta);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("huber_loss_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__huber_loss_backward));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor huber_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double delta) {
return wrapper_CompositeExplicitAutograd__huber_loss_backward(grad_output, self, target, reduction, delta);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__soft_margin_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
    // No device check
  // DeviceGuard omitted
  return at::native::soft_margin_loss(self, target, reduction);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_soft_margin_loss_out(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::soft_margin_loss_out(self, target, reduction, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("soft_margin_loss",
TORCH_FN(wrapper_CompositeExplicitAutograd__soft_margin_loss));
m.impl("soft_margin_loss.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_soft_margin_loss_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor soft_margin_loss(const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
return wrapper_CompositeExplicitAutograd__soft_margin_loss(self, target, reduction);
}
at::Tensor & soft_margin_loss_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
return wrapper_CompositeExplicitAutograd_out_soft_margin_loss_out(self, target, reduction, out);
}
at::Tensor & soft_margin_loss_outf(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_soft_margin_loss_out(self, target, reduction, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__soft_margin_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
    // No device check
  // DeviceGuard omitted
  return at::native::soft_margin_loss_backward(grad_output, self, target, reduction);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_grad_input_soft_margin_loss_backward_out(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & grad_input) {
    // No device check
  // DeviceGuard omitted
  return at::native::soft_margin_loss_backward_out(grad_output, self, target, reduction, grad_input);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("soft_margin_loss_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__soft_margin_loss_backward));
m.impl("soft_margin_loss_backward.grad_input",
TORCH_FN(wrapper_CompositeExplicitAutograd_grad_input_soft_margin_loss_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor soft_margin_loss_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
return wrapper_CompositeExplicitAutograd__soft_margin_loss_backward(grad_output, self, target, reduction);
}
at::Tensor & soft_margin_loss_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction) {
return wrapper_CompositeExplicitAutograd_grad_input_soft_margin_loss_backward_out(grad_output, self, target, reduction, grad_input);
}
at::Tensor & soft_margin_loss_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & grad_input) {
return wrapper_CompositeExplicitAutograd_grad_input_soft_margin_loss_backward_out(grad_output, self, target, reduction, grad_input);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_glu_jvp_out(const at::Tensor & glu, const at::Tensor & x, const at::Tensor & dx, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::glu_jvp_out(glu, x, dx, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("glu_jvp.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_glu_jvp_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & glu_jvp_out(at::Tensor & out, const at::Tensor & glu, const at::Tensor & x, const at::Tensor & dx, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_glu_jvp_out(glu, x, dx, dim, out);
}
at::Tensor & glu_jvp_outf(const at::Tensor & glu, const at::Tensor & x, const at::Tensor & dx, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_glu_jvp_out(glu, x, dx, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_glu_backward_jvp_out(const at::Tensor & grad_x, const at::Tensor & grad_glu, const at::Tensor & x, const at::Tensor & dgrad_glu, const at::Tensor & dx, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::glu_backward_jvp_out(grad_x, grad_glu, x, dgrad_glu, dx, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("glu_backward_jvp.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_glu_backward_jvp_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & glu_backward_jvp_out(at::Tensor & out, const at::Tensor & grad_x, const at::Tensor & grad_glu, const at::Tensor & x, const at::Tensor & dgrad_glu, const at::Tensor & dx, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_glu_backward_jvp_out(grad_x, grad_glu, x, dgrad_glu, dx, dim, out);
}
at::Tensor & glu_backward_jvp_outf(const at::Tensor & grad_x, const at::Tensor & grad_glu, const at::Tensor & x, const at::Tensor & dgrad_glu, const at::Tensor & dx, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_glu_backward_jvp_out(grad_x, grad_glu, x, dgrad_glu, dx, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_hardswish_backward_out(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::hardswish_backward_out(grad_output, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("hardswish_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_hardswish_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & hardswish_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_hardswish_backward_out(grad_output, self, out);
}
at::Tensor & hardswish_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_hardswish_backward_out(grad_output, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__rrelu_with_noise_functional(const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, ::std::optional<at::Generator> generator) {
    // No device check
  // DeviceGuard omitted
  return at::native::rrelu_with_noise_functional(self, noise, lower, upper, training, generator);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rrelu_with_noise_functional",
TORCH_FN(wrapper_CompositeExplicitAutograd__rrelu_with_noise_functional));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor> rrelu_with_noise_functional(const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, ::std::optional<at::Generator> generator) {
return wrapper_CompositeExplicitAutograd__rrelu_with_noise_functional(self, noise, lower, upper, training, generator);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__rrelu_with_noise_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result) {
    // No device check
  // DeviceGuard omitted
  return at::native::rrelu_with_noise_backward(grad_output, self, noise, lower, upper, training, self_is_result);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_rrelu_with_noise_backward_out(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::rrelu_with_noise_backward_out(grad_output, self, noise, lower, upper, training, self_is_result, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("rrelu_with_noise_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd__rrelu_with_noise_backward));
m.impl("rrelu_with_noise_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_rrelu_with_noise_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor rrelu_with_noise_backward(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result) {
return wrapper_CompositeExplicitAutograd__rrelu_with_noise_backward(grad_output, self, noise, lower, upper, training, self_is_result);
}
at::Tensor & rrelu_with_noise_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result) {
return wrapper_CompositeExplicitAutograd_out_rrelu_with_noise_backward_out(grad_output, self, noise, lower, upper, training, self_is_result, out);
}
at::Tensor & rrelu_with_noise_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & noise, const at::Scalar & lower, const at::Scalar & upper, bool training, bool self_is_result, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_rrelu_with_noise_backward_out(grad_output, self, noise, lower, upper, training, self_is_result, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_mkldnn_adaptive_avg_pool2d_backward_out(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::mkldnn_adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("mkldnn_adaptive_avg_pool2d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_mkldnn_adaptive_avg_pool2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & mkldnn_adaptive_avg_pool2d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
at::Tensor & mkldnn_adaptive_avg_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_mkldnn_adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_adaptive_avg_pool2d_out_symint(self, output_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_adaptive_avg_pool2d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _adaptive_avg_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out(self, c10::fromIntArrayRefSlow(output_size), out);
}
at::Tensor & _adaptive_avg_pool2d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out(self, c10::fromIntArrayRefSlow(output_size), out);
}
at::Tensor & _adaptive_avg_pool2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out(self, output_size, out);
}
at::Tensor & _adaptive_avg_pool2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_out(self, output_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_backward_out(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_adaptive_avg_pool2d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _adaptive_avg_pool2d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
at::Tensor & _adaptive_avg_pool2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool2d_backward_out(grad_output, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_adaptive_avg_pool3d_out_symint(self, output_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_adaptive_avg_pool3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _adaptive_avg_pool3d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out(self, c10::fromIntArrayRefSlow(output_size), out);
}
at::Tensor & _adaptive_avg_pool3d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out(self, c10::fromIntArrayRefSlow(output_size), out);
}
at::Tensor & _adaptive_avg_pool3d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out(self, output_size, out);
}
at::Tensor & _adaptive_avg_pool3d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_out(self, output_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_backward_out(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_adaptive_avg_pool3d_backward_out(grad_output, self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_adaptive_avg_pool3d_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _adaptive_avg_pool3d_backward_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_backward_out(grad_output, self, out);
}
at::Tensor & _adaptive_avg_pool3d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__adaptive_avg_pool3d_backward_out(grad_output, self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, bool align_corners, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::upsample_bilinear2d_vec_out_symint(input, output_size, align_corners, scale_factors, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("upsample_bilinear2d.vec_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & upsample_bilinear2d_out(at::Tensor & out, const at::Tensor & input, at::OptionalIntArrayRef output_size, bool align_corners, ::std::optional<at::ArrayRef<double>> scale_factors) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out(input, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, align_corners, scale_factors, out);
}
at::Tensor & upsample_bilinear2d_outf(const at::Tensor & input, at::OptionalIntArrayRef output_size, bool align_corners, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out(input, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, align_corners, scale_factors, out);
}
at::Tensor & upsample_bilinear2d_symint_out(at::Tensor & out, const at::Tensor & input, at::OptionalSymIntArrayRef output_size, bool align_corners, ::std::optional<at::ArrayRef<double>> scale_factors) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out(input, output_size, align_corners, scale_factors, out);
}
at::Tensor & upsample_bilinear2d_symint_outf(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, bool align_corners, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_bilinear2d_out(input, output_size, align_corners, scale_factors, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::upsample_nearest2d_vec_out_symint(input, output_size, scale_factors, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("upsample_nearest2d.vec_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & upsample_nearest2d_out(at::Tensor & out, const at::Tensor & input, at::OptionalIntArrayRef output_size, ::std::optional<at::ArrayRef<double>> scale_factors) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out(input, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, scale_factors, out);
}
at::Tensor & upsample_nearest2d_outf(const at::Tensor & input, at::OptionalIntArrayRef output_size, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out(input, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, scale_factors, out);
}
at::Tensor & upsample_nearest2d_symint_out(at::Tensor & out, const at::Tensor & input, at::OptionalSymIntArrayRef output_size, ::std::optional<at::ArrayRef<double>> scale_factors) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out(input, output_size, scale_factors, out);
}
at::Tensor & upsample_nearest2d_symint_outf(const at::Tensor & input, at::OptionalSymIntArrayRef output_size, ::std::optional<at::ArrayRef<double>> scale_factors, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_vec_out_upsample_nearest2d_out(input, output_size, scale_factors, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
    // No device check
  // DeviceGuard omitted
  return at::native::_slow_conv2d_backward_output_mask_out_symint(grad_output, self, weight, kernel_size, stride, padding, output_mask, out0, out1, out2);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_slow_conv2d_backward.output_mask_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _slow_conv2d_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out(grad_output, self, weight, c10::fromIntArrayRefSlow(kernel_size), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _slow_conv2d_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out(grad_output, self, weight, c10::fromIntArrayRefSlow(kernel_size), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _slow_conv2d_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, ::std::array<bool,3> output_mask) {
return wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out(grad_output, self, weight, kernel_size, stride, padding, output_mask, out0, out1, out2);
}
::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> _slow_conv2d_backward_symint_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
return wrapper_CompositeExplicitAutograd_output_mask_out__slow_conv2d_backward_out(grad_output, self, weight, kernel_size, stride, padding, output_mask, out0, out1, out2);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::conv_depthwise3d_out_symint(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("conv_depthwise3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & conv_depthwise3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & conv_depthwise3d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & conv_depthwise3d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
at::Tensor & conv_depthwise3d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_conv_depthwise3d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::slow_conv_dilated2d_out_symint(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slow_conv_dilated2d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & slow_conv_dilated2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & slow_conv_dilated2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & slow_conv_dilated2d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
at::Tensor & slow_conv_dilated2d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated2d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::slow_conv_dilated3d_out_symint(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slow_conv_dilated3d.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & slow_conv_dilated3d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & slow_conv_dilated3d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(dilation), out);
}
at::Tensor & slow_conv_dilated3d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
at::Tensor & slow_conv_dilated3d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const ::std::optional<at::Tensor> & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_slow_conv_dilated3d_out(self, weight, kernel_size, bias, stride, padding, dilation, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__isinf(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::isinf(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_isinf_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::isinf_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("isinf",
TORCH_FN(wrapper_CompositeExplicitAutograd__isinf));
m.impl("isinf.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_isinf_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor isinf(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd__isinf(self);
}
at::Tensor & isinf_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_isinf_out(self, out);
}
at::Tensor & isinf_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_isinf_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_self_scalar_special_xlog1py(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_xlog1py(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_self_scalar_out_special_xlog1py_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_xlog1py_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_xlog1py.self_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_self_scalar_special_xlog1py));
m.impl("special_xlog1py.self_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_self_scalar_out_special_xlog1py_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_xlog1py(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_self_scalar_special_xlog1py(self, other);
}
at::Tensor & special_xlog1py_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_self_scalar_out_special_xlog1py_out(self, other, out);
}
at::Tensor & special_xlog1py_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_self_scalar_out_special_xlog1py_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_other_scalar_special_xlog1py(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_xlog1py(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_other_scalar_out_special_xlog1py_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_xlog1py_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_xlog1py.other_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_other_scalar_special_xlog1py));
m.impl("special_xlog1py.other_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_other_scalar_out_special_xlog1py_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_xlog1py(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_other_scalar_special_xlog1py(self, other);
}
at::Tensor & special_xlog1py_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_other_scalar_out_special_xlog1py_out(self, other, out);
}
at::Tensor & special_xlog1py_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_other_scalar_out_special_xlog1py_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_self_scalar_special_zeta(const at::Scalar & self, const at::Tensor & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_zeta(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_self_scalar_out_special_zeta_out(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_zeta_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_zeta.self_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_self_scalar_special_zeta));
m.impl("special_zeta.self_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_self_scalar_out_special_zeta_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_zeta(const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_self_scalar_special_zeta(self, other);
}
at::Tensor & special_zeta_out(at::Tensor & out, const at::Scalar & self, const at::Tensor & other) {
return wrapper_CompositeExplicitAutograd_self_scalar_out_special_zeta_out(self, other, out);
}
at::Tensor & special_zeta_outf(const at::Scalar & self, const at::Tensor & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_self_scalar_out_special_zeta_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_other_scalar_special_zeta(const at::Tensor & self, const at::Scalar & other) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_zeta(self, other);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_other_scalar_out_special_zeta_out(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_zeta_out(self, other, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_zeta.other_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_other_scalar_special_zeta));
m.impl("special_zeta.other_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_other_scalar_out_special_zeta_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_zeta(const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_other_scalar_special_zeta(self, other);
}
at::Tensor & special_zeta_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) {
return wrapper_CompositeExplicitAutograd_other_scalar_out_special_zeta_out(self, other, out);
}
at::Tensor & special_zeta_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_other_scalar_out_special_zeta_out(self, other, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__fft_fftfreq(int64_t n, double d, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::fft_fftfreq(n, d, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_fft_fftfreq_out(int64_t n, double d, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::fft_fftfreq_out(n, d, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fft_fftfreq",
TORCH_FN(wrapper_CompositeExplicitAutograd__fft_fftfreq));
m.impl("fft_fftfreq.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_fft_fftfreq_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor fft_fftfreq(int64_t n, double d, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__fft_fftfreq(n, d, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor fft_fftfreq(int64_t n, double d, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__fft_fftfreq(n, d, dtype, layout, device, pin_memory);
}
at::Tensor & fft_fftfreq_out(at::Tensor & out, int64_t n, double d) {
return wrapper_CompositeExplicitAutograd_out_fft_fftfreq_out(n, d, out);
}
at::Tensor & fft_fftfreq_outf(int64_t n, double d, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_fft_fftfreq_out(n, d, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd__fft_rfftfreq(int64_t n, double d, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::fft_rfftfreq(n, d, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_fft_rfftfreq_out(int64_t n, double d, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::fft_rfftfreq_out(n, d, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("fft_rfftfreq",
TORCH_FN(wrapper_CompositeExplicitAutograd__fft_rfftfreq));
m.impl("fft_rfftfreq.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_fft_rfftfreq_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor fft_rfftfreq(int64_t n, double d, at::TensorOptions options) {
return wrapper_CompositeExplicitAutograd__fft_rfftfreq(n, d, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
}
at::Tensor fft_rfftfreq(int64_t n, double d, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd__fft_rfftfreq(n, d, dtype, layout, device, pin_memory);
}
at::Tensor & fft_rfftfreq_out(at::Tensor & out, int64_t n, double d) {
return wrapper_CompositeExplicitAutograd_out_fft_rfftfreq_out(n, d, out);
}
at::Tensor & fft_rfftfreq_outf(int64_t n, double d, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_fft_rfftfreq_out(n, d, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd__linalg_lstsq(const at::Tensor & self, const at::Tensor & b, ::std::optional<double> rcond, ::std::optional<c10::string_view> driver) {
    // No device check
  // DeviceGuard omitted
  return at::native::linalg_lstsq(self, b, rcond, driver);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linalg_lstsq",
TORCH_FN(wrapper_CompositeExplicitAutograd__linalg_lstsq));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> linalg_lstsq(const at::Tensor & self, const at::Tensor & b, ::std::optional<double> rcond, ::std::optional<c10::string_view> driver) {
return wrapper_CompositeExplicitAutograd__linalg_lstsq(self, b, rcond, driver);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_linalg_matrix_exp_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linalg_matrix_exp_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linalg_matrix_exp.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_linalg_matrix_exp_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & linalg_matrix_exp_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_linalg_matrix_exp_out(self, out);
}
at::Tensor & linalg_matrix_exp_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_linalg_matrix_exp_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_atol_rtol_tensor_out_linalg_pinv_out(const at::Tensor & self, const ::std::optional<at::Tensor> & atol, const ::std::optional<at::Tensor> & rtol, bool hermitian, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::linalg_pinv_out(self, atol, rtol, hermitian, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("linalg_pinv.atol_rtol_tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_atol_rtol_tensor_out_linalg_pinv_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & linalg_pinv_out(at::Tensor & out, const at::Tensor & self, const ::std::optional<at::Tensor> & atol, const ::std::optional<at::Tensor> & rtol, bool hermitian) {
return wrapper_CompositeExplicitAutograd_atol_rtol_tensor_out_linalg_pinv_out(self, atol, rtol, hermitian, out);
}
at::Tensor & linalg_pinv_outf(const at::Tensor & self, const ::std::optional<at::Tensor> & atol, const ::std::optional<at::Tensor> & rtol, bool hermitian, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_atol_rtol_tensor_out_linalg_pinv_out(self, atol, rtol, hermitian, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___test_parallel_materialize(const at::Tensor & self, int64_t num_parallel, bool skip_first) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_parallel_materialize(self, num_parallel, skip_first);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_parallel_materialize",
TORCH_FN(wrapper_CompositeExplicitAutograd___test_parallel_materialize));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _test_parallel_materialize(const at::Tensor & self, int64_t num_parallel, bool skip_first) {
return wrapper_CompositeExplicitAutograd___test_parallel_materialize(self, num_parallel, skip_first);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_optional_intlist_out(const at::Tensor & values, at::OptionalIntArrayRef addends, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_optional_intlist_out(values, addends, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_optional_intlist.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_optional_intlist_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _test_optional_intlist_out(at::Tensor & out, const at::Tensor & values, at::OptionalIntArrayRef addends) {
return wrapper_CompositeExplicitAutograd_out__test_optional_intlist_out(values, addends, out);
}
at::Tensor & _test_optional_intlist_outf(const at::Tensor & values, at::OptionalIntArrayRef addends, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_optional_intlist_out(values, addends, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_optional_filled_intlist_out(const at::Tensor & values, at::OptionalIntArrayRef addends, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_optional_filled_intlist_out(values, addends, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_optional_filled_intlist.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_optional_filled_intlist_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _test_optional_filled_intlist_out(at::Tensor & out, const at::Tensor & values, at::OptionalIntArrayRef addends) {
return wrapper_CompositeExplicitAutograd_out__test_optional_filled_intlist_out(values, addends, out);
}
at::Tensor & _test_optional_filled_intlist_outf(const at::Tensor & values, at::OptionalIntArrayRef addends, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_optional_filled_intlist_out(values, addends, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_optional_floatlist_out(const at::Tensor & values, ::std::optional<at::ArrayRef<double>> addends, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_optional_floatlist_out(values, addends, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_optional_floatlist.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_optional_floatlist_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _test_optional_floatlist_out(at::Tensor & out, const at::Tensor & values, ::std::optional<at::ArrayRef<double>> addends) {
return wrapper_CompositeExplicitAutograd_out__test_optional_floatlist_out(values, addends, out);
}
at::Tensor & _test_optional_floatlist_outf(const at::Tensor & values, ::std::optional<at::ArrayRef<double>> addends, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_optional_floatlist_out(values, addends, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___test_warn_in_autograd(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_warn_in_autograd(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_warn_in_autograd_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_warn_in_autograd_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_warn_in_autograd",
TORCH_FN(wrapper_CompositeExplicitAutograd___test_warn_in_autograd));
m.impl("_test_warn_in_autograd.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_warn_in_autograd_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _test_warn_in_autograd(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___test_warn_in_autograd(self);
}
at::Tensor & _test_warn_in_autograd_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__test_warn_in_autograd_out(self, out);
}
at::Tensor & _test_warn_in_autograd_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_warn_in_autograd_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_fullcoverage__test_autograd_multiple_dispatch(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_autograd_multiple_dispatch_fullcoverage(self);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_fullcoverage_out__test_autograd_multiple_dispatch_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_autograd_multiple_dispatch_fullcoverage_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_autograd_multiple_dispatch.fullcoverage",
TORCH_FN(wrapper_CompositeExplicitAutograd_fullcoverage__test_autograd_multiple_dispatch));
m.impl("_test_autograd_multiple_dispatch.fullcoverage_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_fullcoverage_out__test_autograd_multiple_dispatch_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _test_autograd_multiple_dispatch(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_fullcoverage__test_autograd_multiple_dispatch(self);
}
at::Tensor & _test_autograd_multiple_dispatch_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_fullcoverage_out__test_autograd_multiple_dispatch_out(self, out);
}
at::Tensor & _test_autograd_multiple_dispatch_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_fullcoverage_out__test_autograd_multiple_dispatch_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___test_autograd_multiple_dispatch_view(const at::Tensor & self) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_autograd_multiple_dispatch_view(self);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_autograd_multiple_dispatch_view",
TORCH_FN(wrapper_CompositeExplicitAutograd___test_autograd_multiple_dispatch_view));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _test_autograd_multiple_dispatch_view(const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd___test_autograd_multiple_dispatch_view(self);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__test_autograd_multiple_dispatch_view_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_test_autograd_multiple_dispatch_view_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_test_autograd_multiple_dispatch_view_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__test_autograd_multiple_dispatch_view_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _test_autograd_multiple_dispatch_view_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__test_autograd_multiple_dispatch_view_copy_out(self, out);
}
at::Tensor & _test_autograd_multiple_dispatch_view_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__test_autograd_multiple_dispatch_view_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_segment_reduce_out(const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & indices, const ::std::optional<at::Tensor> & offsets, int64_t axis, bool unsafe, const ::std::optional<at::Scalar> & initial, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::segment_reduce_out(data, reduce, lengths, indices, offsets, axis, unsafe, initial, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("segment_reduce.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_segment_reduce_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & segment_reduce_out(at::Tensor & out, const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & indices, const ::std::optional<at::Tensor> & offsets, int64_t axis, bool unsafe, const ::std::optional<at::Scalar> & initial) {
return wrapper_CompositeExplicitAutograd_out_segment_reduce_out(data, reduce, lengths, indices, offsets, axis, unsafe, initial, out);
}
at::Tensor & segment_reduce_outf(const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & indices, const ::std::optional<at::Tensor> & offsets, int64_t axis, bool unsafe, const ::std::optional<at::Scalar> & initial, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_segment_reduce_out(data, reduce, lengths, indices, offsets, axis, unsafe, initial, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__segment_reduce_backward_out(const at::Tensor & grad, const at::Tensor & output, const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & offsets, int64_t axis, const ::std::optional<at::Scalar> & initial, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_segment_reduce_backward_out(grad, output, data, reduce, lengths, offsets, axis, initial, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_segment_reduce_backward.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__segment_reduce_backward_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _segment_reduce_backward_out(at::Tensor & out, const at::Tensor & grad, const at::Tensor & output, const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & offsets, int64_t axis, const ::std::optional<at::Scalar> & initial) {
return wrapper_CompositeExplicitAutograd_out__segment_reduce_backward_out(grad, output, data, reduce, lengths, offsets, axis, initial, out);
}
at::Tensor & _segment_reduce_backward_outf(const at::Tensor & grad, const at::Tensor & output, const at::Tensor & data, c10::string_view reduce, const ::std::optional<at::Tensor> & lengths, const ::std::optional<at::Tensor> & offsets, int64_t axis, const ::std::optional<at::Scalar> & initial, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__segment_reduce_backward_out(grad, output, data, reduce, lengths, offsets, axis, initial, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___nested_tensor_from_tensor_list(at::TensorList list, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_from_tensor_list(list, dtype, layout, device, pin_memory);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__nested_tensor_from_tensor_list_out(at::TensorList list, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_nested_tensor_from_tensor_list_out(list, dtype, layout, device, pin_memory, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_nested_tensor_from_tensor_list",
TORCH_FN(wrapper_CompositeExplicitAutograd___nested_tensor_from_tensor_list));
m.impl("_nested_tensor_from_tensor_list.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__nested_tensor_from_tensor_list_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _nested_tensor_from_tensor_list(at::TensorList list, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd___nested_tensor_from_tensor_list(list, dtype, layout, device, pin_memory);
}
at::Tensor & _nested_tensor_from_tensor_list_out(at::Tensor & out, at::TensorList list, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_from_tensor_list_out(list, dtype, layout, device, pin_memory, out);
}
at::Tensor & _nested_tensor_from_tensor_list_outf(at::TensorList list, ::std::optional<at::ScalarType> dtype, ::std::optional<at::Layout> layout, ::std::optional<at::Device> device, ::std::optional<bool> pin_memory, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__nested_tensor_from_tensor_list_out(list, dtype, layout, device, pin_memory, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__fw_primal_copy_out(const at::Tensor & self, int64_t level, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fw_primal_copy_out(self, level, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fw_primal_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fw_primal_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _fw_primal_copy_out(at::Tensor & out, const at::Tensor & self, int64_t level) {
return wrapper_CompositeExplicitAutograd_out__fw_primal_copy_out(self, level, out);
}
at::Tensor & _fw_primal_copy_outf(const at::Tensor & self, int64_t level, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__fw_primal_copy_out(self, level, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__make_dual_copy_out(const at::Tensor & primal, const at::Tensor & tangent, int64_t level, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_make_dual_copy_out(primal, tangent, level, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_make_dual_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__make_dual_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _make_dual_copy_out(at::Tensor & out, const at::Tensor & primal, const at::Tensor & tangent, int64_t level) {
return wrapper_CompositeExplicitAutograd_out__make_dual_copy_out(primal, tangent, level, out);
}
at::Tensor & _make_dual_copy_outf(const at::Tensor & primal, const at::Tensor & tangent, int64_t level, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__make_dual_copy_out(primal, tangent, level, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_view_as_real_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::view_as_real_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("view_as_real_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_view_as_real_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & view_as_real_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_view_as_real_copy_out(self, out);
}
at::Tensor & view_as_real_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_view_as_real_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_view_as_complex_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::view_as_complex_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("view_as_complex_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_view_as_complex_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & view_as_complex_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_view_as_complex_copy_out(self, out);
}
at::Tensor & view_as_complex_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_view_as_complex_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__conj_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_conj_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_conj_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__conj_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _conj_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__conj_copy_out(self, out);
}
at::Tensor & _conj_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__conj_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__neg_view_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_neg_view_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_neg_view_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__neg_view_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _neg_view_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__neg_view_copy_out(self, out);
}
at::Tensor & _neg_view_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__neg_view_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_as_strided_copy_out(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::as_strided_copy_out_symint(self, size, stride, storage_offset, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("as_strided_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_as_strided_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & as_strided_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, ::std::optional<int64_t> storage_offset) {
return wrapper_CompositeExplicitAutograd_out_as_strided_copy_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? ::std::make_optional(c10::SymInt(*storage_offset)) : ::std::nullopt, out);
}
at::Tensor & as_strided_copy_outf(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, ::std::optional<int64_t> storage_offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_as_strided_copy_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? ::std::make_optional(c10::SymInt(*storage_offset)) : ::std::nullopt, out);
}
at::Tensor & as_strided_copy_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset) {
return wrapper_CompositeExplicitAutograd_out_as_strided_copy_out(self, size, stride, storage_offset, out);
}
at::Tensor & as_strided_copy_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, ::std::optional<c10::SymInt> storage_offset, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_as_strided_copy_out(self, size, stride, storage_offset, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__sparse_broadcast_to_copy_out(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_sparse_broadcast_to_copy_out(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_sparse_broadcast_to_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__sparse_broadcast_to_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _sparse_broadcast_to_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out__sparse_broadcast_to_copy_out(self, size, out);
}
at::Tensor & _sparse_broadcast_to_copy_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__sparse_broadcast_to_copy_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_diagonal_copy_out(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::diagonal_copy_out(self, offset, dim1, dim2, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("diagonal_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_diagonal_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & diagonal_copy_out(at::Tensor & out, const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2) {
return wrapper_CompositeExplicitAutograd_out_diagonal_copy_out(self, offset, dim1, dim2, out);
}
at::Tensor & diagonal_copy_outf(const at::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_diagonal_copy_out(self, offset, dim1, dim2, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_expand_copy_out(const at::Tensor & self, c10::SymIntArrayRef size, bool implicit, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::expand_copy_out_symint(self, size, implicit, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("expand_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_expand_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & expand_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, bool implicit) {
return wrapper_CompositeExplicitAutograd_out_expand_copy_out(self, c10::fromIntArrayRefSlow(size), implicit, out);
}
at::Tensor & expand_copy_outf(const at::Tensor & self, at::IntArrayRef size, bool implicit, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_expand_copy_out(self, c10::fromIntArrayRefSlow(size), implicit, out);
}
at::Tensor & expand_copy_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, bool implicit) {
return wrapper_CompositeExplicitAutograd_out_expand_copy_out(self, size, implicit, out);
}
at::Tensor & expand_copy_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, bool implicit, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_expand_copy_out(self, size, implicit, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_permute_copy_out(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::permute_copy_out(self, dims, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("permute_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_permute_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & permute_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dims) {
return wrapper_CompositeExplicitAutograd_out_permute_copy_out(self, dims, out);
}
at::Tensor & permute_copy_outf(const at::Tensor & self, at::IntArrayRef dims, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_permute_copy_out(self, dims, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_reshape_alias_copy_out_symint(self, size, stride, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_reshape_alias_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _reshape_alias_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & _reshape_alias_copy_outf(const at::Tensor & self, at::IntArrayRef size, at::IntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out(self, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), out);
}
at::Tensor & _reshape_alias_copy_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride) {
return wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out(self, size, stride, out);
}
at::Tensor & _reshape_alias_copy_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__reshape_alias_copy_out(self, size, stride, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_out_select_copy_out(const at::Tensor & self, int64_t dim, c10::SymInt index, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::select_copy_int_out_symint(self, dim, index, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("select_copy.int_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_out_select_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & select_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim, int64_t index) {
return wrapper_CompositeExplicitAutograd_int_out_select_copy_out(self, dim, index, out);
}
at::Tensor & select_copy_outf(const at::Tensor & self, int64_t dim, int64_t index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_out_select_copy_out(self, dim, index, out);
}
at::Tensor & select_copy_symint_out(at::Tensor & out, const at::Tensor & self, int64_t dim, c10::SymInt index) {
return wrapper_CompositeExplicitAutograd_int_out_select_copy_out(self, dim, index, out);
}
at::Tensor & select_copy_symint_outf(const at::Tensor & self, int64_t dim, c10::SymInt index, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_out_select_copy_out(self, dim, index, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_detach_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::detach_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("detach_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_detach_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & detach_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_detach_copy_out(self, out);
}
at::Tensor & detach_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_detach_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out(const at::Tensor & self, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::slice_copy_Tensor_out_symint(self, dim, start, end, step, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("slice_copy.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & slice_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step) {
return wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out(self, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step, out);
}
at::Tensor & slice_copy_outf(const at::Tensor & self, int64_t dim, ::std::optional<int64_t> start, ::std::optional<int64_t> end, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out(self, dim, start.has_value() ? ::std::make_optional(c10::SymInt(*start)) : ::std::nullopt, end.has_value() ? ::std::make_optional(c10::SymInt(*end)) : ::std::nullopt, step, out);
}
at::Tensor & slice_copy_symint_out(at::Tensor & out, const at::Tensor & self, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step) {
return wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out(self, dim, start, end, step, out);
}
at::Tensor & slice_copy_symint_outf(const at::Tensor & self, int64_t dim, ::std::optional<c10::SymInt> start, ::std::optional<c10::SymInt> end, c10::SymInt step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_slice_copy_out(self, dim, start, end, step, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out(const at::Tensor & self, c10::SymInt split_size, int64_t dim, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::split_copy_Tensor_out(self, split_size.guard_int(__FILE__, __LINE__), dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("split_copy.Tensor_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void split_copy_out(at::TensorList out, const at::Tensor & self, int64_t split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out(self, split_size, dim, out);
}
void split_copy_outf(const at::Tensor & self, int64_t split_size, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out(self, split_size, dim, out);
}
void split_copy_symint_out(at::TensorList out, const at::Tensor & self, c10::SymInt split_size, int64_t dim) {
return wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out(self, split_size, dim, out);
}
void split_copy_symint_outf(const at::Tensor & self, c10::SymInt split_size, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_Tensor_out_split_copy_out(self, split_size, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::split_with_sizes_copy_out(self, C10_AS_INTARRAYREF_SLOW(split_sizes), dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("split_with_sizes_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void split_with_sizes_copy_out(at::TensorList out, const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out(self, c10::fromIntArrayRefSlow(split_sizes), dim, out);
}
void split_with_sizes_copy_outf(const at::Tensor & self, at::IntArrayRef split_sizes, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out(self, c10::fromIntArrayRefSlow(split_sizes), dim, out);
}
void split_with_sizes_copy_symint_out(at::TensorList out, const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out(self, split_sizes, dim, out);
}
void split_with_sizes_copy_symint_outf(const at::Tensor & self, c10::SymIntArrayRef split_sizes, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out_split_with_sizes_copy_out(self, split_sizes, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_squeeze_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_squeeze_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_squeeze_copy_out(self, out);
}
at::Tensor & squeeze_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_squeeze_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dim_out_squeeze_copy_out(const at::Tensor & self, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_copy_dim_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_copy.dim_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dim_out_squeeze_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_dim_out_squeeze_copy_out(self, dim, out);
}
at::Tensor & squeeze_copy_outf(const at::Tensor & self, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dim_out_squeeze_copy_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dims_out_squeeze_copy_out(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::squeeze_copy_dims_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("squeeze_copy.dims_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dims_out_squeeze_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & squeeze_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef dim) {
return wrapper_CompositeExplicitAutograd_dims_out_squeeze_copy_out(self, dim, out);
}
at::Tensor & squeeze_copy_outf(const at::Tensor & self, at::IntArrayRef dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dims_out_squeeze_copy_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_t_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::t_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("t_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_t_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & t_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_t_copy_out(self, out);
}
at::Tensor & t_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_t_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_int_out_transpose_copy_out(const at::Tensor & self, int64_t dim0, int64_t dim1, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::transpose_copy_int_out(self, dim0, dim1, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("transpose_copy.int_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_out_transpose_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & transpose_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim0, int64_t dim1) {
return wrapper_CompositeExplicitAutograd_int_out_transpose_copy_out(self, dim0, dim1, out);
}
at::Tensor & transpose_copy_outf(const at::Tensor & self, int64_t dim0, int64_t dim1, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_int_out_transpose_copy_out(self, dim0, dim1, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_unsqueeze_copy_out(const at::Tensor & self, int64_t dim, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unsqueeze_copy_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unsqueeze_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unsqueeze_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & unsqueeze_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_out_unsqueeze_copy_out(self, dim, out);
}
at::Tensor & unsqueeze_copy_outf(const at::Tensor & self, int64_t dim, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_unsqueeze_copy_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__indices_copy_out(self, out);
}
at::Tensor & _indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__values_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_values_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_values_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__values_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _values_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out__values_copy_out(self, out);
}
at::Tensor & _values_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__values_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_indices_copy_out(self, out);
}
at::Tensor & indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_values_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::values_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("values_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_values_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & values_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_values_copy_out(self, out);
}
at::Tensor & values_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_values_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_crow_indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::crow_indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("crow_indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_crow_indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & crow_indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_crow_indices_copy_out(self, out);
}
at::Tensor & crow_indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_crow_indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_col_indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::col_indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("col_indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_col_indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & col_indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_col_indices_copy_out(self, out);
}
at::Tensor & col_indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_col_indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_ccol_indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::ccol_indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("ccol_indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_ccol_indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & ccol_indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_ccol_indices_copy_out(self, out);
}
at::Tensor & ccol_indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_ccol_indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_row_indices_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::row_indices_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("row_indices_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_row_indices_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & row_indices_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_row_indices_copy_out(self, out);
}
at::Tensor & row_indices_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_row_indices_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
void wrapper_CompositeExplicitAutograd_int_out_unbind_copy_out(const at::Tensor & self, int64_t dim, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unbind_copy_int_out(self, dim, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unbind_copy.int_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_int_out_unbind_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
void unbind_copy_out(at::TensorList out, const at::Tensor & self, int64_t dim) {
return wrapper_CompositeExplicitAutograd_int_out_unbind_copy_out(self, dim, out);
}
void unbind_copy_outf(const at::Tensor & self, int64_t dim, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_int_out_unbind_copy_out(self, dim, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_view_copy_out(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::view_copy_out_symint(self, size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("view_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_view_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & view_copy_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_view_copy_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & view_copy_outf(const at::Tensor & self, at::IntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_view_copy_out(self, c10::fromIntArrayRefSlow(size), out);
}
at::Tensor & view_copy_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef size) {
return wrapper_CompositeExplicitAutograd_out_view_copy_out(self, size, out);
}
at::Tensor & view_copy_symint_outf(const at::Tensor & self, c10::SymIntArrayRef size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_view_copy_out(self, size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_dtype_out_view_copy_out(const at::Tensor & self, at::ScalarType dtype, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::view_copy_dtype_out(self, dtype, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("view_copy.dtype_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_dtype_out_view_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & view_copy_out(at::Tensor & out, const at::Tensor & self, at::ScalarType dtype) {
return wrapper_CompositeExplicitAutograd_dtype_out_view_copy_out(self, dtype, out);
}
at::Tensor & view_copy_outf(const at::Tensor & self, at::ScalarType dtype, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_dtype_out_view_copy_out(self, dtype, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_unfold_copy_out(const at::Tensor & self, int64_t dimension, int64_t size, int64_t step, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::unfold_copy_out(self, dimension, size, step, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("unfold_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_unfold_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & unfold_copy_out(at::Tensor & out, const at::Tensor & self, int64_t dimension, int64_t size, int64_t step) {
return wrapper_CompositeExplicitAutograd_out_unfold_copy_out(self, dimension, size, step, out);
}
at::Tensor & unfold_copy_outf(const at::Tensor & self, int64_t dimension, int64_t size, int64_t step, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_unfold_copy_out(self, dimension, size, step, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_alias_copy_out(const at::Tensor & self, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::alias_copy_out(self, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("alias_copy.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_alias_copy_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & alias_copy_out(at::Tensor & out, const at::Tensor & self) {
return wrapper_CompositeExplicitAutograd_out_alias_copy_out(self, out);
}
at::Tensor & alias_copy_outf(const at::Tensor & self, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_alias_copy_out(self, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out(const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::to_padded_tensor_out_symint(self, padding, output_size, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("to_padded_tensor.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & to_padded_tensor_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out(self, padding, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, out);
}
at::Tensor & to_padded_tensor_outf(const at::Tensor & self, double padding, at::OptionalIntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out(self, padding, output_size.has_value() ? ::std::make_optional(c10::fromIntArrayRefSlow(*output_size)) : ::std::nullopt, out);
}
at::Tensor & to_padded_tensor_symint_out(at::Tensor & out, const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size) {
return wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out(self, padding, output_size, out);
}
at::Tensor & to_padded_tensor_symint_outf(const at::Tensor & self, double padding, at::OptionalSymIntArrayRef output_size, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out_to_padded_tensor_out(self, padding, output_size, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd___safe_softmax(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype) {
    // No device check
  // DeviceGuard omitted
  return at::native::_safe_softmax(self, dim, dtype);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_safe_softmax",
TORCH_FN(wrapper_CompositeExplicitAutograd___safe_softmax));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor _safe_softmax(const at::Tensor & self, int64_t dim, ::std::optional<at::ScalarType> dtype) {
return wrapper_CompositeExplicitAutograd___safe_softmax(self, dim, dtype);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__transformer_encoder_layer_fwd_out(const at::Tensor & src, int64_t embed_dim, int64_t num_heads, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, bool use_gelu, bool norm_first, double eps, const at::Tensor & norm_weight_1, const at::Tensor & norm_bias_1, const at::Tensor & norm_weight_2, const at::Tensor & norm_bias_2, const at::Tensor & ffn_weight_1, const at::Tensor & ffn_bias_1, const at::Tensor & ffn_weight_2, const at::Tensor & ffn_bias_2, const ::std::optional<at::Tensor> & mask, ::std::optional<int64_t> mask_type, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_transformer_encoder_layer_fwd_out(src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask, mask_type, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_transformer_encoder_layer_fwd.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__transformer_encoder_layer_fwd_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _transformer_encoder_layer_fwd_out(at::Tensor & out, const at::Tensor & src, int64_t embed_dim, int64_t num_heads, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, bool use_gelu, bool norm_first, double eps, const at::Tensor & norm_weight_1, const at::Tensor & norm_bias_1, const at::Tensor & norm_weight_2, const at::Tensor & norm_bias_2, const at::Tensor & ffn_weight_1, const at::Tensor & ffn_bias_1, const at::Tensor & ffn_weight_2, const at::Tensor & ffn_bias_2, const ::std::optional<at::Tensor> & mask, ::std::optional<int64_t> mask_type) {
return wrapper_CompositeExplicitAutograd_out__transformer_encoder_layer_fwd_out(src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask, mask_type, out);
}
at::Tensor & _transformer_encoder_layer_fwd_outf(const at::Tensor & src, int64_t embed_dim, int64_t num_heads, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, bool use_gelu, bool norm_first, double eps, const at::Tensor & norm_weight_1, const at::Tensor & norm_bias_1, const at::Tensor & norm_weight_2, const at::Tensor & norm_bias_2, const at::Tensor & ffn_weight_1, const at::Tensor & ffn_bias_1, const at::Tensor & ffn_weight_2, const at::Tensor & ffn_bias_2, const ::std::optional<at::Tensor> & mask, ::std::optional<int64_t> mask_type, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__transformer_encoder_layer_fwd_out(src, embed_dim, num_heads, qkv_weight, qkv_bias, proj_weight, proj_bias, use_gelu, norm_first, eps, norm_weight_1, norm_bias_1, norm_weight_2, norm_bias_2, ffn_weight_1, ffn_bias_1, ffn_weight_2, ffn_bias_2, mask, mask_type, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor &,at::Tensor &> wrapper_CompositeExplicitAutograd_out__native_multi_head_attention_out(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask, bool need_weights, bool average_attn_weights, ::std::optional<int64_t> mask_type, at::Tensor & out0, at::Tensor & out1) {
    // No device check
  // DeviceGuard omitted
  return at::native::_native_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, need_weights, average_attn_weights, mask_type, out0, out1);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_native_multi_head_attention.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__native_multi_head_attention_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor &,at::Tensor &> _native_multi_head_attention_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask, bool need_weights, bool average_attn_weights, ::std::optional<int64_t> mask_type) {
return wrapper_CompositeExplicitAutograd_out__native_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, need_weights, average_attn_weights, mask_type, out0, out1);
}
::std::tuple<at::Tensor &,at::Tensor &> _native_multi_head_attention_outf(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask, bool need_weights, bool average_attn_weights, ::std::optional<int64_t> mask_type, at::Tensor & out0, at::Tensor & out1) {
return wrapper_CompositeExplicitAutograd_out__native_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, need_weights, average_attn_weights, mask_type, out0, out1);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,c10::SymInt,c10::SymInt,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional<at::Tensor> & attn_bias, double dropout_p, bool is_causal, bool return_debug_mask, ::std::optional<double> scale) {
    // No device check
  // DeviceGuard omitted
  return at::native::_scaled_dot_product_fused_attention_overrideable(query, key, value, attn_bias, dropout_p, is_causal, return_debug_mask, scale);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_scaled_dot_product_fused_attention_overrideable",
TORCH_FN(wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor,c10::SymInt,c10::SymInt,at::Tensor,at::Tensor,at::Tensor> _scaled_dot_product_fused_attention_overrideable(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const ::std::optional<at::Tensor> & attn_bias, double dropout_p, bool is_causal, bool return_debug_mask, ::std::optional<double> scale) {
return wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable(query, key, value, attn_bias, dropout_p, is_causal, return_debug_mask, scale);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable_backward(const at::Tensor & grad_out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const at::Tensor & attn_bias, ::std::array<bool,4> grad_input_mask, const at::Tensor & out, const at::Tensor & logsumexp, const at::Tensor & cum_seq_q, const at::Tensor & cum_seq_k, c10::SymInt max_q, c10::SymInt max_k, double dropout_p, bool is_causal, const at::Tensor & philox_seed, const at::Tensor & philox_offset, ::std::optional<double> scale) {
    // No device check
  // DeviceGuard omitted
  return at::native::_scaled_dot_product_fused_attention_overrideable_backward(grad_out, query, key, value, attn_bias, grad_input_mask, out, logsumexp, cum_seq_q, cum_seq_k, max_q.guard_int(__FILE__, __LINE__), max_k.guard_int(__FILE__, __LINE__), dropout_p, is_causal, philox_seed, philox_offset, scale);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_scaled_dot_product_fused_attention_overrideable_backward",
TORCH_FN(wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable_backward));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> _scaled_dot_product_fused_attention_overrideable_backward(const at::Tensor & grad_out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const at::Tensor & attn_bias, ::std::array<bool,4> grad_input_mask, const at::Tensor & out, const at::Tensor & logsumexp, const at::Tensor & cum_seq_q, const at::Tensor & cum_seq_k, int64_t max_q, int64_t max_k, double dropout_p, bool is_causal, const at::Tensor & philox_seed, const at::Tensor & philox_offset, ::std::optional<double> scale) {
return wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable_backward(grad_out, query, key, value, attn_bias, grad_input_mask, out, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, philox_seed, philox_offset, scale);
}
::std::tuple<at::Tensor,at::Tensor,at::Tensor,at::Tensor> _scaled_dot_product_fused_attention_overrideable_backward_symint(const at::Tensor & grad_out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, const at::Tensor & attn_bias, ::std::array<bool,4> grad_input_mask, const at::Tensor & out, const at::Tensor & logsumexp, const at::Tensor & cum_seq_q, const at::Tensor & cum_seq_k, c10::SymInt max_q, c10::SymInt max_k, double dropout_p, bool is_causal, const at::Tensor & philox_seed, const at::Tensor & philox_offset, ::std::optional<double> scale) {
return wrapper_CompositeExplicitAutograd___scaled_dot_product_fused_attention_overrideable_backward(grad_out, query, key, value, attn_bias, grad_input_mask, out, logsumexp, cum_seq_q, cum_seq_k, max_q, max_k, dropout_p, is_causal, philox_seed, philox_offset, scale);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__triton_scaled_dot_attention_out(const at::Tensor & q, const at::Tensor & k, const at::Tensor & v, double dropout_p, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_triton_scaled_dot_attention_out(q, k, v, dropout_p, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_triton_scaled_dot_attention.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__triton_scaled_dot_attention_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _triton_scaled_dot_attention_out(at::Tensor & out, const at::Tensor & q, const at::Tensor & k, const at::Tensor & v, double dropout_p) {
return wrapper_CompositeExplicitAutograd_out__triton_scaled_dot_attention_out(q, k, v, dropout_p, out);
}
at::Tensor & _triton_scaled_dot_attention_outf(const at::Tensor & q, const at::Tensor & k, const at::Tensor & v, double dropout_p, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__triton_scaled_dot_attention_out(q, k, v, dropout_p, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__triton_multi_head_attention_out(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_triton_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_triton_multi_head_attention.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__triton_multi_head_attention_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _triton_multi_head_attention_out(at::Tensor & out, const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask) {
return wrapper_CompositeExplicitAutograd_out__triton_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, out);
}
at::Tensor & _triton_multi_head_attention_outf(const at::Tensor & query, const at::Tensor & key, const at::Tensor & value, int64_t embed_dim, int64_t num_head, const at::Tensor & qkv_weight, const at::Tensor & qkv_bias, const at::Tensor & proj_weight, const at::Tensor & proj_bias, const ::std::optional<at::Tensor> & mask, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__triton_multi_head_attention_out(query, key, value, embed_dim, num_head, qkv_weight, qkv_bias, proj_weight, proj_bias, mask, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_t(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_t(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_t_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_t_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_t.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_t));
m.impl("special_chebyshev_polynomial_t.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_t_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_t(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_t(x, n);
}
at::Tensor & special_chebyshev_polynomial_t_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_t_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_t_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_t_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_t(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_t(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_t_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_t_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_t.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_t));
m.impl("special_chebyshev_polynomial_t.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_t_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_t(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_t(x, n);
}
at::Tensor & special_chebyshev_polynomial_t_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_t_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_t_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_t_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_u(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_u_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_u_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_u.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_u));
m.impl("special_chebyshev_polynomial_u.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_u_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_u(x, n);
}
at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_u_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_u_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_u_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_u(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_u_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_u_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_u.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_u));
m.impl("special_chebyshev_polynomial_u.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_u_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_u(x, n);
}
at::Tensor & special_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_u_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_u_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_v(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_v(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_v_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_v_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_v.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_v));
m.impl("special_chebyshev_polynomial_v.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_v_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_v(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_v(x, n);
}
at::Tensor & special_chebyshev_polynomial_v_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_v_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_v_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_v_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_v(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_v(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_v_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_v_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_v.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_v));
m.impl("special_chebyshev_polynomial_v.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_v_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_v(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_v(x, n);
}
at::Tensor & special_chebyshev_polynomial_v_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_v_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_v_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_v_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_w(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_w(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_w_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_w_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_w.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_w));
m.impl("special_chebyshev_polynomial_w.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_w_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_w(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_chebyshev_polynomial_w(x, n);
}
at::Tensor & special_chebyshev_polynomial_w_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_w_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_w_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_chebyshev_polynomial_w_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_w(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_w(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_w_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_chebyshev_polynomial_w_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_chebyshev_polynomial_w.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_w));
m.impl("special_chebyshev_polynomial_w.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_w_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_chebyshev_polynomial_w(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_chebyshev_polynomial_w(x, n);
}
at::Tensor & special_chebyshev_polynomial_w_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_w_out(x, n, out);
}
at::Tensor & special_chebyshev_polynomial_w_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_chebyshev_polynomial_w_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_h(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_h(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_h_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_h_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_hermite_polynomial_h.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_h));
m.impl("special_hermite_polynomial_h.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_h_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_hermite_polynomial_h(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_h(x, n);
}
at::Tensor & special_hermite_polynomial_h_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_h_out(x, n, out);
}
at::Tensor & special_hermite_polynomial_h_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_h_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_h(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_h(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_h_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_h_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_hermite_polynomial_h.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_h));
m.impl("special_hermite_polynomial_h.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_h_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_hermite_polynomial_h(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_h(x, n);
}
at::Tensor & special_hermite_polynomial_h_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_h_out(x, n, out);
}
at::Tensor & special_hermite_polynomial_h_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_h_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_he(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_he(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_he_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_he_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_hermite_polynomial_he.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_he));
m.impl("special_hermite_polynomial_he.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_he_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_hermite_polynomial_he(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_hermite_polynomial_he(x, n);
}
at::Tensor & special_hermite_polynomial_he_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_he_out(x, n, out);
}
at::Tensor & special_hermite_polynomial_he_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_hermite_polynomial_he_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_he(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_he(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_he_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_hermite_polynomial_he_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_hermite_polynomial_he.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_he));
m.impl("special_hermite_polynomial_he.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_he_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_hermite_polynomial_he(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_hermite_polynomial_he(x, n);
}
at::Tensor & special_hermite_polynomial_he_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_he_out(x, n, out);
}
at::Tensor & special_hermite_polynomial_he_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_hermite_polynomial_he_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_laguerre_polynomial_l(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_laguerre_polynomial_l(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_laguerre_polynomial_l_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_laguerre_polynomial_l_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_laguerre_polynomial_l.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_laguerre_polynomial_l));
m.impl("special_laguerre_polynomial_l.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_laguerre_polynomial_l_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_laguerre_polynomial_l(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_laguerre_polynomial_l(x, n);
}
at::Tensor & special_laguerre_polynomial_l_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_laguerre_polynomial_l_out(x, n, out);
}
at::Tensor & special_laguerre_polynomial_l_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_laguerre_polynomial_l_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_laguerre_polynomial_l(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_laguerre_polynomial_l(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_laguerre_polynomial_l_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_laguerre_polynomial_l_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_laguerre_polynomial_l.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_laguerre_polynomial_l));
m.impl("special_laguerre_polynomial_l.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_laguerre_polynomial_l_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_laguerre_polynomial_l(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_laguerre_polynomial_l(x, n);
}
at::Tensor & special_laguerre_polynomial_l_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_laguerre_polynomial_l_out(x, n, out);
}
at::Tensor & special_laguerre_polynomial_l_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_laguerre_polynomial_l_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_legendre_polynomial_p(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_legendre_polynomial_p(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_legendre_polynomial_p_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_legendre_polynomial_p_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_legendre_polynomial_p.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_legendre_polynomial_p));
m.impl("special_legendre_polynomial_p.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_legendre_polynomial_p_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_legendre_polynomial_p(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_legendre_polynomial_p(x, n);
}
at::Tensor & special_legendre_polynomial_p_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_legendre_polynomial_p_out(x, n, out);
}
at::Tensor & special_legendre_polynomial_p_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_legendre_polynomial_p_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_legendre_polynomial_p(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_legendre_polynomial_p(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_legendre_polynomial_p_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_legendre_polynomial_p_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_legendre_polynomial_p.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_legendre_polynomial_p));
m.impl("special_legendre_polynomial_p.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_legendre_polynomial_p_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_legendre_polynomial_p(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_legendre_polynomial_p(x, n);
}
at::Tensor & special_legendre_polynomial_p_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_legendre_polynomial_p_out(x, n, out);
}
at::Tensor & special_legendre_polynomial_p_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_legendre_polynomial_p_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_t(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_t(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_t_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_t.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_t));
m.impl("special_shifted_chebyshev_polynomial_t.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_t_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_t(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_t(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_t_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_t_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_t(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_t(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_t_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_t.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_t));
m.impl("special_shifted_chebyshev_polynomial_t.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_t_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_t(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_t(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_t_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_t_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_t_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_u(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_u_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_u.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_u));
m.impl("special_shifted_chebyshev_polynomial_u.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_u_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_u(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_u(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_u_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_u_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_u(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_u_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_u.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_u));
m.impl("special_shifted_chebyshev_polynomial_u.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_u_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_u(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_u(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_u_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_u_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_u_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_v(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_v(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_v_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_v.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_v));
m.impl("special_shifted_chebyshev_polynomial_v.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_v_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_v(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_v(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_v_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_v_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_v(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_v(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_v_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_v.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_v));
m.impl("special_shifted_chebyshev_polynomial_v.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_v_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_v(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_v(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_v_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_v_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_v_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_w(const at::Scalar & x, const at::Tensor & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_w(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_w_out(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_w.x_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_w));
m.impl("special_shifted_chebyshev_polynomial_w.x_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_w_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_w(const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_special_shifted_chebyshev_polynomial_w(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_w_out(at::Tensor & out, const at::Scalar & x, const at::Tensor & n) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_w_outf(const at::Scalar & x, const at::Tensor & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_x_scalar_out_special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_w(const at::Tensor & x, const at::Scalar & n) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_w(x, n);
}
} // anonymous namespace
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_w_out(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("special_shifted_chebyshev_polynomial_w.n_scalar",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_w));
m.impl("special_shifted_chebyshev_polynomial_w.n_scalar_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_w_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor special_shifted_chebyshev_polynomial_w(const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_special_shifted_chebyshev_polynomial_w(x, n);
}
at::Tensor & special_shifted_chebyshev_polynomial_w_out(at::Tensor & out, const at::Tensor & x, const at::Scalar & n) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
at::Tensor & special_shifted_chebyshev_polynomial_w_outf(const at::Tensor & x, const at::Scalar & n, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_n_scalar_out_special_shifted_chebyshev_polynomial_w_out(x, n, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
at::Tensor & wrapper_CompositeExplicitAutograd_out__foobar_out(const at::Tensor & self, bool arg1, bool arg2, bool arg3, at::Tensor & out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_foobar_out(self, arg1, arg2, arg3, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_foobar.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__foobar_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
at::Tensor & _foobar_out(at::Tensor & out, const at::Tensor & self, bool arg1, bool arg2, bool arg3) {
return wrapper_CompositeExplicitAutograd_out__foobar_out(self, arg1, arg2, arg3, out);
}
at::Tensor & _foobar_outf(const at::Tensor & self, bool arg1, bool arg2, bool arg3, at::Tensor & out) {
return wrapper_CompositeExplicitAutograd_out__foobar_out(self, arg1, arg2, arg3, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd___fused_adam(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adam(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__fused_adam_out(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adam_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_adam",
TORCH_FN(wrapper_CompositeExplicitAutograd___fused_adam));
m.impl("_fused_adam.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_adam_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_adam(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd___fused_adam(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
void _fused_adam_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_out__fused_adam_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
void _fused_adam_outf(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__fused_adam_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd_tensor_lr__fused_adam(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adam(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adam_out(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adam_tensor_lr_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_adam.tensor_lr",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr__fused_adam));
m.impl("_fused_adam.tensor_lr_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adam_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_adam(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr__fused_adam(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
void _fused_adam_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adam_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
void _fused_adam_outf(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adam_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd___fused_adamw(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adamw(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__fused_adamw_out(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adamw_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_adamw",
TORCH_FN(wrapper_CompositeExplicitAutograd___fused_adamw));
m.impl("_fused_adamw.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_adamw_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_adamw(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd___fused_adamw(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
void _fused_adamw_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_out__fused_adamw_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
void _fused_adamw_outf(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, double lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__fused_adamw_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd_tensor_lr__fused_adamw(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adamw(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adamw_out(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adamw_tensor_lr_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_adamw.tensor_lr",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr__fused_adamw));
m.impl("_fused_adamw.tensor_lr_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adamw_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_adamw(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr__fused_adamw(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf);
}
void _fused_adamw_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adamw_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
void _fused_adamw_outf(at::TensorList self, at::TensorList grads, at::TensorList exp_avgs, at::TensorList exp_avg_sqs, at::TensorList max_exp_avg_sqs, at::TensorList state_steps, const at::Tensor & lr, double beta1, double beta2, double weight_decay, double eps, bool amsgrad, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_adamw_out(self, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, lr, beta1, beta2, weight_decay, eps, amsgrad, maximize, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd___fused_sgd(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, double lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_sgd(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__fused_sgd_out(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, double lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_sgd_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_sgd",
TORCH_FN(wrapper_CompositeExplicitAutograd___fused_sgd));
m.impl("_fused_sgd.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_sgd_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_sgd(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, double lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd___fused_sgd(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf);
}
void _fused_sgd_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, double lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_out__fused_sgd_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
void _fused_sgd_outf(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, double lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__fused_sgd_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd_tensor_lr__fused_sgd(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, const at::Tensor & lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_sgd(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_sgd_out(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, const at::Tensor & lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_sgd_tensor_lr_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_sgd.tensor_lr",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr__fused_sgd));
m.impl("_fused_sgd.tensor_lr_out",
TORCH_FN(wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_sgd_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_sgd(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, const at::Tensor & lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr__fused_sgd(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf);
}
void _fused_sgd_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, const at::Tensor & lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_sgd_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
void _fused_sgd_outf(at::TensorList self, at::TensorList grads, at::TensorList momentum_buffer_list, double weight_decay, double momentum, const at::Tensor & lr, double dampening, bool nesterov, bool maximize, bool is_first_step, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_tensor_lr_out__fused_sgd_out(self, grads, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, is_first_step, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at
namespace at {
// NB: TORCH_LIBRARY_IMPL must be in an anonymous namespace to avoid
// ambiguity with conflicting identifiers that may have been defined in
// at namespace already.
namespace {
namespace {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> wrapper_CompositeExplicitAutograd___fused_adagrad(at::TensorList self, at::TensorList grads, at::TensorList state_sums, at::TensorList state_steps, double lr, double lr_decay, double weight_decay, double eps, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adagrad(self, grads, state_sums, state_steps, lr, lr_decay, weight_decay, eps, maximize, grad_scale, found_inf);
}
} // anonymous namespace
namespace {
void wrapper_CompositeExplicitAutograd_out__fused_adagrad_out(at::TensorList self, at::TensorList grads, at::TensorList state_sums, at::TensorList state_steps, double lr, double lr_decay, double weight_decay, double eps, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
    // No device check
  // DeviceGuard omitted
  return at::native::_fused_adagrad_out(self, grads, state_sums, state_steps, lr, lr_decay, weight_decay, eps, maximize, grad_scale, found_inf, out);
}
} // anonymous namespace
TORCH_LIBRARY_IMPL(aten, CompositeExplicitAutograd, m) {
    m.impl("_fused_adagrad",
TORCH_FN(wrapper_CompositeExplicitAutograd___fused_adagrad));
m.impl("_fused_adagrad.out",
TORCH_FN(wrapper_CompositeExplicitAutograd_out__fused_adagrad_out));
}
} // anonymous namespace
namespace compositeexplicitautograd {
::std::tuple<::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>,::std::vector<at::Tensor>> _fused_adagrad(at::TensorList self, at::TensorList grads, at::TensorList state_sums, at::TensorList state_steps, double lr, double lr_decay, double weight_decay, double eps, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd___fused_adagrad(self, grads, state_sums, state_steps, lr, lr_decay, weight_decay, eps, maximize, grad_scale, found_inf);
}
void _fused_adagrad_out(at::TensorList out, at::TensorList self, at::TensorList grads, at::TensorList state_sums, at::TensorList state_steps, double lr, double lr_decay, double weight_decay, double eps, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf) {
return wrapper_CompositeExplicitAutograd_out__fused_adagrad_out(self, grads, state_sums, state_steps, lr, lr_decay, weight_decay, eps, maximize, grad_scale, found_inf, out);
}
void _fused_adagrad_outf(at::TensorList self, at::TensorList grads, at::TensorList state_sums, at::TensorList state_steps, double lr, double lr_decay, double weight_decay, double eps, bool maximize, const ::std::optional<at::Tensor> & grad_scale, const ::std::optional<at::Tensor> & found_inf, at::TensorList out) {
return wrapper_CompositeExplicitAutograd_out__fused_adagrad_out(self, grads, state_sums, state_steps, lr, lr_decay, weight_decay, eps, maximize, grad_scale, found_inf, out);
}
} // namespace compositeexplicitautograd
} // namespace at