TorchOps.h.inc

TorchOps.h.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Declarations                                                            *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: TorchOps.td                                                          *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#if defined(GET_OP_CLASSES) || defined(GET_OP_FWD_DEFINES)
#undef GET_OP_FWD_DEFINES
namespace mlir {
namespace torch {
namespace Torch {
class AtenAbsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAbs_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAcosOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAcos_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAdaptiveAvgPool1dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAdaptiveAvgPool2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAdaptiveAvgPool3dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddFloatIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAdd_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAdd_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddcdivOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddcdiv_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddcmulOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddcmul_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAddmmOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAliasCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAliasOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAllBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAllDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAllOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAmaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAminOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAnyBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAnyDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAnyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAppendTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArangeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArangeStartOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArangeStartOutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArangeStartStepOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArgmaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenArgminOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAsStridedCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAsStridedScatterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAtan2Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAtan2_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAtanOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAtan_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAvgPool1dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAvgPool2dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAvgPool2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAvgPool3dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenAvgPool3dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBaddbmmOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBaddbmm_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBatchNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBernoulliOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBernoulliPOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBernoulliTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBernoulli_FloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBernoulli_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBinaryCrossEntropyBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBinaryCrossEntropyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBincountOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseAndScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseAndTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseAnd_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseAnd_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseLeftShiftTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseLeftShift_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseNotOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseNot_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseOrTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseOr_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseRightShiftTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseRightShift_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseXorTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBitwiseXor_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBmmOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBoolFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBoolIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBoolTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBroadcastToOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenBucketizeTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCeilFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCeilOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCeilScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCeil_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenChunkOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMaxTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMax_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMax_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMinTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMin_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampMin_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClampTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClamp_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenClamp_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCloneOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConstantPadNdOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenContiguousOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConv2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConvTranspose1dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConvTranspose2dInputOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConvTranspose3dInputOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConvolutionBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenConvolutionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCopy_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCosOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCos_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCoshOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCosh_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCosineEmbeddingLossOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCosineSimilarityOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCpuOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCrossEntropyLossOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCudaOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCumprodOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenCumsumOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDeleteDictStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDetachCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDetachOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDeviceWithIndexOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDiagonalCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDiagonalScatterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivTensorModeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDivTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDiv_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDiv_TensorModeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDiv_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDropoutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenDropout_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEinsumOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEluBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenElu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmbeddingBagPaddingIdxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmbeddingDenseBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmbeddingOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmptyLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmptyMemoryFormatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEmptyStridedOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqDeviceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqIntListOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEqTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEq_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEq_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenErfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenErf_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenErfinvOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenErfinv_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExp_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpandAsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpandCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpandOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpm1Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenExpm1_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEyeMOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenEyeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFftFftOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFillScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFillTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFill_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFill_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFlattenUsingIntsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFlipOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloatImplicitOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloatScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloatStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloatTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloorDivideOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloorDivideScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloor_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFloordivIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFmodScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFmodTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFmod_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFormatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFrobeniusNormDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFullLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenFullOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGatherOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeFloatIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGe_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGe_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeluBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGeluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGetDefaultStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGroupNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGtFloatIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGtFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGtIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGtScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGtTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGt_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenGt_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardsigmoidOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardsigmoid_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardswishOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardswish_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardtanhBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardtanhOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenHardtanh_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIm2colOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenImagOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexPutHackedTwinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexPutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexPut_HackedTwinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexPut_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexSelectOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexTensorHackedTwinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIndexTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenInsertTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIntBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIntFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIntImplicitOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIntScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIntTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIsFloatingPointOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIscloseOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIsinfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenIsnanOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenItemOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenJoinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenKeysStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLayerNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLe_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLe_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeakyReluBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeakyReluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLeakyRelu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLenStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLenTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLenTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLerpTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLerp_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLiftFreshCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLinalgQrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLinalgVectorNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLinearOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLinspaceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenListTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog10Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog10_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog1pOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog1p_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog2Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog2_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogSigmoidBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogSigmoidForwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogSoftmaxIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLog_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalAndOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalAnd_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalNotOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalNot_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalOrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalOr_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalXorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogicalXor_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLogsumexpOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLtFloatIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLtFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLtIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLtScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLtTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLt_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenLt_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedFillScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedFillTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedFill_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedFill_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedScatterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedScatter_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaskedSelectOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMatmulOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxOtherOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool2dWithIndicesBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool2dWithIndicesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool3dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool3dWithIndicesBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaxPool3dWithIndicesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMaximumOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMeanDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMeanOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMinDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMinOtherOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMinimumOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMishOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMmOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMovedimIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMseLossBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMseLossOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMulFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMulIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMulScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMulTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMul_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMul_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMultinomialOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenMvOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNarrowOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNarrowTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeBatchNormBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeBatchNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeDropoutBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeDropoutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeGroupNormBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeGroupNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeLayerNormBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNativeLayerNormOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeFloatIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeIntListOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNe_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNe_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNegFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNegIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNegOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNeg_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNewEmptyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNewEmptyStridedOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNewFullOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNewOnesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNewZerosOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNllLoss2dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNllLoss2dForwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNllLossBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNllLossForwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNonzeroNumpyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNonzeroOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNonzeroStaticOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNormScalarOptDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNormalFunctionalOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNumelOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenNumpyTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenOneHotOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenOnesLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenOnesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPadOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPermuteCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPermuteOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPixelShuffleOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPowIntFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPowScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPowTensorScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPowTensorTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenPreluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenProdDimIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandintLowOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandintOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandnGeneratorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandnLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandnOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandomFromOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRandomOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRealOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenReciprocalOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenReciprocal_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRelu6Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRelu6_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenReluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRelu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRemainderIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRemainderScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRemainderTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRepeatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenReshapeAsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenReshapeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenResizeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenResize_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRollOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRoundOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRound_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRsqrtOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRsqrt_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenRsubScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScalarImplicitOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScalarTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScaledDotProductAttentionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterAddOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterAdd_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterReduceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterReduceTwoOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterReduce_TwoOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterSrcOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatterValueOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatter_SrcOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenScatter_ValueOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSelectCopyIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSelectIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSelectScatterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSeluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSelu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSgnOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSgn_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSigmoidBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSigmoidOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSigmoid_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSignOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSign_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSiluOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSilu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSin_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSinhOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSinh_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSizeIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSizeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSliceCopyTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSliceScatterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSliceTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSliceTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSoftmaxIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSoftplusOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSortIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSortOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSplitCopyTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSplitTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSplitWithSizesCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSplitWithSizesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqrtIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqrtOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqrt_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSquareOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSquare_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqueezeCopyDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqueezeCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqueezeDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSqueezeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenStackOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenStdCorrectionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenStdDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenStdOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSubFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSubIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSubOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSubScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSubTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSub_ScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSub_TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSumDimIntListOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenSumOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTanOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTan_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTanhBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTanhOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTanh_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTensorBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTensorFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTensorIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenThresholdBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenThresholdOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenThreshold_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTileOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenToDeviceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenToDtypeLayoutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenToDtypeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenToOtherOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenToPrimDeviceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTopkOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTransposeCopyIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTransposeIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTrilOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTril_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTriuOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTriu_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenTypeAsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnbindCopyIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnbindIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnflattenIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnfoldCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUniformOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUniform_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUniqueConsecutiveOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnsqueezeCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnsqueezeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUnsqueeze_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUpsampleNearest2dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenUpsampleNearest2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarCorrectionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarMeanCorrectionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarMeanDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarMeanOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenVarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenViewAsComplexOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenViewAsRealOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenViewCopyDtypeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenViewCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenViewOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenWhereScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenWhereScalarOtherOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenWhereScalarSelfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenWhereSelfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenXlogyTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenZeroOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenZero_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenZerosLikeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AtenZerosOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_AdaptiveAvgPool2dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_AdaptiveAvgPool2dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_AdaptiveAvgPool3dBackwardOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_AdaptiveAvgPool3dOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ConvolutionDeprecatedOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ConvolutionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_EmbeddingBagOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_IndexPutImplOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_IndexPutImpl_Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_LogSoftmaxBackwardDataOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_LogSoftmaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ReshapeAliasCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ReshapeAliasOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_SetItemStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_SetItemTOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ShapeAsTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_SoftmaxBackwardDataOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_SoftmaxOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_ToCopyOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_UnsafeIndexPutHackedTwinOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten_UnsafeViewOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__And__BoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__And__TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Contains__IntListOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Contains__StrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__DeriveIndexOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Getitem__DictStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Getitem__TOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Is__Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Isnot__Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Not__Op;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__Or__TensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class Aten__RangeLengthOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class AttrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ClassTypeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ClassTypeTerminatorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantBoolOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantDeviceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantNoneOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantNumberOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ConstantStrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class CopyToNonValueTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class CopyToValueTensorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class DerefineOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class DtypeCalculateOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class DtypeCalculateYieldDtypesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class DtypeCalculateYieldOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class GlobalSlotGetOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class GlobalSlotInitOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class GlobalSlotModuleInitializerOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class GlobalSlotOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class GlobalSlotSetOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class InitializeGlobalSlotsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class LinearParamsCreateOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class MethodOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class NnModuleOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class NnModuleTerminatorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class NonValueTensorLiteralOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class OperatorOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class OverwriteTensorContentsOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PerTensorAffineCreateOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimAbsScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimCallMethodOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimCreateObjectOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimDeviceOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimDictConstructOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimDtypeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimEnterOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimExitOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimGetAttrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimIfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimIfYieldOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimLayoutOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimListConstructOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimListUnpackOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimLoadOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimLoopConditionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimLoopOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimMaxIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimMaxSelfIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimMinIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimMinSelfIntOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimNumToTensorScalarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimPrintOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimRaiseExceptionOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimSetAttrOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimStoreOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimTolistOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimTupleConstructOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimTupleIndexOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimTupleUnpackOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimUncheckedCastOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimUninitializedOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsCollapseOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsConvertElementTypeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsSplitDimOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsSqrtOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsSqueezeOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsVarOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PrimsViewOfOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class PromoteDtypesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class QuantizedLinearOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class RuntimeAssertOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ShapeCalculateOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ShapeCalculateYieldOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ShapeCalculateYieldShapesOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class SlotOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class TensorStaticInfoCastOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ValsemVariantAtenBernoulliFloatOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
namespace mlir {
namespace torch {
namespace Torch {
class ValueTensorLiteralOp;
} // namespace Torch
} // namespace torch
} // namespace mlir
#endif

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


//===----------------------------------------------------------------------===//
// Local Utility Method Definitions
//===----------------------------------------------------------------------===//

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAbsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAbsOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAbsOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAbsOpGenericAdaptorBase(AtenAbsOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAbsOpGenericAdaptor : public detail::AtenAbsOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAbsOpGenericAdaptorBase;
public:
  AtenAbsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAbsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAbsOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAbsOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAbsOp>>>
  AtenAbsOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAbsOpAdaptor : public AtenAbsOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAbsOpGenericAdaptor::AtenAbsOpGenericAdaptor;
  AtenAbsOpAdaptor(AtenAbsOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAbsOp : public ::mlir::Op<AtenAbsOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAbsOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAbsOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.abs");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAbsOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAbs_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAbs_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAbs_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAbs_OpGenericAdaptorBase(AtenAbs_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAbs_OpGenericAdaptor : public detail::AtenAbs_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAbs_OpGenericAdaptorBase;
public:
  AtenAbs_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAbs_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAbs_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAbs_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAbs_Op>>>
  AtenAbs_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAbs_OpAdaptor : public AtenAbs_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAbs_OpGenericAdaptor::AtenAbs_OpGenericAdaptor;
  AtenAbs_OpAdaptor(AtenAbs_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAbs_Op : public ::mlir::Op<AtenAbs_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAbs_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAbs_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.abs_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAbs_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAcosOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAcosOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAcosOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAcosOpGenericAdaptorBase(AtenAcosOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAcosOpGenericAdaptor : public detail::AtenAcosOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAcosOpGenericAdaptorBase;
public:
  AtenAcosOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAcosOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAcosOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAcosOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAcosOp>>>
  AtenAcosOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAcosOpAdaptor : public AtenAcosOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAcosOpGenericAdaptor::AtenAcosOpGenericAdaptor;
  AtenAcosOpAdaptor(AtenAcosOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAcosOp : public ::mlir::Op<AtenAcosOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAcosOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAcosOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.acos");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAcosOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAcos_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAcos_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAcos_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAcos_OpGenericAdaptorBase(AtenAcos_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAcos_OpGenericAdaptor : public detail::AtenAcos_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAcos_OpGenericAdaptorBase;
public:
  AtenAcos_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAcos_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAcos_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAcos_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAcos_Op>>>
  AtenAcos_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAcos_OpAdaptor : public AtenAcos_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAcos_OpGenericAdaptor::AtenAcos_OpGenericAdaptor;
  AtenAcos_OpAdaptor(AtenAcos_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAcos_Op : public ::mlir::Op<AtenAcos_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAcos_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAcos_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.acos_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAcos_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAdaptiveAvgPool1dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAdaptiveAvgPool1dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAdaptiveAvgPool1dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAdaptiveAvgPool1dOpGenericAdaptorBase(AtenAdaptiveAvgPool1dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAdaptiveAvgPool1dOpGenericAdaptor : public detail::AtenAdaptiveAvgPool1dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAdaptiveAvgPool1dOpGenericAdaptorBase;
public:
  AtenAdaptiveAvgPool1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAdaptiveAvgPool1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAdaptiveAvgPool1dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAdaptiveAvgPool1dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAdaptiveAvgPool1dOp>>>
  AtenAdaptiveAvgPool1dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOutputSize() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAdaptiveAvgPool1dOpAdaptor : public AtenAdaptiveAvgPool1dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAdaptiveAvgPool1dOpGenericAdaptor::AtenAdaptiveAvgPool1dOpGenericAdaptor;
  AtenAdaptiveAvgPool1dOpAdaptor(AtenAdaptiveAvgPool1dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAdaptiveAvgPool1dOp : public ::mlir::Op<AtenAdaptiveAvgPool1dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAdaptiveAvgPool1dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAdaptiveAvgPool1dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.adaptive_avg_pool1d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputSize();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOutputSizeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAdaptiveAvgPool1dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAdaptiveAvgPool2dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAdaptiveAvgPool2dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAdaptiveAvgPool2dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAdaptiveAvgPool2dOpGenericAdaptorBase(AtenAdaptiveAvgPool2dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAdaptiveAvgPool2dOpGenericAdaptor : public detail::AtenAdaptiveAvgPool2dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAdaptiveAvgPool2dOpGenericAdaptorBase;
public:
  AtenAdaptiveAvgPool2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAdaptiveAvgPool2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAdaptiveAvgPool2dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAdaptiveAvgPool2dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAdaptiveAvgPool2dOp>>>
  AtenAdaptiveAvgPool2dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOutputSize() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAdaptiveAvgPool2dOpAdaptor : public AtenAdaptiveAvgPool2dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAdaptiveAvgPool2dOpGenericAdaptor::AtenAdaptiveAvgPool2dOpGenericAdaptor;
  AtenAdaptiveAvgPool2dOpAdaptor(AtenAdaptiveAvgPool2dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAdaptiveAvgPool2dOp : public ::mlir::Op<AtenAdaptiveAvgPool2dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAdaptiveAvgPool2dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAdaptiveAvgPool2dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.adaptive_avg_pool2d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputSize();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOutputSizeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAdaptiveAvgPool2dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAdaptiveAvgPool3dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAdaptiveAvgPool3dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAdaptiveAvgPool3dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAdaptiveAvgPool3dOpGenericAdaptorBase(AtenAdaptiveAvgPool3dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAdaptiveAvgPool3dOpGenericAdaptor : public detail::AtenAdaptiveAvgPool3dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAdaptiveAvgPool3dOpGenericAdaptorBase;
public:
  AtenAdaptiveAvgPool3dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAdaptiveAvgPool3dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAdaptiveAvgPool3dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAdaptiveAvgPool3dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAdaptiveAvgPool3dOp>>>
  AtenAdaptiveAvgPool3dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOutputSize() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAdaptiveAvgPool3dOpAdaptor : public AtenAdaptiveAvgPool3dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAdaptiveAvgPool3dOpGenericAdaptor::AtenAdaptiveAvgPool3dOpGenericAdaptor;
  AtenAdaptiveAvgPool3dOpAdaptor(AtenAdaptiveAvgPool3dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAdaptiveAvgPool3dOp : public ::mlir::Op<AtenAdaptiveAvgPool3dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAdaptiveAvgPool3dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAdaptiveAvgPool3dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.adaptive_avg_pool3d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputSize();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOutputSizeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value output_size);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAdaptiveAvgPool3dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddFloatIntOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddFloatIntOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddFloatIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddFloatIntOpGenericAdaptorBase(AtenAddFloatIntOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddFloatIntOpGenericAdaptor : public detail::AtenAddFloatIntOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddFloatIntOpGenericAdaptorBase;
public:
  AtenAddFloatIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddFloatIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddFloatIntOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddFloatIntOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddFloatIntOp>>>
  AtenAddFloatIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddFloatIntOpAdaptor : public AtenAddFloatIntOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddFloatIntOpGenericAdaptor::AtenAddFloatIntOpGenericAdaptor;
  AtenAddFloatIntOpAdaptor(AtenAddFloatIntOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddFloatIntOp : public ::mlir::Op<AtenAddFloatIntOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddFloatIntOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddFloatIntOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.float_int");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddFloatIntOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddIntOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddIntOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddIntOpGenericAdaptorBase(AtenAddIntOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddIntOpGenericAdaptor : public detail::AtenAddIntOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddIntOpGenericAdaptorBase;
public:
  AtenAddIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddIntOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddIntOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddIntOp>>>
  AtenAddIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddIntOpAdaptor : public AtenAddIntOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddIntOpGenericAdaptor::AtenAddIntOpGenericAdaptor;
  AtenAddIntOpAdaptor(AtenAddIntOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddIntOp : public ::mlir::Op<AtenAddIntOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::IntType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddIntOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddIntOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.int");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddIntOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddOpGenericAdaptorBase(AtenAddOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddOpGenericAdaptor : public detail::AtenAddOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddOpGenericAdaptorBase;
public:
  AtenAddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddOp>>>
  AtenAddOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddOpAdaptor : public AtenAddOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddOpGenericAdaptor::AtenAddOpGenericAdaptor;
  AtenAddOpAdaptor(AtenAddOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddOp : public ::mlir::Op<AtenAddOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getA();
  ::mlir::Value getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddScalarOpGenericAdaptorBase(AtenAddScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddScalarOpGenericAdaptor : public detail::AtenAddScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddScalarOpGenericAdaptorBase;
public:
  AtenAddScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddScalarOp>>>
  AtenAddScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddScalarOpAdaptor : public AtenAddScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddScalarOpGenericAdaptor::AtenAddScalarOpGenericAdaptor;
  AtenAddScalarOpAdaptor(AtenAddScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddScalarOp : public ::mlir::Op<AtenAddScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddStrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddStrOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddStrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddStrOpGenericAdaptorBase(AtenAddStrOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddStrOpGenericAdaptor : public detail::AtenAddStrOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddStrOpGenericAdaptorBase;
public:
  AtenAddStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddStrOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddStrOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddStrOp>>>
  AtenAddStrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddStrOpAdaptor : public AtenAddStrOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddStrOpGenericAdaptor::AtenAddStrOpGenericAdaptor;
  AtenAddStrOpAdaptor(AtenAddStrOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddStrOp : public ::mlir::Op<AtenAddStrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::StringType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddStrOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddStrOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.str");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddStrOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddTOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddTOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddTOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddTOpGenericAdaptorBase(AtenAddTOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddTOpGenericAdaptor : public detail::AtenAddTOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddTOpGenericAdaptorBase;
public:
  AtenAddTOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddTOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddTOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddTOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddTOp>>>
  AtenAddTOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddTOpAdaptor : public AtenAddTOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddTOpGenericAdaptor::AtenAddTOpGenericAdaptor;
  AtenAddTOpAdaptor(AtenAddTOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddTOp : public ::mlir::Op<AtenAddTOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::ListType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddTOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddTOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.t");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddTOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddTensorOpGenericAdaptorBase(AtenAddTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddTensorOpGenericAdaptor : public detail::AtenAddTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddTensorOpGenericAdaptorBase;
public:
  AtenAddTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddTensorOp>>>
  AtenAddTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddTensorOpAdaptor : public AtenAddTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddTensorOpGenericAdaptor::AtenAddTensorOpGenericAdaptor;
  AtenAddTensorOpAdaptor(AtenAddTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddTensorOp : public ::mlir::Op<AtenAddTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAdd_ScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAdd_ScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAdd_ScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAdd_ScalarOpGenericAdaptorBase(AtenAdd_ScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAdd_ScalarOpGenericAdaptor : public detail::AtenAdd_ScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAdd_ScalarOpGenericAdaptorBase;
public:
  AtenAdd_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAdd_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAdd_ScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAdd_ScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAdd_ScalarOp>>>
  AtenAdd_ScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAdd_ScalarOpAdaptor : public AtenAdd_ScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAdd_ScalarOpGenericAdaptor::AtenAdd_ScalarOpGenericAdaptor;
  AtenAdd_ScalarOpAdaptor(AtenAdd_ScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAdd_ScalarOp : public ::mlir::Op<AtenAdd_ScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAdd_ScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAdd_ScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add_.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getOther();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAdd_ScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAdd_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAdd_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAdd_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAdd_TensorOpGenericAdaptorBase(AtenAdd_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAdd_TensorOpGenericAdaptor : public detail::AtenAdd_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAdd_TensorOpGenericAdaptorBase;
public:
  AtenAdd_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAdd_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAdd_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAdd_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAdd_TensorOp>>>
  AtenAdd_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAdd_TensorOpAdaptor : public AtenAdd_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAdd_TensorOpGenericAdaptor::AtenAdd_TensorOpGenericAdaptor;
  AtenAdd_TensorOpAdaptor(AtenAdd_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAdd_TensorOp : public ::mlir::Op<AtenAdd_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAdd_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAdd_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.add_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAdd_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddcdivOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddcdivOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddcdivOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddcdivOpGenericAdaptorBase(AtenAddcdivOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddcdivOpGenericAdaptor : public detail::AtenAddcdivOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddcdivOpGenericAdaptorBase;
public:
  AtenAddcdivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddcdivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddcdivOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddcdivOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddcdivOp>>>
  AtenAddcdivOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTensor1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTensor2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getValue() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddcdivOpAdaptor : public AtenAddcdivOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddcdivOpGenericAdaptor::AtenAddcdivOpGenericAdaptor;
  AtenAddcdivOpAdaptor(AtenAddcdivOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddcdivOp : public ::mlir::Op<AtenAddcdivOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddcdivOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddcdivOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.addcdiv");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getTensor1();
  ::mlir::Value getTensor2();
  ::mlir::Value getValue();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTensor1Mutable();
  ::mlir::OpOperand &getTensor2Mutable();
  ::mlir::OpOperand &getValueMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddcdivOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddcdiv_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddcdiv_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddcdiv_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddcdiv_OpGenericAdaptorBase(AtenAddcdiv_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddcdiv_OpGenericAdaptor : public detail::AtenAddcdiv_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddcdiv_OpGenericAdaptorBase;
public:
  AtenAddcdiv_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddcdiv_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddcdiv_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddcdiv_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddcdiv_Op>>>
  AtenAddcdiv_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTensor1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTensor2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getValue() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddcdiv_OpAdaptor : public AtenAddcdiv_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddcdiv_OpGenericAdaptor::AtenAddcdiv_OpGenericAdaptor;
  AtenAddcdiv_OpAdaptor(AtenAddcdiv_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddcdiv_Op : public ::mlir::Op<AtenAddcdiv_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddcdiv_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddcdiv_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.addcdiv_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getTensor1();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getTensor2();
  ::mlir::Value getValue();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTensor1Mutable();
  ::mlir::OpOperand &getTensor2Mutable();
  ::mlir::OpOperand &getValueMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddcdiv_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddcmulOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddcmulOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddcmulOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddcmulOpGenericAdaptorBase(AtenAddcmulOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddcmulOpGenericAdaptor : public detail::AtenAddcmulOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddcmulOpGenericAdaptorBase;
public:
  AtenAddcmulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddcmulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddcmulOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddcmulOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddcmulOp>>>
  AtenAddcmulOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTensor1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTensor2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getValue() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddcmulOpAdaptor : public AtenAddcmulOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddcmulOpGenericAdaptor::AtenAddcmulOpGenericAdaptor;
  AtenAddcmulOpAdaptor(AtenAddcmulOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddcmulOp : public ::mlir::Op<AtenAddcmulOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddcmulOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddcmulOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.addcmul");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getTensor1();
  ::mlir::Value getTensor2();
  ::mlir::Value getValue();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTensor1Mutable();
  ::mlir::OpOperand &getTensor2Mutable();
  ::mlir::OpOperand &getValueMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddcmulOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddcmul_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddcmul_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddcmul_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddcmul_OpGenericAdaptorBase(AtenAddcmul_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddcmul_OpGenericAdaptor : public detail::AtenAddcmul_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddcmul_OpGenericAdaptorBase;
public:
  AtenAddcmul_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddcmul_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddcmul_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddcmul_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddcmul_Op>>>
  AtenAddcmul_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTensor1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTensor2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getValue() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddcmul_OpAdaptor : public AtenAddcmul_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddcmul_OpGenericAdaptor::AtenAddcmul_OpGenericAdaptor;
  AtenAddcmul_OpAdaptor(AtenAddcmul_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddcmul_Op : public ::mlir::Op<AtenAddcmul_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddcmul_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddcmul_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.addcmul_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getTensor1();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getTensor2();
  ::mlir::Value getValue();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTensor1Mutable();
  ::mlir::OpOperand &getTensor2Mutable();
  ::mlir::OpOperand &getValueMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value tensor1, ::mlir::Value tensor2, ::mlir::Value value);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddcmul_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAddmmOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAddmmOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAddmmOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAddmmOpGenericAdaptorBase(AtenAddmmOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAddmmOpGenericAdaptor : public detail::AtenAddmmOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAddmmOpGenericAdaptorBase;
public:
  AtenAddmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAddmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAddmmOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAddmmOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAddmmOp>>>
  AtenAddmmOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMat1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMat2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getBeta() {
    return (*getODSOperands(3).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAddmmOpAdaptor : public AtenAddmmOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAddmmOpGenericAdaptor::AtenAddmmOpGenericAdaptor;
  AtenAddmmOpAdaptor(AtenAddmmOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAddmmOp : public ::mlir::Op<AtenAddmmOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAddmmOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAddmmOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.addmm");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMat1();
  ::mlir::Value getMat2();
  ::mlir::Value getBeta();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMat1Mutable();
  ::mlir::OpOperand &getMat2Mutable();
  ::mlir::OpOperand &getBetaMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value mat1, ::mlir::Value mat2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value mat1, ::mlir::Value mat2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAddmmOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAliasCopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAliasCopyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAliasCopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAliasCopyOpGenericAdaptorBase(AtenAliasCopyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAliasCopyOpGenericAdaptor : public detail::AtenAliasCopyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAliasCopyOpGenericAdaptorBase;
public:
  AtenAliasCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAliasCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAliasCopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAliasCopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAliasCopyOp>>>
  AtenAliasCopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAliasCopyOpAdaptor : public AtenAliasCopyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAliasCopyOpGenericAdaptor::AtenAliasCopyOpGenericAdaptor;
  AtenAliasCopyOpAdaptor(AtenAliasCopyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAliasCopyOp : public ::mlir::Op<AtenAliasCopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAliasCopyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAliasCopyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.alias_copy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAliasCopyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAliasOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAliasOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAliasOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAliasOpGenericAdaptorBase(AtenAliasOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAliasOpGenericAdaptor : public detail::AtenAliasOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAliasOpGenericAdaptorBase;
public:
  AtenAliasOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAliasOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAliasOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAliasOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAliasOp>>>
  AtenAliasOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAliasOpAdaptor : public AtenAliasOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAliasOpGenericAdaptor::AtenAliasOpGenericAdaptor;
  AtenAliasOpAdaptor(AtenAliasOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAliasOp : public ::mlir::Op<AtenAliasOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAliasOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAliasOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.alias");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAliasOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAllBoolOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAllBoolOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAllBoolOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAllBoolOpGenericAdaptorBase(AtenAllBoolOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAllBoolOpGenericAdaptor : public detail::AtenAllBoolOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAllBoolOpGenericAdaptorBase;
public:
  AtenAllBoolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAllBoolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAllBoolOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAllBoolOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAllBoolOp>>>
  AtenAllBoolOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAllBoolOpAdaptor : public AtenAllBoolOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAllBoolOpGenericAdaptor::AtenAllBoolOpGenericAdaptor;
  AtenAllBoolOpAdaptor(AtenAllBoolOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAllBoolOp : public ::mlir::Op<AtenAllBoolOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAllBoolOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAllBoolOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.all.bool");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAllBoolOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAllDimOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAllDimOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAllDimOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAllDimOpGenericAdaptorBase(AtenAllDimOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAllDimOpGenericAdaptor : public detail::AtenAllDimOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAllDimOpGenericAdaptorBase;
public:
  AtenAllDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAllDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAllDimOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAllDimOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAllDimOp>>>
  AtenAllDimOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAllDimOpAdaptor : public AtenAllDimOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAllDimOpGenericAdaptor::AtenAllDimOpGenericAdaptor;
  AtenAllDimOpAdaptor(AtenAllDimOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAllDimOp : public ::mlir::Op<AtenAllDimOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAllDimOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAllDimOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.all.dim");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAllDimOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAllOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAllOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAllOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAllOpGenericAdaptorBase(AtenAllOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAllOpGenericAdaptor : public detail::AtenAllOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAllOpGenericAdaptorBase;
public:
  AtenAllOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAllOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAllOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAllOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAllOp>>>
  AtenAllOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAllOpAdaptor : public AtenAllOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAllOpGenericAdaptor::AtenAllOpGenericAdaptor;
  AtenAllOpAdaptor(AtenAllOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAllOp : public ::mlir::Op<AtenAllOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAllOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAllOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.all");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAllOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAmaxOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAmaxOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAmaxOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAmaxOpGenericAdaptorBase(AtenAmaxOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAmaxOpGenericAdaptor : public detail::AtenAmaxOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAmaxOpGenericAdaptorBase;
public:
  AtenAmaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAmaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAmaxOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAmaxOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAmaxOp>>>
  AtenAmaxOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAmaxOpAdaptor : public AtenAmaxOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAmaxOpGenericAdaptor::AtenAmaxOpGenericAdaptor;
  AtenAmaxOpAdaptor(AtenAmaxOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAmaxOp : public ::mlir::Op<AtenAmaxOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAmaxOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAmaxOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.amax");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAmaxOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAminOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAminOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAminOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAminOpGenericAdaptorBase(AtenAminOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAminOpGenericAdaptor : public detail::AtenAminOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAminOpGenericAdaptorBase;
public:
  AtenAminOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAminOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAminOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAminOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAminOp>>>
  AtenAminOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAminOpAdaptor : public AtenAminOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAminOpGenericAdaptor::AtenAminOpGenericAdaptor;
  AtenAminOpAdaptor(AtenAminOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAminOp : public ::mlir::Op<AtenAminOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAminOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAminOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.amin");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAminOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAnyBoolOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAnyBoolOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAnyBoolOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAnyBoolOpGenericAdaptorBase(AtenAnyBoolOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAnyBoolOpGenericAdaptor : public detail::AtenAnyBoolOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAnyBoolOpGenericAdaptorBase;
public:
  AtenAnyBoolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAnyBoolOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAnyBoolOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAnyBoolOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAnyBoolOp>>>
  AtenAnyBoolOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAnyBoolOpAdaptor : public AtenAnyBoolOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAnyBoolOpGenericAdaptor::AtenAnyBoolOpGenericAdaptor;
  AtenAnyBoolOpAdaptor(AtenAnyBoolOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAnyBoolOp : public ::mlir::Op<AtenAnyBoolOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAnyBoolOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAnyBoolOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.any.bool");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAnyBoolOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAnyDimOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAnyDimOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAnyDimOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAnyDimOpGenericAdaptorBase(AtenAnyDimOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAnyDimOpGenericAdaptor : public detail::AtenAnyDimOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAnyDimOpGenericAdaptorBase;
public:
  AtenAnyDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAnyDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAnyDimOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAnyDimOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAnyDimOp>>>
  AtenAnyDimOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAnyDimOpAdaptor : public AtenAnyDimOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAnyDimOpGenericAdaptor::AtenAnyDimOpGenericAdaptor;
  AtenAnyDimOpAdaptor(AtenAnyDimOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAnyDimOp : public ::mlir::Op<AtenAnyDimOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAnyDimOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAnyDimOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.any.dim");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAnyDimOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAnyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAnyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAnyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAnyOpGenericAdaptorBase(AtenAnyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAnyOpGenericAdaptor : public detail::AtenAnyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAnyOpGenericAdaptorBase;
public:
  AtenAnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAnyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAnyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAnyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAnyOp>>>
  AtenAnyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAnyOpAdaptor : public AtenAnyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAnyOpGenericAdaptor::AtenAnyOpGenericAdaptor;
  AtenAnyOpAdaptor(AtenAnyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAnyOp : public ::mlir::Op<AtenAnyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAnyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAnyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.any");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAnyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAppendTOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAppendTOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAppendTOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAppendTOpGenericAdaptorBase(AtenAppendTOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAppendTOpGenericAdaptor : public detail::AtenAppendTOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAppendTOpGenericAdaptorBase;
public:
  AtenAppendTOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAppendTOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAppendTOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAppendTOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAppendTOp>>>
  AtenAppendTOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getEl() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAppendTOpAdaptor : public AtenAppendTOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAppendTOpGenericAdaptor::AtenAppendTOpGenericAdaptor;
  AtenAppendTOpAdaptor(AtenAppendTOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAppendTOp : public ::mlir::Op<AtenAppendTOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::ListType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAppendTOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAppendTOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.append.t");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSelf();
  ::mlir::Value getEl();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getElMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value el);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value el);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAppendTOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArangeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArangeOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArangeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArangeOpGenericAdaptorBase(AtenArangeOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArangeOpGenericAdaptor : public detail::AtenArangeOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArangeOpGenericAdaptorBase;
public:
  AtenArangeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArangeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArangeOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArangeOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArangeOp>>>
  AtenArangeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getEnd() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(1).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArangeOpAdaptor : public AtenArangeOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArangeOpGenericAdaptor::AtenArangeOpGenericAdaptor;
  AtenArangeOpAdaptor(AtenArangeOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArangeOp : public ::mlir::Op<AtenArangeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArangeOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArangeOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.arange");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getEnd();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::OpOperand &getEndMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value end, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value end, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArangeOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArangeStartOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArangeStartOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArangeStartOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArangeStartOpGenericAdaptorBase(AtenArangeStartOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArangeStartOpGenericAdaptor : public detail::AtenArangeStartOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArangeStartOpGenericAdaptorBase;
public:
  AtenArangeStartOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArangeStartOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArangeStartOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArangeStartOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArangeStartOp>>>
  AtenArangeStartOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getStart() {
    return (*getODSOperands(0).begin());
  }

  ValueT getEnd() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(2).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(3).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(4).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArangeStartOpAdaptor : public AtenArangeStartOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArangeStartOpGenericAdaptor::AtenArangeStartOpGenericAdaptor;
  AtenArangeStartOpAdaptor(AtenArangeStartOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArangeStartOp : public ::mlir::Op<AtenArangeStartOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArangeStartOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArangeStartOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.arange.start");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getStart();
  ::mlir::Value getEnd();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::OpOperand &getStartMutable();
  ::mlir::OpOperand &getEndMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value start, ::mlir::Value end, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value start, ::mlir::Value end, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArangeStartOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArangeStartOutOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArangeStartOutOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArangeStartOutOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArangeStartOutOpGenericAdaptorBase(AtenArangeStartOutOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArangeStartOutOpGenericAdaptor : public detail::AtenArangeStartOutOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArangeStartOutOpGenericAdaptorBase;
public:
  AtenArangeStartOutOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArangeStartOutOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArangeStartOutOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArangeStartOutOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArangeStartOutOp>>>
  AtenArangeStartOutOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getStart() {
    return (*getODSOperands(0).begin());
  }

  ValueT getEnd() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStep() {
    return (*getODSOperands(2).begin());
  }

  ValueT getOut() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArangeStartOutOpAdaptor : public AtenArangeStartOutOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArangeStartOutOpGenericAdaptor::AtenArangeStartOutOpGenericAdaptor;
  AtenArangeStartOutOpAdaptor(AtenArangeStartOutOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArangeStartOutOp : public ::mlir::Op<AtenArangeStartOutOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArangeStartOutOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArangeStartOutOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.arange.start_out");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getStart();
  ::mlir::Value getEnd();
  ::mlir::Value getStep();
  ::mlir::Value getOut();
  ::mlir::OpOperand &getStartMutable();
  ::mlir::OpOperand &getEndMutable();
  ::mlir::OpOperand &getStepMutable();
  ::mlir::OpOperand &getOutMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value start, ::mlir::Value end, ::mlir::Value step, ::mlir::Value out);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value start, ::mlir::Value end, ::mlir::Value step, ::mlir::Value out);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArangeStartOutOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArangeStartStepOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArangeStartStepOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArangeStartStepOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArangeStartStepOpGenericAdaptorBase(AtenArangeStartStepOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArangeStartStepOpGenericAdaptor : public detail::AtenArangeStartStepOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArangeStartStepOpGenericAdaptorBase;
public:
  AtenArangeStartStepOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArangeStartStepOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArangeStartStepOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArangeStartStepOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArangeStartStepOp>>>
  AtenArangeStartStepOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getStart() {
    return (*getODSOperands(0).begin());
  }

  ValueT getEnd() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStep() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(3).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(4).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(5).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(6).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArangeStartStepOpAdaptor : public AtenArangeStartStepOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArangeStartStepOpGenericAdaptor::AtenArangeStartStepOpGenericAdaptor;
  AtenArangeStartStepOpAdaptor(AtenArangeStartStepOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArangeStartStepOp : public ::mlir::Op<AtenArangeStartStepOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<7>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArangeStartStepOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArangeStartStepOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.arange.start_step");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getStart();
  ::mlir::Value getEnd();
  ::mlir::Value getStep();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::OpOperand &getStartMutable();
  ::mlir::OpOperand &getEndMutable();
  ::mlir::OpOperand &getStepMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value start, ::mlir::Value end, ::mlir::Value step, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value start, ::mlir::Value end, ::mlir::Value step, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArangeStartStepOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArgmaxOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArgmaxOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArgmaxOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArgmaxOpGenericAdaptorBase(AtenArgmaxOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArgmaxOpGenericAdaptor : public detail::AtenArgmaxOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArgmaxOpGenericAdaptorBase;
public:
  AtenArgmaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArgmaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArgmaxOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArgmaxOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArgmaxOp>>>
  AtenArgmaxOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArgmaxOpAdaptor : public AtenArgmaxOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArgmaxOpGenericAdaptor::AtenArgmaxOpGenericAdaptor;
  AtenArgmaxOpAdaptor(AtenArgmaxOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArgmaxOp : public ::mlir::Op<AtenArgmaxOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArgmaxOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArgmaxOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.argmax");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArgmaxOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenArgminOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenArgminOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenArgminOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenArgminOpGenericAdaptorBase(AtenArgminOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenArgminOpGenericAdaptor : public detail::AtenArgminOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenArgminOpGenericAdaptorBase;
public:
  AtenArgminOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenArgminOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenArgminOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenArgminOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenArgminOp>>>
  AtenArgminOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKeepdim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenArgminOpAdaptor : public AtenArgminOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenArgminOpGenericAdaptor::AtenArgminOpGenericAdaptor;
  AtenArgminOpAdaptor(AtenArgminOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenArgminOp : public ::mlir::Op<AtenArgminOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenArgminOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenArgminOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.argmin");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getKeepdim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getKeepdimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value keepdim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenArgminOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAsStridedCopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAsStridedCopyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAsStridedCopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAsStridedCopyOpGenericAdaptorBase(AtenAsStridedCopyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAsStridedCopyOpGenericAdaptor : public detail::AtenAsStridedCopyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAsStridedCopyOpGenericAdaptorBase;
public:
  AtenAsStridedCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAsStridedCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAsStridedCopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAsStridedCopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAsStridedCopyOp>>>
  AtenAsStridedCopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSize() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStorageOffset() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAsStridedCopyOpAdaptor : public AtenAsStridedCopyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAsStridedCopyOpGenericAdaptor::AtenAsStridedCopyOpGenericAdaptor;
  AtenAsStridedCopyOpAdaptor(AtenAsStridedCopyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAsStridedCopyOp : public ::mlir::Op<AtenAsStridedCopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAsStridedCopyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAsStridedCopyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.as_strided_copy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::Value getStorageOffset();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getStorageOffsetMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value storage_offset);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value storage_offset);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAsStridedCopyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAsStridedScatterOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAsStridedScatterOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAsStridedScatterOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAsStridedScatterOpGenericAdaptorBase(AtenAsStridedScatterOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAsStridedScatterOpGenericAdaptor : public detail::AtenAsStridedScatterOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAsStridedScatterOpGenericAdaptorBase;
public:
  AtenAsStridedScatterOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAsStridedScatterOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAsStridedScatterOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAsStridedScatterOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAsStridedScatterOp>>>
  AtenAsStridedScatterOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSrc() {
    return (*getODSOperands(1).begin());
  }

  ValueT getSize() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getStorageOffset() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAsStridedScatterOpAdaptor : public AtenAsStridedScatterOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAsStridedScatterOpGenericAdaptor::AtenAsStridedScatterOpGenericAdaptor;
  AtenAsStridedScatterOpAdaptor(AtenAsStridedScatterOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAsStridedScatterOp : public ::mlir::Op<AtenAsStridedScatterOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAsStridedScatterOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAsStridedScatterOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.as_strided_scatter");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getSrc();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::Value getStorageOffset();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSrcMutable();
  ::mlir::OpOperand &getSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getStorageOffsetMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value src, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value storage_offset);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value src, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value storage_offset);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAsStridedScatterOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAtan2Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAtan2OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAtan2OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAtan2OpGenericAdaptorBase(AtenAtan2Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAtan2OpGenericAdaptor : public detail::AtenAtan2OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAtan2OpGenericAdaptorBase;
public:
  AtenAtan2OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAtan2OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAtan2OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAtan2Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAtan2Op>>>
  AtenAtan2OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAtan2OpAdaptor : public AtenAtan2OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAtan2OpGenericAdaptor::AtenAtan2OpGenericAdaptor;
  AtenAtan2OpAdaptor(AtenAtan2Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAtan2Op : public ::mlir::Op<AtenAtan2Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAtan2OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAtan2OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.atan2");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAtan2Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAtan2_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAtan2_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAtan2_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAtan2_OpGenericAdaptorBase(AtenAtan2_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAtan2_OpGenericAdaptor : public detail::AtenAtan2_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAtan2_OpGenericAdaptorBase;
public:
  AtenAtan2_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAtan2_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAtan2_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAtan2_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAtan2_Op>>>
  AtenAtan2_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAtan2_OpAdaptor : public AtenAtan2_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAtan2_OpGenericAdaptor::AtenAtan2_OpGenericAdaptor;
  AtenAtan2_OpAdaptor(AtenAtan2_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAtan2_Op : public ::mlir::Op<AtenAtan2_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAtan2_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAtan2_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.atan2_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAtan2_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAtanOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAtanOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAtanOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAtanOpGenericAdaptorBase(AtenAtanOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAtanOpGenericAdaptor : public detail::AtenAtanOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAtanOpGenericAdaptorBase;
public:
  AtenAtanOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAtanOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAtanOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAtanOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAtanOp>>>
  AtenAtanOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAtanOpAdaptor : public AtenAtanOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAtanOpGenericAdaptor::AtenAtanOpGenericAdaptor;
  AtenAtanOpAdaptor(AtenAtanOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAtanOp : public ::mlir::Op<AtenAtanOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAtanOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAtanOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.atan");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAtanOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAtan_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAtan_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAtan_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAtan_OpGenericAdaptorBase(AtenAtan_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAtan_OpGenericAdaptor : public detail::AtenAtan_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAtan_OpGenericAdaptorBase;
public:
  AtenAtan_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAtan_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAtan_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAtan_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAtan_Op>>>
  AtenAtan_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAtan_OpAdaptor : public AtenAtan_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAtan_OpGenericAdaptor::AtenAtan_OpGenericAdaptor;
  AtenAtan_OpAdaptor(AtenAtan_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAtan_Op : public ::mlir::Op<AtenAtan_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAtan_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAtan_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.atan_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAtan_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAvgPool1dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAvgPool1dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAvgPool1dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAvgPool1dOpGenericAdaptorBase(AtenAvgPool1dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAvgPool1dOpGenericAdaptor : public detail::AtenAvgPool1dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAvgPool1dOpGenericAdaptorBase;
public:
  AtenAvgPool1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAvgPool1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAvgPool1dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAvgPool1dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAvgPool1dOp>>>
  AtenAvgPool1dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getKernelSize() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(2).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(3).begin());
  }

  ValueT getCeilMode() {
    return (*getODSOperands(4).begin());
  }

  ValueT getCountIncludePad() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAvgPool1dOpAdaptor : public AtenAvgPool1dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAvgPool1dOpGenericAdaptor::AtenAvgPool1dOpGenericAdaptor;
  AtenAvgPool1dOpAdaptor(AtenAvgPool1dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAvgPool1dOp : public ::mlir::Op<AtenAvgPool1dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAvgPool1dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAvgPool1dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.avg_pool1d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getKernelSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCeilMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCountIncludePad();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKernelSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getCeilModeMutable();
  ::mlir::OpOperand &getCountIncludePadMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAvgPool1dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAvgPool2dBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAvgPool2dBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAvgPool2dBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAvgPool2dBackwardOpGenericAdaptorBase(AtenAvgPool2dBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAvgPool2dBackwardOpGenericAdaptor : public detail::AtenAvgPool2dBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAvgPool2dBackwardOpGenericAdaptorBase;
public:
  AtenAvgPool2dBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAvgPool2dBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAvgPool2dBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAvgPool2dBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAvgPool2dBackwardOp>>>
  AtenAvgPool2dBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSelf() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKernelSize() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getCeilMode() {
    return (*getODSOperands(5).begin());
  }

  ValueT getCountIncludePad() {
    return (*getODSOperands(6).begin());
  }

  ValueT getDivisorOverride() {
    return (*getODSOperands(7).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAvgPool2dBackwardOpAdaptor : public AtenAvgPool2dBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAvgPool2dBackwardOpGenericAdaptor::AtenAvgPool2dBackwardOpGenericAdaptor;
  AtenAvgPool2dBackwardOpAdaptor(AtenAvgPool2dBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAvgPool2dBackwardOp : public ::mlir::Op<AtenAvgPool2dBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<8>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAvgPool2dBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAvgPool2dBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.avg_pool2d_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getKernelSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCeilMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCountIncludePad();
  ::mlir::Value getDivisorOverride();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKernelSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getCeilModeMutable();
  ::mlir::OpOperand &getCountIncludePadMutable();
  ::mlir::OpOperand &getDivisorOverrideMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAvgPool2dBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAvgPool2dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAvgPool2dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAvgPool2dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAvgPool2dOpGenericAdaptorBase(AtenAvgPool2dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAvgPool2dOpGenericAdaptor : public detail::AtenAvgPool2dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAvgPool2dOpGenericAdaptorBase;
public:
  AtenAvgPool2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAvgPool2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAvgPool2dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAvgPool2dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAvgPool2dOp>>>
  AtenAvgPool2dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getKernelSize() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(2).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(3).begin());
  }

  ValueT getCeilMode() {
    return (*getODSOperands(4).begin());
  }

  ValueT getCountIncludePad() {
    return (*getODSOperands(5).begin());
  }

  ValueT getDivisorOverride() {
    return (*getODSOperands(6).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAvgPool2dOpAdaptor : public AtenAvgPool2dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAvgPool2dOpGenericAdaptor::AtenAvgPool2dOpGenericAdaptor;
  AtenAvgPool2dOpAdaptor(AtenAvgPool2dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAvgPool2dOp : public ::mlir::Op<AtenAvgPool2dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<7>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAvgPool2dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAvgPool2dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.avg_pool2d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getKernelSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCeilMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCountIncludePad();
  ::mlir::Value getDivisorOverride();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKernelSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getCeilModeMutable();
  ::mlir::OpOperand &getCountIncludePadMutable();
  ::mlir::OpOperand &getDivisorOverrideMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAvgPool2dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAvgPool3dBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAvgPool3dBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAvgPool3dBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAvgPool3dBackwardOpGenericAdaptorBase(AtenAvgPool3dBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAvgPool3dBackwardOpGenericAdaptor : public detail::AtenAvgPool3dBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAvgPool3dBackwardOpGenericAdaptorBase;
public:
  AtenAvgPool3dBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAvgPool3dBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAvgPool3dBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAvgPool3dBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAvgPool3dBackwardOp>>>
  AtenAvgPool3dBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSelf() {
    return (*getODSOperands(1).begin());
  }

  ValueT getKernelSize() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getCeilMode() {
    return (*getODSOperands(5).begin());
  }

  ValueT getCountIncludePad() {
    return (*getODSOperands(6).begin());
  }

  ValueT getDivisorOverride() {
    return (*getODSOperands(7).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAvgPool3dBackwardOpAdaptor : public AtenAvgPool3dBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAvgPool3dBackwardOpGenericAdaptor::AtenAvgPool3dBackwardOpGenericAdaptor;
  AtenAvgPool3dBackwardOpAdaptor(AtenAvgPool3dBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAvgPool3dBackwardOp : public ::mlir::Op<AtenAvgPool3dBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<8>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAvgPool3dBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAvgPool3dBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.avg_pool3d_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getKernelSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCeilMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCountIncludePad();
  ::mlir::Value getDivisorOverride();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKernelSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getCeilModeMutable();
  ::mlir::OpOperand &getCountIncludePadMutable();
  ::mlir::OpOperand &getDivisorOverrideMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAvgPool3dBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenAvgPool3dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenAvgPool3dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenAvgPool3dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenAvgPool3dOpGenericAdaptorBase(AtenAvgPool3dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenAvgPool3dOpGenericAdaptor : public detail::AtenAvgPool3dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenAvgPool3dOpGenericAdaptorBase;
public:
  AtenAvgPool3dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenAvgPool3dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenAvgPool3dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenAvgPool3dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenAvgPool3dOp>>>
  AtenAvgPool3dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getKernelSize() {
    return (*getODSOperands(1).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(2).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(3).begin());
  }

  ValueT getCeilMode() {
    return (*getODSOperands(4).begin());
  }

  ValueT getCountIncludePad() {
    return (*getODSOperands(5).begin());
  }

  ValueT getDivisorOverride() {
    return (*getODSOperands(6).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenAvgPool3dOpAdaptor : public AtenAvgPool3dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenAvgPool3dOpGenericAdaptor::AtenAvgPool3dOpGenericAdaptor;
  AtenAvgPool3dOpAdaptor(AtenAvgPool3dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenAvgPool3dOp : public ::mlir::Op<AtenAvgPool3dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<7>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenAvgPool3dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenAvgPool3dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.avg_pool3d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getKernelSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCeilMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCountIncludePad();
  ::mlir::Value getDivisorOverride();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKernelSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getCeilModeMutable();
  ::mlir::OpOperand &getCountIncludePadMutable();
  ::mlir::OpOperand &getDivisorOverrideMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value kernel_size, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value ceil_mode, ::mlir::Value count_include_pad, ::mlir::Value divisor_override);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenAvgPool3dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBaddbmmOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBaddbmmOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBaddbmmOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBaddbmmOpGenericAdaptorBase(AtenBaddbmmOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBaddbmmOpGenericAdaptor : public detail::AtenBaddbmmOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBaddbmmOpGenericAdaptorBase;
public:
  AtenBaddbmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBaddbmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBaddbmmOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBaddbmmOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBaddbmmOp>>>
  AtenBaddbmmOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getBatch1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBatch2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getBeta() {
    return (*getODSOperands(3).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBaddbmmOpAdaptor : public AtenBaddbmmOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBaddbmmOpGenericAdaptor::AtenBaddbmmOpGenericAdaptor;
  AtenBaddbmmOpAdaptor(AtenBaddbmmOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBaddbmmOp : public ::mlir::Op<AtenBaddbmmOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBaddbmmOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBaddbmmOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.baddbmm");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getBatch1();
  ::mlir::Value getBatch2();
  ::mlir::Value getBeta();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getBatch1Mutable();
  ::mlir::OpOperand &getBatch2Mutable();
  ::mlir::OpOperand &getBetaMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value batch1, ::mlir::Value batch2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value batch1, ::mlir::Value batch2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBaddbmmOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBaddbmm_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBaddbmm_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBaddbmm_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBaddbmm_OpGenericAdaptorBase(AtenBaddbmm_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBaddbmm_OpGenericAdaptor : public detail::AtenBaddbmm_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBaddbmm_OpGenericAdaptorBase;
public:
  AtenBaddbmm_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBaddbmm_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBaddbmm_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBaddbmm_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBaddbmm_Op>>>
  AtenBaddbmm_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getBatch1() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBatch2() {
    return (*getODSOperands(2).begin());
  }

  ValueT getBeta() {
    return (*getODSOperands(3).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBaddbmm_OpAdaptor : public AtenBaddbmm_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBaddbmm_OpGenericAdaptor::AtenBaddbmm_OpGenericAdaptor;
  AtenBaddbmm_OpAdaptor(AtenBaddbmm_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBaddbmm_Op : public ::mlir::Op<AtenBaddbmm_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBaddbmm_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBaddbmm_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.baddbmm_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getBatch1();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getBatch2();
  ::mlir::Value getBeta();
  ::mlir::Value getAlpha();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getBatch1Mutable();
  ::mlir::OpOperand &getBatch2Mutable();
  ::mlir::OpOperand &getBetaMutable();
  ::mlir::OpOperand &getAlphaMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value batch1, ::mlir::Value batch2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value batch1, ::mlir::Value batch2, ::mlir::Value beta, ::mlir::Value alpha);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBaddbmm_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBatchNormOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBatchNormOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBatchNormOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBatchNormOpGenericAdaptorBase(AtenBatchNormOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBatchNormOpGenericAdaptor : public detail::AtenBatchNormOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBatchNormOpGenericAdaptorBase;
public:
  AtenBatchNormOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBatchNormOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBatchNormOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBatchNormOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBatchNormOp>>>
  AtenBatchNormOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getRunningMean() {
    return (*getODSOperands(3).begin());
  }

  ValueT getRunningVar() {
    return (*getODSOperands(4).begin());
  }

  ValueT getTraining() {
    return (*getODSOperands(5).begin());
  }

  ValueT getMomentum() {
    return (*getODSOperands(6).begin());
  }

  ValueT getEps() {
    return (*getODSOperands(7).begin());
  }

  ValueT getCudnnEnabled() {
    return (*getODSOperands(8).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBatchNormOpAdaptor : public AtenBatchNormOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBatchNormOpGenericAdaptor::AtenBatchNormOpGenericAdaptor;
  AtenBatchNormOpAdaptor(AtenBatchNormOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBatchNormOp : public ::mlir::Op<AtenBatchNormOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<9>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBatchNormOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBatchNormOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.batch_norm");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::Value getRunningMean();
  ::mlir::Value getRunningVar();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getTraining();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getMomentum();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getEps();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getCudnnEnabled();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getRunningMeanMutable();
  ::mlir::OpOperand &getRunningVarMutable();
  ::mlir::OpOperand &getTrainingMutable();
  ::mlir::OpOperand &getMomentumMutable();
  ::mlir::OpOperand &getEpsMutable();
  ::mlir::OpOperand &getCudnnEnabledMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value running_mean, ::mlir::Value running_var, ::mlir::Value training, ::mlir::Value momentum, ::mlir::Value eps, ::mlir::Value cudnn_enabled);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value running_mean, ::mlir::Value running_var, ::mlir::Value training, ::mlir::Value momentum, ::mlir::Value eps, ::mlir::Value cudnn_enabled);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBatchNormOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBernoulliOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBernoulliOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBernoulliOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBernoulliOpGenericAdaptorBase(AtenBernoulliOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBernoulliOpGenericAdaptor : public detail::AtenBernoulliOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBernoulliOpGenericAdaptorBase;
public:
  AtenBernoulliOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBernoulliOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBernoulliOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBernoulliOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBernoulliOp>>>
  AtenBernoulliOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getGenerator() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBernoulliOpAdaptor : public AtenBernoulliOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBernoulliOpGenericAdaptor::AtenBernoulliOpGenericAdaptor;
  AtenBernoulliOpAdaptor(AtenBernoulliOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBernoulliOp : public ::mlir::Op<AtenBernoulliOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBernoulliOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBernoulliOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bernoulli");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getGenerator();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getGeneratorMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBernoulliOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBernoulliPOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBernoulliPOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBernoulliPOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBernoulliPOpGenericAdaptorBase(AtenBernoulliPOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBernoulliPOpGenericAdaptor : public detail::AtenBernoulliPOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBernoulliPOpGenericAdaptorBase;
public:
  AtenBernoulliPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBernoulliPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBernoulliPOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBernoulliPOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBernoulliPOp>>>
  AtenBernoulliPOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getGenerator() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBernoulliPOpAdaptor : public AtenBernoulliPOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBernoulliPOpGenericAdaptor::AtenBernoulliPOpGenericAdaptor;
  AtenBernoulliPOpAdaptor(AtenBernoulliPOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBernoulliPOp : public ::mlir::Op<AtenBernoulliPOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBernoulliPOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBernoulliPOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bernoulli.p");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getP();
  ::mlir::Value getGenerator();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getGeneratorMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBernoulliPOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBernoulliTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBernoulliTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBernoulliTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBernoulliTensorOpGenericAdaptorBase(AtenBernoulliTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBernoulliTensorOpGenericAdaptor : public detail::AtenBernoulliTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBernoulliTensorOpGenericAdaptorBase;
public:
  AtenBernoulliTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBernoulliTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBernoulliTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBernoulliTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBernoulliTensorOp>>>
  AtenBernoulliTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getGenerator() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBernoulliTensorOpAdaptor : public AtenBernoulliTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBernoulliTensorOpGenericAdaptor::AtenBernoulliTensorOpGenericAdaptor;
  AtenBernoulliTensorOpAdaptor(AtenBernoulliTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBernoulliTensorOp : public ::mlir::Op<AtenBernoulliTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBernoulliTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBernoulliTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bernoulli.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getP();
  ::mlir::Value getGenerator();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getGeneratorMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBernoulliTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBernoulli_FloatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBernoulli_FloatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBernoulli_FloatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBernoulli_FloatOpGenericAdaptorBase(AtenBernoulli_FloatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBernoulli_FloatOpGenericAdaptor : public detail::AtenBernoulli_FloatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBernoulli_FloatOpGenericAdaptorBase;
public:
  AtenBernoulli_FloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBernoulli_FloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBernoulli_FloatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBernoulli_FloatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBernoulli_FloatOp>>>
  AtenBernoulli_FloatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getGenerator() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBernoulli_FloatOpAdaptor : public AtenBernoulli_FloatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBernoulli_FloatOpGenericAdaptor::AtenBernoulli_FloatOpGenericAdaptor;
  AtenBernoulli_FloatOpAdaptor(AtenBernoulli_FloatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBernoulli_FloatOp : public ::mlir::Op<AtenBernoulli_FloatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBernoulli_FloatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBernoulli_FloatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bernoulli_.float");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getP();
  ::mlir::Value getGenerator();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getGeneratorMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBernoulli_FloatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBernoulli_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBernoulli_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBernoulli_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBernoulli_TensorOpGenericAdaptorBase(AtenBernoulli_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBernoulli_TensorOpGenericAdaptor : public detail::AtenBernoulli_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBernoulli_TensorOpGenericAdaptorBase;
public:
  AtenBernoulli_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBernoulli_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBernoulli_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBernoulli_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBernoulli_TensorOp>>>
  AtenBernoulli_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getGenerator() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBernoulli_TensorOpAdaptor : public AtenBernoulli_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBernoulli_TensorOpGenericAdaptor::AtenBernoulli_TensorOpGenericAdaptor;
  AtenBernoulli_TensorOpAdaptor(AtenBernoulli_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBernoulli_TensorOp : public ::mlir::Op<AtenBernoulli_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBernoulli_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBernoulli_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bernoulli_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getP();
  ::mlir::Value getGenerator();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getGeneratorMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value p, ::mlir::Value generator);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBernoulli_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBinaryCrossEntropyBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBinaryCrossEntropyBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBinaryCrossEntropyBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBinaryCrossEntropyBackwardOpGenericAdaptorBase(AtenBinaryCrossEntropyBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBinaryCrossEntropyBackwardOpGenericAdaptor : public detail::AtenBinaryCrossEntropyBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBinaryCrossEntropyBackwardOpGenericAdaptorBase;
public:
  AtenBinaryCrossEntropyBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBinaryCrossEntropyBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBinaryCrossEntropyBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBinaryCrossEntropyBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBinaryCrossEntropyBackwardOp>>>
  AtenBinaryCrossEntropyBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSelf() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTarget() {
    return (*getODSOperands(2).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(3).begin());
  }

  ValueT getReduction() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBinaryCrossEntropyBackwardOpAdaptor : public AtenBinaryCrossEntropyBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBinaryCrossEntropyBackwardOpGenericAdaptor::AtenBinaryCrossEntropyBackwardOpGenericAdaptor;
  AtenBinaryCrossEntropyBackwardOpAdaptor(AtenBinaryCrossEntropyBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBinaryCrossEntropyBackwardOp : public ::mlir::Op<AtenBinaryCrossEntropyBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBinaryCrossEntropyBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBinaryCrossEntropyBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.binary_cross_entropy_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getSelf();
  ::mlir::Value getTarget();
  ::mlir::Value getWeight();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getReduction();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTargetMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getReductionMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBinaryCrossEntropyBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBinaryCrossEntropyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBinaryCrossEntropyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBinaryCrossEntropyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBinaryCrossEntropyOpGenericAdaptorBase(AtenBinaryCrossEntropyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBinaryCrossEntropyOpGenericAdaptor : public detail::AtenBinaryCrossEntropyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBinaryCrossEntropyOpGenericAdaptorBase;
public:
  AtenBinaryCrossEntropyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBinaryCrossEntropyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBinaryCrossEntropyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBinaryCrossEntropyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBinaryCrossEntropyOp>>>
  AtenBinaryCrossEntropyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTarget() {
    return (*getODSOperands(1).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(2).begin());
  }

  ValueT getReduction() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBinaryCrossEntropyOpAdaptor : public AtenBinaryCrossEntropyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBinaryCrossEntropyOpGenericAdaptor::AtenBinaryCrossEntropyOpGenericAdaptor;
  AtenBinaryCrossEntropyOpAdaptor(AtenBinaryCrossEntropyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBinaryCrossEntropyOp : public ::mlir::Op<AtenBinaryCrossEntropyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBinaryCrossEntropyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBinaryCrossEntropyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.binary_cross_entropy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getTarget();
  ::mlir::Value getWeight();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getReduction();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTargetMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getReductionMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBinaryCrossEntropyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBincountOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBincountOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBincountOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBincountOpGenericAdaptorBase(AtenBincountOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBincountOpGenericAdaptor : public detail::AtenBincountOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBincountOpGenericAdaptorBase;
public:
  AtenBincountOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBincountOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBincountOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBincountOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBincountOp>>>
  AtenBincountOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeights() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMinlength() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBincountOpAdaptor : public AtenBincountOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBincountOpGenericAdaptor::AtenBincountOpGenericAdaptor;
  AtenBincountOpAdaptor(AtenBincountOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBincountOp : public ::mlir::Op<AtenBincountOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBincountOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBincountOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bincount");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getWeights();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getMinlength();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getWeightsMutable();
  ::mlir::OpOperand &getMinlengthMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value weights, ::mlir::Value minlength);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value weights, ::mlir::Value minlength);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBincountOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseAndScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseAndScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseAndScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseAndScalarOpGenericAdaptorBase(AtenBitwiseAndScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseAndScalarOpGenericAdaptor : public detail::AtenBitwiseAndScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseAndScalarOpGenericAdaptorBase;
public:
  AtenBitwiseAndScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseAndScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseAndScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseAndScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseAndScalarOp>>>
  AtenBitwiseAndScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseAndScalarOpAdaptor : public AtenBitwiseAndScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseAndScalarOpGenericAdaptor::AtenBitwiseAndScalarOpGenericAdaptor;
  AtenBitwiseAndScalarOpAdaptor(AtenBitwiseAndScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseAndScalarOp : public ::mlir::Op<AtenBitwiseAndScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseAndScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseAndScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_and.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseAndScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseAndTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseAndTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseAndTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseAndTensorOpGenericAdaptorBase(AtenBitwiseAndTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseAndTensorOpGenericAdaptor : public detail::AtenBitwiseAndTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseAndTensorOpGenericAdaptorBase;
public:
  AtenBitwiseAndTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseAndTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseAndTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseAndTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseAndTensorOp>>>
  AtenBitwiseAndTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseAndTensorOpAdaptor : public AtenBitwiseAndTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseAndTensorOpGenericAdaptor::AtenBitwiseAndTensorOpGenericAdaptor;
  AtenBitwiseAndTensorOpAdaptor(AtenBitwiseAndTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseAndTensorOp : public ::mlir::Op<AtenBitwiseAndTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseAndTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseAndTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_and.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseAndTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseAnd_ScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseAnd_ScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseAnd_ScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseAnd_ScalarOpGenericAdaptorBase(AtenBitwiseAnd_ScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseAnd_ScalarOpGenericAdaptor : public detail::AtenBitwiseAnd_ScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseAnd_ScalarOpGenericAdaptorBase;
public:
  AtenBitwiseAnd_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseAnd_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseAnd_ScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseAnd_ScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseAnd_ScalarOp>>>
  AtenBitwiseAnd_ScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseAnd_ScalarOpAdaptor : public AtenBitwiseAnd_ScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseAnd_ScalarOpGenericAdaptor::AtenBitwiseAnd_ScalarOpGenericAdaptor;
  AtenBitwiseAnd_ScalarOpAdaptor(AtenBitwiseAnd_ScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseAnd_ScalarOp : public ::mlir::Op<AtenBitwiseAnd_ScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseAnd_ScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseAnd_ScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_and_.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseAnd_ScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseAnd_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseAnd_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseAnd_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseAnd_TensorOpGenericAdaptorBase(AtenBitwiseAnd_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseAnd_TensorOpGenericAdaptor : public detail::AtenBitwiseAnd_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseAnd_TensorOpGenericAdaptorBase;
public:
  AtenBitwiseAnd_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseAnd_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseAnd_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseAnd_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseAnd_TensorOp>>>
  AtenBitwiseAnd_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseAnd_TensorOpAdaptor : public AtenBitwiseAnd_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseAnd_TensorOpGenericAdaptor::AtenBitwiseAnd_TensorOpGenericAdaptor;
  AtenBitwiseAnd_TensorOpAdaptor(AtenBitwiseAnd_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseAnd_TensorOp : public ::mlir::Op<AtenBitwiseAnd_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseAnd_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseAnd_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_and_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseAnd_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseLeftShiftTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseLeftShiftTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseLeftShiftTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseLeftShiftTensorOpGenericAdaptorBase(AtenBitwiseLeftShiftTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseLeftShiftTensorOpGenericAdaptor : public detail::AtenBitwiseLeftShiftTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseLeftShiftTensorOpGenericAdaptorBase;
public:
  AtenBitwiseLeftShiftTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseLeftShiftTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseLeftShiftTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseLeftShiftTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseLeftShiftTensorOp>>>
  AtenBitwiseLeftShiftTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseLeftShiftTensorOpAdaptor : public AtenBitwiseLeftShiftTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseLeftShiftTensorOpGenericAdaptor::AtenBitwiseLeftShiftTensorOpGenericAdaptor;
  AtenBitwiseLeftShiftTensorOpAdaptor(AtenBitwiseLeftShiftTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseLeftShiftTensorOp : public ::mlir::Op<AtenBitwiseLeftShiftTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseLeftShiftTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseLeftShiftTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_left_shift.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseLeftShiftTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseLeftShift_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseLeftShift_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseLeftShift_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseLeftShift_TensorOpGenericAdaptorBase(AtenBitwiseLeftShift_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseLeftShift_TensorOpGenericAdaptor : public detail::AtenBitwiseLeftShift_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseLeftShift_TensorOpGenericAdaptorBase;
public:
  AtenBitwiseLeftShift_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseLeftShift_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseLeftShift_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseLeftShift_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseLeftShift_TensorOp>>>
  AtenBitwiseLeftShift_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseLeftShift_TensorOpAdaptor : public AtenBitwiseLeftShift_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseLeftShift_TensorOpGenericAdaptor::AtenBitwiseLeftShift_TensorOpGenericAdaptor;
  AtenBitwiseLeftShift_TensorOpAdaptor(AtenBitwiseLeftShift_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseLeftShift_TensorOp : public ::mlir::Op<AtenBitwiseLeftShift_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseLeftShift_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseLeftShift_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_left_shift_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseLeftShift_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseNotOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseNotOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseNotOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseNotOpGenericAdaptorBase(AtenBitwiseNotOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseNotOpGenericAdaptor : public detail::AtenBitwiseNotOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseNotOpGenericAdaptorBase;
public:
  AtenBitwiseNotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseNotOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseNotOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseNotOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseNotOp>>>
  AtenBitwiseNotOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseNotOpAdaptor : public AtenBitwiseNotOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseNotOpGenericAdaptor::AtenBitwiseNotOpGenericAdaptor;
  AtenBitwiseNotOpAdaptor(AtenBitwiseNotOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseNotOp : public ::mlir::Op<AtenBitwiseNotOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseNotOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseNotOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_not");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseNotOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseNot_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseNot_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseNot_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseNot_OpGenericAdaptorBase(AtenBitwiseNot_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseNot_OpGenericAdaptor : public detail::AtenBitwiseNot_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseNot_OpGenericAdaptorBase;
public:
  AtenBitwiseNot_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseNot_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseNot_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseNot_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseNot_Op>>>
  AtenBitwiseNot_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseNot_OpAdaptor : public AtenBitwiseNot_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseNot_OpGenericAdaptor::AtenBitwiseNot_OpGenericAdaptor;
  AtenBitwiseNot_OpAdaptor(AtenBitwiseNot_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseNot_Op : public ::mlir::Op<AtenBitwiseNot_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseNot_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseNot_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_not_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseNot_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseOrTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseOrTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseOrTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseOrTensorOpGenericAdaptorBase(AtenBitwiseOrTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseOrTensorOpGenericAdaptor : public detail::AtenBitwiseOrTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseOrTensorOpGenericAdaptorBase;
public:
  AtenBitwiseOrTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseOrTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseOrTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseOrTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseOrTensorOp>>>
  AtenBitwiseOrTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseOrTensorOpAdaptor : public AtenBitwiseOrTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseOrTensorOpGenericAdaptor::AtenBitwiseOrTensorOpGenericAdaptor;
  AtenBitwiseOrTensorOpAdaptor(AtenBitwiseOrTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseOrTensorOp : public ::mlir::Op<AtenBitwiseOrTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseOrTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseOrTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_or.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseOrTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseOr_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseOr_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseOr_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseOr_TensorOpGenericAdaptorBase(AtenBitwiseOr_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseOr_TensorOpGenericAdaptor : public detail::AtenBitwiseOr_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseOr_TensorOpGenericAdaptorBase;
public:
  AtenBitwiseOr_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseOr_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseOr_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseOr_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseOr_TensorOp>>>
  AtenBitwiseOr_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseOr_TensorOpAdaptor : public AtenBitwiseOr_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseOr_TensorOpGenericAdaptor::AtenBitwiseOr_TensorOpGenericAdaptor;
  AtenBitwiseOr_TensorOpAdaptor(AtenBitwiseOr_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseOr_TensorOp : public ::mlir::Op<AtenBitwiseOr_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseOr_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseOr_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_or_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseOr_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseRightShiftTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseRightShiftTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseRightShiftTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseRightShiftTensorOpGenericAdaptorBase(AtenBitwiseRightShiftTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseRightShiftTensorOpGenericAdaptor : public detail::AtenBitwiseRightShiftTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseRightShiftTensorOpGenericAdaptorBase;
public:
  AtenBitwiseRightShiftTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseRightShiftTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseRightShiftTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseRightShiftTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseRightShiftTensorOp>>>
  AtenBitwiseRightShiftTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseRightShiftTensorOpAdaptor : public AtenBitwiseRightShiftTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseRightShiftTensorOpGenericAdaptor::AtenBitwiseRightShiftTensorOpGenericAdaptor;
  AtenBitwiseRightShiftTensorOpAdaptor(AtenBitwiseRightShiftTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseRightShiftTensorOp : public ::mlir::Op<AtenBitwiseRightShiftTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseRightShiftTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseRightShiftTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_right_shift.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseRightShiftTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseRightShift_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseRightShift_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseRightShift_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseRightShift_TensorOpGenericAdaptorBase(AtenBitwiseRightShift_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseRightShift_TensorOpGenericAdaptor : public detail::AtenBitwiseRightShift_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseRightShift_TensorOpGenericAdaptorBase;
public:
  AtenBitwiseRightShift_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseRightShift_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseRightShift_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseRightShift_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseRightShift_TensorOp>>>
  AtenBitwiseRightShift_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseRightShift_TensorOpAdaptor : public AtenBitwiseRightShift_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseRightShift_TensorOpGenericAdaptor::AtenBitwiseRightShift_TensorOpGenericAdaptor;
  AtenBitwiseRightShift_TensorOpAdaptor(AtenBitwiseRightShift_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseRightShift_TensorOp : public ::mlir::Op<AtenBitwiseRightShift_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseRightShift_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseRightShift_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_right_shift_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseRightShift_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseXorTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseXorTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseXorTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseXorTensorOpGenericAdaptorBase(AtenBitwiseXorTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseXorTensorOpGenericAdaptor : public detail::AtenBitwiseXorTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseXorTensorOpGenericAdaptorBase;
public:
  AtenBitwiseXorTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseXorTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseXorTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseXorTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseXorTensorOp>>>
  AtenBitwiseXorTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseXorTensorOpAdaptor : public AtenBitwiseXorTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseXorTensorOpGenericAdaptor::AtenBitwiseXorTensorOpGenericAdaptor;
  AtenBitwiseXorTensorOpAdaptor(AtenBitwiseXorTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseXorTensorOp : public ::mlir::Op<AtenBitwiseXorTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseXorTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseXorTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_xor.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseXorTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBitwiseXor_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBitwiseXor_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBitwiseXor_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBitwiseXor_TensorOpGenericAdaptorBase(AtenBitwiseXor_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBitwiseXor_TensorOpGenericAdaptor : public detail::AtenBitwiseXor_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBitwiseXor_TensorOpGenericAdaptorBase;
public:
  AtenBitwiseXor_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBitwiseXor_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBitwiseXor_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBitwiseXor_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBitwiseXor_TensorOp>>>
  AtenBitwiseXor_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBitwiseXor_TensorOpAdaptor : public AtenBitwiseXor_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBitwiseXor_TensorOpGenericAdaptor::AtenBitwiseXor_TensorOpGenericAdaptor;
  AtenBitwiseXor_TensorOpAdaptor(AtenBitwiseXor_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBitwiseXor_TensorOp : public ::mlir::Op<AtenBitwiseXor_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBitwiseXor_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBitwiseXor_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bitwise_xor_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBitwiseXor_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBmmOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBmmOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBmmOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBmmOpGenericAdaptorBase(AtenBmmOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBmmOpGenericAdaptor : public detail::AtenBmmOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBmmOpGenericAdaptorBase;
public:
  AtenBmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBmmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBmmOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBmmOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBmmOp>>>
  AtenBmmOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMat2() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBmmOpAdaptor : public AtenBmmOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBmmOpGenericAdaptor::AtenBmmOpGenericAdaptor;
  AtenBmmOpAdaptor(AtenBmmOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBmmOp : public ::mlir::Op<AtenBmmOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBmmOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBmmOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bmm");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMat2();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMat2Mutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value mat2);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value mat2);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBmmOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBoolFloatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBoolFloatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBoolFloatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBoolFloatOpGenericAdaptorBase(AtenBoolFloatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBoolFloatOpGenericAdaptor : public detail::AtenBoolFloatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBoolFloatOpGenericAdaptorBase;
public:
  AtenBoolFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBoolFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBoolFloatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBoolFloatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBoolFloatOp>>>
  AtenBoolFloatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBoolFloatOpAdaptor : public AtenBoolFloatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBoolFloatOpGenericAdaptor::AtenBoolFloatOpGenericAdaptor;
  AtenBoolFloatOpAdaptor(AtenBoolFloatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBoolFloatOp : public ::mlir::Op<AtenBoolFloatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBoolFloatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBoolFloatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.Bool.float");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getA();
  ::mlir::OpOperand &getAMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBoolFloatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBoolIntOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBoolIntOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBoolIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBoolIntOpGenericAdaptorBase(AtenBoolIntOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBoolIntOpGenericAdaptor : public detail::AtenBoolIntOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBoolIntOpGenericAdaptorBase;
public:
  AtenBoolIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBoolIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBoolIntOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBoolIntOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBoolIntOp>>>
  AtenBoolIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBoolIntOpAdaptor : public AtenBoolIntOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBoolIntOpGenericAdaptor::AtenBoolIntOpGenericAdaptor;
  AtenBoolIntOpAdaptor(AtenBoolIntOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBoolIntOp : public ::mlir::Op<AtenBoolIntOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBoolIntOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBoolIntOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.Bool.int");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getA();
  ::mlir::OpOperand &getAMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBoolIntOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBoolTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBoolTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBoolTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBoolTensorOpGenericAdaptorBase(AtenBoolTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBoolTensorOpGenericAdaptor : public detail::AtenBoolTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBoolTensorOpGenericAdaptorBase;
public:
  AtenBoolTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBoolTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBoolTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBoolTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBoolTensorOp>>>
  AtenBoolTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBoolTensorOpAdaptor : public AtenBoolTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBoolTensorOpGenericAdaptor::AtenBoolTensorOpGenericAdaptor;
  AtenBoolTensorOpAdaptor(AtenBoolTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBoolTensorOp : public ::mlir::Op<AtenBoolTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBoolTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBoolTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.Bool.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getA();
  ::mlir::OpOperand &getAMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBoolTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBroadcastToOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBroadcastToOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBroadcastToOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBroadcastToOpGenericAdaptorBase(AtenBroadcastToOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBroadcastToOpGenericAdaptor : public detail::AtenBroadcastToOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBroadcastToOpGenericAdaptorBase;
public:
  AtenBroadcastToOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBroadcastToOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBroadcastToOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBroadcastToOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBroadcastToOp>>>
  AtenBroadcastToOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSize() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBroadcastToOpAdaptor : public AtenBroadcastToOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBroadcastToOpGenericAdaptor::AtenBroadcastToOpGenericAdaptor;
  AtenBroadcastToOpAdaptor(AtenBroadcastToOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBroadcastToOp : public ::mlir::Op<AtenBroadcastToOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBroadcastToOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBroadcastToOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.broadcast_to");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSize();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSizeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value size);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value size);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBroadcastToOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenBucketizeTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenBucketizeTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenBucketizeTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenBucketizeTensorOpGenericAdaptorBase(AtenBucketizeTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenBucketizeTensorOpGenericAdaptor : public detail::AtenBucketizeTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenBucketizeTensorOpGenericAdaptorBase;
public:
  AtenBucketizeTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenBucketizeTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenBucketizeTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenBucketizeTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenBucketizeTensorOp>>>
  AtenBucketizeTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getBoundaries() {
    return (*getODSOperands(1).begin());
  }

  ValueT getOutInt32() {
    return (*getODSOperands(2).begin());
  }

  ValueT getRight() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenBucketizeTensorOpAdaptor : public AtenBucketizeTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenBucketizeTensorOpGenericAdaptor::AtenBucketizeTensorOpGenericAdaptor;
  AtenBucketizeTensorOpAdaptor(AtenBucketizeTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenBucketizeTensorOp : public ::mlir::Op<AtenBucketizeTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenBucketizeTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenBucketizeTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.bucketize.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getBoundaries();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getOutInt32();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getRight();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getBoundariesMutable();
  ::mlir::OpOperand &getOutInt32Mutable();
  ::mlir::OpOperand &getRightMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value boundaries, ::mlir::Value out_int32, ::mlir::Value right);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value boundaries, ::mlir::Value out_int32, ::mlir::Value right);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenBucketizeTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCatOpGenericAdaptorBase(AtenCatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCatOpGenericAdaptor : public detail::AtenCatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCatOpGenericAdaptorBase;
public:
  AtenCatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCatOp>>>
  AtenCatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getTensors() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCatOpAdaptor : public AtenCatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCatOpGenericAdaptor::AtenCatOpGenericAdaptor;
  AtenCatOpAdaptor(AtenCatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCatOp : public ::mlir::Op<AtenCatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cat");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getTensors();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::OpOperand &getTensorsMutable();
  ::mlir::OpOperand &getDimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value tensors, ::mlir::Value dim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value tensors, ::mlir::Value dim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCeilFloatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCeilFloatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCeilFloatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCeilFloatOpGenericAdaptorBase(AtenCeilFloatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCeilFloatOpGenericAdaptor : public detail::AtenCeilFloatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCeilFloatOpGenericAdaptorBase;
public:
  AtenCeilFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCeilFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCeilFloatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCeilFloatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCeilFloatOp>>>
  AtenCeilFloatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCeilFloatOpAdaptor : public AtenCeilFloatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCeilFloatOpGenericAdaptor::AtenCeilFloatOpGenericAdaptor;
  AtenCeilFloatOpAdaptor(AtenCeilFloatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCeilFloatOp : public ::mlir::Op<AtenCeilFloatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::IntType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCeilFloatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCeilFloatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.ceil.float");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getA();
  ::mlir::OpOperand &getAMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCeilFloatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCeilOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCeilOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCeilOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCeilOpGenericAdaptorBase(AtenCeilOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCeilOpGenericAdaptor : public detail::AtenCeilOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCeilOpGenericAdaptorBase;
public:
  AtenCeilOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCeilOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCeilOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCeilOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCeilOp>>>
  AtenCeilOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCeilOpAdaptor : public AtenCeilOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCeilOpGenericAdaptor::AtenCeilOpGenericAdaptor;
  AtenCeilOpAdaptor(AtenCeilOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCeilOp : public ::mlir::Op<AtenCeilOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCeilOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCeilOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.ceil");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCeilOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCeilScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCeilScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCeilScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCeilScalarOpGenericAdaptorBase(AtenCeilScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCeilScalarOpGenericAdaptor : public detail::AtenCeilScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCeilScalarOpGenericAdaptorBase;
public:
  AtenCeilScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCeilScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCeilScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCeilScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCeilScalarOp>>>
  AtenCeilScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCeilScalarOpAdaptor : public AtenCeilScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCeilScalarOpGenericAdaptor::AtenCeilScalarOpGenericAdaptor;
  AtenCeilScalarOpAdaptor(AtenCeilScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCeilScalarOp : public ::mlir::Op<AtenCeilScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCeilScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCeilScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.ceil.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getA();
  ::mlir::OpOperand &getAMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCeilScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCeil_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCeil_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCeil_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCeil_OpGenericAdaptorBase(AtenCeil_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCeil_OpGenericAdaptor : public detail::AtenCeil_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCeil_OpGenericAdaptorBase;
public:
  AtenCeil_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCeil_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCeil_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCeil_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCeil_Op>>>
  AtenCeil_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCeil_OpAdaptor : public AtenCeil_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCeil_OpGenericAdaptor::AtenCeil_OpGenericAdaptor;
  AtenCeil_OpAdaptor(AtenCeil_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCeil_Op : public ::mlir::Op<AtenCeil_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCeil_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCeil_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.ceil_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCeil_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenChunkOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenChunkOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenChunkOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenChunkOpGenericAdaptorBase(AtenChunkOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenChunkOpGenericAdaptor : public detail::AtenChunkOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenChunkOpGenericAdaptorBase;
public:
  AtenChunkOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenChunkOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenChunkOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenChunkOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenChunkOp>>>
  AtenChunkOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getChunks() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenChunkOpAdaptor : public AtenChunkOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenChunkOpGenericAdaptor::AtenChunkOpGenericAdaptor;
  AtenChunkOpAdaptor(AtenChunkOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenChunkOp : public ::mlir::Op<AtenChunkOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::ListType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenChunkOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenChunkOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.chunk");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getChunks();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getChunksMutable();
  ::mlir::OpOperand &getDimMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value chunks, ::mlir::Value dim);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value chunks, ::mlir::Value dim);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenChunkOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMaxOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMaxOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMaxOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMaxOpGenericAdaptorBase(AtenClampMaxOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMaxOpGenericAdaptor : public detail::AtenClampMaxOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMaxOpGenericAdaptorBase;
public:
  AtenClampMaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMaxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMaxOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMaxOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMaxOp>>>
  AtenClampMaxOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMaxOpAdaptor : public AtenClampMaxOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMaxOpGenericAdaptor::AtenClampMaxOpGenericAdaptor;
  AtenClampMaxOpAdaptor(AtenClampMaxOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMaxOp : public ::mlir::Op<AtenClampMaxOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMaxOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMaxOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_max");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMaxOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMaxTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMaxTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMaxTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMaxTensorOpGenericAdaptorBase(AtenClampMaxTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMaxTensorOpGenericAdaptor : public detail::AtenClampMaxTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMaxTensorOpGenericAdaptorBase;
public:
  AtenClampMaxTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMaxTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMaxTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMaxTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMaxTensorOp>>>
  AtenClampMaxTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMaxTensorOpAdaptor : public AtenClampMaxTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMaxTensorOpGenericAdaptor::AtenClampMaxTensorOpGenericAdaptor;
  AtenClampMaxTensorOpAdaptor(AtenClampMaxTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMaxTensorOp : public ::mlir::Op<AtenClampMaxTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMaxTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMaxTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_max.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMaxTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMax_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMax_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMax_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMax_OpGenericAdaptorBase(AtenClampMax_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMax_OpGenericAdaptor : public detail::AtenClampMax_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMax_OpGenericAdaptorBase;
public:
  AtenClampMax_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMax_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMax_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMax_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMax_Op>>>
  AtenClampMax_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMax_OpAdaptor : public AtenClampMax_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMax_OpGenericAdaptor::AtenClampMax_OpGenericAdaptor;
  AtenClampMax_OpAdaptor(AtenClampMax_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMax_Op : public ::mlir::Op<AtenClampMax_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMax_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMax_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_max_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMax_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMax_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMax_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMax_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMax_TensorOpGenericAdaptorBase(AtenClampMax_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMax_TensorOpGenericAdaptor : public detail::AtenClampMax_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMax_TensorOpGenericAdaptorBase;
public:
  AtenClampMax_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMax_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMax_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMax_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMax_TensorOp>>>
  AtenClampMax_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMax_TensorOpAdaptor : public AtenClampMax_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMax_TensorOpGenericAdaptor::AtenClampMax_TensorOpGenericAdaptor;
  AtenClampMax_TensorOpAdaptor(AtenClampMax_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMax_TensorOp : public ::mlir::Op<AtenClampMax_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMax_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMax_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_max_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMax_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMinOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMinOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMinOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMinOpGenericAdaptorBase(AtenClampMinOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMinOpGenericAdaptor : public detail::AtenClampMinOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMinOpGenericAdaptorBase;
public:
  AtenClampMinOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMinOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMinOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMinOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMinOp>>>
  AtenClampMinOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMinOpAdaptor : public AtenClampMinOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMinOpGenericAdaptor::AtenClampMinOpGenericAdaptor;
  AtenClampMinOpAdaptor(AtenClampMinOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMinOp : public ::mlir::Op<AtenClampMinOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMinOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMinOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_min");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMin();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMinOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMinTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMinTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMinTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMinTensorOpGenericAdaptorBase(AtenClampMinTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMinTensorOpGenericAdaptor : public detail::AtenClampMinTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMinTensorOpGenericAdaptorBase;
public:
  AtenClampMinTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMinTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMinTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMinTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMinTensorOp>>>
  AtenClampMinTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMinTensorOpAdaptor : public AtenClampMinTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMinTensorOpGenericAdaptor::AtenClampMinTensorOpGenericAdaptor;
  AtenClampMinTensorOpAdaptor(AtenClampMinTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMinTensorOp : public ::mlir::Op<AtenClampMinTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMinTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMinTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_min.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMin();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMinTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMin_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMin_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMin_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMin_OpGenericAdaptorBase(AtenClampMin_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMin_OpGenericAdaptor : public detail::AtenClampMin_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMin_OpGenericAdaptorBase;
public:
  AtenClampMin_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMin_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMin_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMin_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMin_Op>>>
  AtenClampMin_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMin_OpAdaptor : public AtenClampMin_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMin_OpGenericAdaptor::AtenClampMin_OpGenericAdaptor;
  AtenClampMin_OpAdaptor(AtenClampMin_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMin_Op : public ::mlir::Op<AtenClampMin_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMin_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMin_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_min_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getMin();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMin_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampMin_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampMin_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampMin_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampMin_TensorOpGenericAdaptorBase(AtenClampMin_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampMin_TensorOpGenericAdaptor : public detail::AtenClampMin_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampMin_TensorOpGenericAdaptorBase;
public:
  AtenClampMin_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampMin_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampMin_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampMin_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampMin_TensorOp>>>
  AtenClampMin_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampMin_TensorOpAdaptor : public AtenClampMin_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampMin_TensorOpGenericAdaptor::AtenClampMin_TensorOpGenericAdaptor;
  AtenClampMin_TensorOpAdaptor(AtenClampMin_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampMin_TensorOp : public ::mlir::Op<AtenClampMin_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampMin_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampMin_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_min_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getMin();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampMin_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampOpGenericAdaptorBase(AtenClampOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampOpGenericAdaptor : public detail::AtenClampOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampOpGenericAdaptorBase;
public:
  AtenClampOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampOp>>>
  AtenClampOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampOpAdaptor : public AtenClampOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampOpGenericAdaptor::AtenClampOpGenericAdaptor;
  AtenClampOpAdaptor(AtenClampOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampOp : public ::mlir::Op<AtenClampOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMin();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClampTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClampTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClampTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClampTensorOpGenericAdaptorBase(AtenClampTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClampTensorOpGenericAdaptor : public detail::AtenClampTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClampTensorOpGenericAdaptorBase;
public:
  AtenClampTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClampTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClampTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClampTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClampTensorOp>>>
  AtenClampTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClampTensorOpAdaptor : public AtenClampTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClampTensorOpGenericAdaptor::AtenClampTensorOpGenericAdaptor;
  AtenClampTensorOpAdaptor(AtenClampTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClampTensorOp : public ::mlir::Op<AtenClampTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClampTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClampTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMin();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClampTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClamp_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClamp_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClamp_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClamp_OpGenericAdaptorBase(AtenClamp_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClamp_OpGenericAdaptor : public detail::AtenClamp_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClamp_OpGenericAdaptorBase;
public:
  AtenClamp_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClamp_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClamp_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClamp_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClamp_Op>>>
  AtenClamp_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClamp_OpAdaptor : public AtenClamp_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClamp_OpGenericAdaptor::AtenClamp_OpGenericAdaptor;
  AtenClamp_OpAdaptor(AtenClamp_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClamp_Op : public ::mlir::Op<AtenClamp_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClamp_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClamp_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getMin();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClamp_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenClamp_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenClamp_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenClamp_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenClamp_TensorOpGenericAdaptorBase(AtenClamp_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenClamp_TensorOpGenericAdaptor : public detail::AtenClamp_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenClamp_TensorOpGenericAdaptorBase;
public:
  AtenClamp_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenClamp_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenClamp_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenClamp_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenClamp_TensorOp>>>
  AtenClamp_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMin() {
    return (*getODSOperands(1).begin());
  }

  ValueT getMax() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenClamp_TensorOpAdaptor : public AtenClamp_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenClamp_TensorOpGenericAdaptor::AtenClamp_TensorOpGenericAdaptor;
  AtenClamp_TensorOpAdaptor(AtenClamp_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenClamp_TensorOp : public ::mlir::Op<AtenClamp_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenClamp_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenClamp_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clamp_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getMin();
  ::mlir::Value getMax();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMinMutable();
  ::mlir::OpOperand &getMaxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value min, ::mlir::Value max);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenClamp_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCloneOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCloneOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCloneOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCloneOpGenericAdaptorBase(AtenCloneOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCloneOpGenericAdaptor : public detail::AtenCloneOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCloneOpGenericAdaptorBase;
public:
  AtenCloneOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCloneOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCloneOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCloneOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCloneOp>>>
  AtenCloneOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMemoryFormat() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCloneOpAdaptor : public AtenCloneOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCloneOpGenericAdaptor::AtenCloneOpGenericAdaptor;
  AtenCloneOpAdaptor(AtenCloneOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCloneOp : public ::mlir::Op<AtenCloneOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCloneOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCloneOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.clone");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getMemoryFormat();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMemoryFormatMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCloneOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConstantPadNdOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConstantPadNdOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConstantPadNdOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConstantPadNdOpGenericAdaptorBase(AtenConstantPadNdOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConstantPadNdOpGenericAdaptor : public detail::AtenConstantPadNdOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConstantPadNdOpGenericAdaptorBase;
public:
  AtenConstantPadNdOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConstantPadNdOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConstantPadNdOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConstantPadNdOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConstantPadNdOp>>>
  AtenConstantPadNdOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getPad() {
    return (*getODSOperands(1).begin());
  }

  ValueT getValue() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConstantPadNdOpAdaptor : public AtenConstantPadNdOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConstantPadNdOpGenericAdaptor::AtenConstantPadNdOpGenericAdaptor;
  AtenConstantPadNdOpAdaptor(AtenConstantPadNdOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConstantPadNdOp : public ::mlir::Op<AtenConstantPadNdOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConstantPadNdOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConstantPadNdOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.constant_pad_nd");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPad();
  ::mlir::Value getValue();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPadMutable();
  ::mlir::OpOperand &getValueMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value pad, ::mlir::Value value);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value pad, ::mlir::Value value);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConstantPadNdOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenContiguousOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenContiguousOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenContiguousOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenContiguousOpGenericAdaptorBase(AtenContiguousOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenContiguousOpGenericAdaptor : public detail::AtenContiguousOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenContiguousOpGenericAdaptorBase;
public:
  AtenContiguousOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenContiguousOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenContiguousOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenContiguousOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenContiguousOp>>>
  AtenContiguousOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getMemoryFormat() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenContiguousOpAdaptor : public AtenContiguousOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenContiguousOpGenericAdaptor::AtenContiguousOpGenericAdaptor;
  AtenContiguousOpAdaptor(AtenContiguousOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenContiguousOp : public ::mlir::Op<AtenContiguousOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenContiguousOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenContiguousOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.contiguous");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getMemoryFormat();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getMemoryFormatMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenContiguousOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConv2dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConv2dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConv2dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConv2dOpGenericAdaptorBase(AtenConv2dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConv2dOpGenericAdaptor : public detail::AtenConv2dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConv2dOpGenericAdaptorBase;
public:
  AtenConv2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConv2dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConv2dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConv2dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConv2dOp>>>
  AtenConv2dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(5).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(6).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConv2dOpAdaptor : public AtenConv2dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConv2dOpGenericAdaptor::AtenConv2dOpGenericAdaptor;
  AtenConv2dOpAdaptor(AtenConv2dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConv2dOp : public ::mlir::Op<AtenConv2dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<7>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConv2dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConv2dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.conv2d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getDilationMutable();
  ::mlir::OpOperand &getGroupsMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value groups);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value groups);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConv2dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConvTranspose1dOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConvTranspose1dOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConvTranspose1dOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConvTranspose1dOpGenericAdaptorBase(AtenConvTranspose1dOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConvTranspose1dOpGenericAdaptor : public detail::AtenConvTranspose1dOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConvTranspose1dOpGenericAdaptorBase;
public:
  AtenConvTranspose1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConvTranspose1dOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConvTranspose1dOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConvTranspose1dOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConvTranspose1dOp>>>
  AtenConvTranspose1dOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getOutputPadding() {
    return (*getODSOperands(5).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(6).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(7).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConvTranspose1dOpAdaptor : public AtenConvTranspose1dOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConvTranspose1dOpGenericAdaptor::AtenConvTranspose1dOpGenericAdaptor;
  AtenConvTranspose1dOpAdaptor(AtenConvTranspose1dOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConvTranspose1dOp : public ::mlir::Op<AtenConvTranspose1dOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<8>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConvTranspose1dOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConvTranspose1dOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.conv_transpose1d");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getOutputPaddingMutable();
  ::mlir::OpOperand &getGroupsMutable();
  ::mlir::OpOperand &getDilationMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConvTranspose1dOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConvTranspose2dInputOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConvTranspose2dInputOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConvTranspose2dInputOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConvTranspose2dInputOpGenericAdaptorBase(AtenConvTranspose2dInputOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConvTranspose2dInputOpGenericAdaptor : public detail::AtenConvTranspose2dInputOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConvTranspose2dInputOpGenericAdaptorBase;
public:
  AtenConvTranspose2dInputOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConvTranspose2dInputOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConvTranspose2dInputOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConvTranspose2dInputOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConvTranspose2dInputOp>>>
  AtenConvTranspose2dInputOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getOutputPadding() {
    return (*getODSOperands(5).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(6).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(7).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConvTranspose2dInputOpAdaptor : public AtenConvTranspose2dInputOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConvTranspose2dInputOpGenericAdaptor::AtenConvTranspose2dInputOpGenericAdaptor;
  AtenConvTranspose2dInputOpAdaptor(AtenConvTranspose2dInputOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConvTranspose2dInputOp : public ::mlir::Op<AtenConvTranspose2dInputOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<8>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConvTranspose2dInputOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConvTranspose2dInputOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.conv_transpose2d.input");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getOutputPaddingMutable();
  ::mlir::OpOperand &getGroupsMutable();
  ::mlir::OpOperand &getDilationMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConvTranspose2dInputOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConvTranspose3dInputOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConvTranspose3dInputOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConvTranspose3dInputOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConvTranspose3dInputOpGenericAdaptorBase(AtenConvTranspose3dInputOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConvTranspose3dInputOpGenericAdaptor : public detail::AtenConvTranspose3dInputOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConvTranspose3dInputOpGenericAdaptorBase;
public:
  AtenConvTranspose3dInputOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConvTranspose3dInputOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConvTranspose3dInputOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConvTranspose3dInputOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConvTranspose3dInputOp>>>
  AtenConvTranspose3dInputOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getOutputPadding() {
    return (*getODSOperands(5).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(6).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(7).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConvTranspose3dInputOpAdaptor : public AtenConvTranspose3dInputOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConvTranspose3dInputOpGenericAdaptor::AtenConvTranspose3dInputOpGenericAdaptor;
  AtenConvTranspose3dInputOpAdaptor(AtenConvTranspose3dInputOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConvTranspose3dInputOp : public ::mlir::Op<AtenConvTranspose3dInputOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<8>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConvTranspose3dInputOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConvTranspose3dInputOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.conv_transpose3d.input");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getOutputPaddingMutable();
  ::mlir::OpOperand &getGroupsMutable();
  ::mlir::OpOperand &getDilationMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value dilation);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConvTranspose3dInputOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConvolutionBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConvolutionBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConvolutionBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConvolutionBackwardOpGenericAdaptorBase(AtenConvolutionBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConvolutionBackwardOpGenericAdaptor : public detail::AtenConvolutionBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConvolutionBackwardOpGenericAdaptorBase;
public:
  AtenConvolutionBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConvolutionBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConvolutionBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConvolutionBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConvolutionBackwardOp>>>
  AtenConvolutionBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getInput() {
    return (*getODSOperands(1).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(2).begin());
  }

  ValueT getBiasSizes() {
    return (*getODSOperands(3).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(4).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(5).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(6).begin());
  }

  ValueT getTransposed() {
    return (*getODSOperands(7).begin());
  }

  ValueT getOutputPadding() {
    return (*getODSOperands(8).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(9).begin());
  }

  ValueT getOutputMask() {
    return (*getODSOperands(10).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConvolutionBackwardOpAdaptor : public AtenConvolutionBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConvolutionBackwardOpGenericAdaptor::AtenConvolutionBackwardOpGenericAdaptor;
  AtenConvolutionBackwardOpAdaptor(AtenConvolutionBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConvolutionBackwardOp : public ::mlir::Op<AtenConvolutionBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<3>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<11>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::OpAsmOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConvolutionBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConvolutionBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  void getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn);
  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.convolution_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBiasSizes();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getTransposed();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputMask();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasSizesMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getDilationMutable();
  ::mlir::OpOperand &getTransposedMutable();
  ::mlir::OpOperand &getOutputPaddingMutable();
  ::mlir::OpOperand &getGroupsMutable();
  ::mlir::OpOperand &getOutputMaskMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult0();
  ::mlir::Value getResult1();
  ::mlir::Value getResult2();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result0, ::mlir::Type result1, ::mlir::Type result2, ::mlir::Value grad_output, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias_sizes, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value transposed, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value output_mask);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias_sizes, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value transposed, ::mlir::Value output_padding, ::mlir::Value groups, ::mlir::Value output_mask);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConvolutionBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenConvolutionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenConvolutionOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenConvolutionOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenConvolutionOpGenericAdaptorBase(AtenConvolutionOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenConvolutionOpGenericAdaptor : public detail::AtenConvolutionOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenConvolutionOpGenericAdaptorBase;
public:
  AtenConvolutionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenConvolutionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenConvolutionOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenConvolutionOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenConvolutionOp>>>
  AtenConvolutionOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(1).begin());
  }

  ValueT getBias() {
    return (*getODSOperands(2).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPadding() {
    return (*getODSOperands(4).begin());
  }

  ValueT getDilation() {
    return (*getODSOperands(5).begin());
  }

  ValueT getTransposed() {
    return (*getODSOperands(6).begin());
  }

  ValueT getOutputPadding() {
    return (*getODSOperands(7).begin());
  }

  ValueT getGroups() {
    return (*getODSOperands(8).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenConvolutionOpAdaptor : public AtenConvolutionOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenConvolutionOpGenericAdaptor::AtenConvolutionOpGenericAdaptor;
  AtenConvolutionOpAdaptor(AtenConvolutionOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenConvolutionOp : public ::mlir::Op<AtenConvolutionOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<9>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenConvolutionOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenConvolutionOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.convolution");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::Value getWeight();
  ::mlir::Value getBias();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getDilation();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getTransposed();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getOutputPadding();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getGroups();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getBiasMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getPaddingMutable();
  ::mlir::OpOperand &getDilationMutable();
  ::mlir::OpOperand &getTransposedMutable();
  ::mlir::OpOperand &getOutputPaddingMutable();
  ::mlir::OpOperand &getGroupsMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value transposed, ::mlir::Value output_padding, ::mlir::Value groups);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value weight, ::mlir::Value bias, ::mlir::Value stride, ::mlir::Value padding, ::mlir::Value dilation, ::mlir::Value transposed, ::mlir::Value output_padding, ::mlir::Value groups);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenConvolutionOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCopyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCopyOpGenericAdaptorBase(AtenCopyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCopyOpGenericAdaptor : public detail::AtenCopyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCopyOpGenericAdaptorBase;
public:
  AtenCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCopyOp>>>
  AtenCopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSrc() {
    return (*getODSOperands(1).begin());
  }

  ValueT getNonBlocking() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCopyOpAdaptor : public AtenCopyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCopyOpGenericAdaptor::AtenCopyOpGenericAdaptor;
  AtenCopyOpAdaptor(AtenCopyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCopyOp : public ::mlir::Op<AtenCopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCopyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCopyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.copy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getSrc();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getNonBlocking();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSrcMutable();
  ::mlir::OpOperand &getNonBlockingMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value src, ::mlir::Value non_blocking);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value src, ::mlir::Value non_blocking);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCopyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCopy_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCopy_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCopy_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCopy_OpGenericAdaptorBase(AtenCopy_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCopy_OpGenericAdaptor : public detail::AtenCopy_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCopy_OpGenericAdaptorBase;
public:
  AtenCopy_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCopy_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCopy_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCopy_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCopy_Op>>>
  AtenCopy_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSrc() {
    return (*getODSOperands(1).begin());
  }

  ValueT getNonBlocking() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCopy_OpAdaptor : public AtenCopy_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCopy_OpGenericAdaptor::AtenCopy_OpGenericAdaptor;
  AtenCopy_OpAdaptor(AtenCopy_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCopy_Op : public ::mlir::Op<AtenCopy_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCopy_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCopy_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.copy_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSrc();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getNonBlocking();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSrcMutable();
  ::mlir::OpOperand &getNonBlockingMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value src, ::mlir::Value non_blocking);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value src, ::mlir::Value non_blocking);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCopy_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCosOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCosOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCosOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCosOpGenericAdaptorBase(AtenCosOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCosOpGenericAdaptor : public detail::AtenCosOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCosOpGenericAdaptorBase;
public:
  AtenCosOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCosOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCosOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCosOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCosOp>>>
  AtenCosOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCosOpAdaptor : public AtenCosOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCosOpGenericAdaptor::AtenCosOpGenericAdaptor;
  AtenCosOpAdaptor(AtenCosOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCosOp : public ::mlir::Op<AtenCosOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCosOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCosOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cos");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCosOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCos_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCos_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCos_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCos_OpGenericAdaptorBase(AtenCos_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCos_OpGenericAdaptor : public detail::AtenCos_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCos_OpGenericAdaptorBase;
public:
  AtenCos_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCos_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCos_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCos_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCos_Op>>>
  AtenCos_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCos_OpAdaptor : public AtenCos_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCos_OpGenericAdaptor::AtenCos_OpGenericAdaptor;
  AtenCos_OpAdaptor(AtenCos_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCos_Op : public ::mlir::Op<AtenCos_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCos_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCos_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cos_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCos_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCoshOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCoshOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCoshOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCoshOpGenericAdaptorBase(AtenCoshOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCoshOpGenericAdaptor : public detail::AtenCoshOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCoshOpGenericAdaptorBase;
public:
  AtenCoshOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCoshOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCoshOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCoshOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCoshOp>>>
  AtenCoshOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCoshOpAdaptor : public AtenCoshOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCoshOpGenericAdaptor::AtenCoshOpGenericAdaptor;
  AtenCoshOpAdaptor(AtenCoshOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCoshOp : public ::mlir::Op<AtenCoshOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCoshOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCoshOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cosh");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCoshOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCosh_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCosh_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCosh_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCosh_OpGenericAdaptorBase(AtenCosh_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCosh_OpGenericAdaptor : public detail::AtenCosh_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCosh_OpGenericAdaptorBase;
public:
  AtenCosh_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCosh_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCosh_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCosh_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCosh_Op>>>
  AtenCosh_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCosh_OpAdaptor : public AtenCosh_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCosh_OpGenericAdaptor::AtenCosh_OpGenericAdaptor;
  AtenCosh_OpAdaptor(AtenCosh_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCosh_Op : public ::mlir::Op<AtenCosh_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCosh_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCosh_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cosh_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCosh_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCosineEmbeddingLossOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCosineEmbeddingLossOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCosineEmbeddingLossOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCosineEmbeddingLossOpGenericAdaptorBase(AtenCosineEmbeddingLossOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCosineEmbeddingLossOpGenericAdaptor : public detail::AtenCosineEmbeddingLossOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCosineEmbeddingLossOpGenericAdaptorBase;
public:
  AtenCosineEmbeddingLossOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCosineEmbeddingLossOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCosineEmbeddingLossOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCosineEmbeddingLossOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCosineEmbeddingLossOp>>>
  AtenCosineEmbeddingLossOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput1() {
    return (*getODSOperands(0).begin());
  }

  ValueT getInput2() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTarget() {
    return (*getODSOperands(2).begin());
  }

  ValueT getMargin() {
    return (*getODSOperands(3).begin());
  }

  ValueT getReduction() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCosineEmbeddingLossOpAdaptor : public AtenCosineEmbeddingLossOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCosineEmbeddingLossOpGenericAdaptor::AtenCosineEmbeddingLossOpGenericAdaptor;
  AtenCosineEmbeddingLossOpAdaptor(AtenCosineEmbeddingLossOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCosineEmbeddingLossOp : public ::mlir::Op<AtenCosineEmbeddingLossOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCosineEmbeddingLossOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCosineEmbeddingLossOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cosine_embedding_loss");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput1();
  ::mlir::Value getInput2();
  ::mlir::Value getTarget();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getMargin();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getReduction();
  ::mlir::OpOperand &getInput1Mutable();
  ::mlir::OpOperand &getInput2Mutable();
  ::mlir::OpOperand &getTargetMutable();
  ::mlir::OpOperand &getMarginMutable();
  ::mlir::OpOperand &getReductionMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input1, ::mlir::Value input2, ::mlir::Value target, ::mlir::Value margin, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input1, ::mlir::Value input2, ::mlir::Value target, ::mlir::Value margin, ::mlir::Value reduction);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCosineEmbeddingLossOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCosineSimilarityOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCosineSimilarityOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCosineSimilarityOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCosineSimilarityOpGenericAdaptorBase(AtenCosineSimilarityOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCosineSimilarityOpGenericAdaptor : public detail::AtenCosineSimilarityOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCosineSimilarityOpGenericAdaptorBase;
public:
  AtenCosineSimilarityOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCosineSimilarityOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCosineSimilarityOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCosineSimilarityOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCosineSimilarityOp>>>
  AtenCosineSimilarityOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getX1() {
    return (*getODSOperands(0).begin());
  }

  ValueT getX2() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(2).begin());
  }

  ValueT getEps() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCosineSimilarityOpAdaptor : public AtenCosineSimilarityOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCosineSimilarityOpGenericAdaptor::AtenCosineSimilarityOpGenericAdaptor;
  AtenCosineSimilarityOpAdaptor(AtenCosineSimilarityOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCosineSimilarityOp : public ::mlir::Op<AtenCosineSimilarityOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCosineSimilarityOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCosineSimilarityOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cosine_similarity");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getX1();
  ::mlir::Value getX2();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getEps();
  ::mlir::OpOperand &getX1Mutable();
  ::mlir::OpOperand &getX2Mutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getEpsMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value x1, ::mlir::Value x2, ::mlir::Value dim, ::mlir::Value eps);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value x1, ::mlir::Value x2, ::mlir::Value dim, ::mlir::Value eps);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCosineSimilarityOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCpuOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCpuOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCpuOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCpuOpGenericAdaptorBase(AtenCpuOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCpuOpGenericAdaptor : public detail::AtenCpuOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCpuOpGenericAdaptorBase;
public:
  AtenCpuOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCpuOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCpuOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCpuOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCpuOp>>>
  AtenCpuOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCpuOpAdaptor : public AtenCpuOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCpuOpGenericAdaptor::AtenCpuOpGenericAdaptor;
  AtenCpuOpAdaptor(AtenCpuOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCpuOp : public ::mlir::Op<AtenCpuOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCpuOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCpuOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cpu");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCpuOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCrossEntropyLossOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCrossEntropyLossOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCrossEntropyLossOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCrossEntropyLossOpGenericAdaptorBase(AtenCrossEntropyLossOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCrossEntropyLossOpGenericAdaptor : public detail::AtenCrossEntropyLossOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCrossEntropyLossOpGenericAdaptorBase;
public:
  AtenCrossEntropyLossOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCrossEntropyLossOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCrossEntropyLossOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCrossEntropyLossOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCrossEntropyLossOp>>>
  AtenCrossEntropyLossOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTarget() {
    return (*getODSOperands(1).begin());
  }

  ValueT getWeight() {
    return (*getODSOperands(2).begin());
  }

  ValueT getReduction() {
    return (*getODSOperands(3).begin());
  }

  ValueT getIgnoreIndex() {
    return (*getODSOperands(4).begin());
  }

  ValueT getLabelSmoothing() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCrossEntropyLossOpAdaptor : public AtenCrossEntropyLossOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCrossEntropyLossOpGenericAdaptor::AtenCrossEntropyLossOpGenericAdaptor;
  AtenCrossEntropyLossOpAdaptor(AtenCrossEntropyLossOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCrossEntropyLossOp : public ::mlir::Op<AtenCrossEntropyLossOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCrossEntropyLossOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCrossEntropyLossOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cross_entropy_loss");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getTarget();
  ::mlir::Value getWeight();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getReduction();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getIgnoreIndex();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getLabelSmoothing();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getTargetMutable();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getReductionMutable();
  ::mlir::OpOperand &getIgnoreIndexMutable();
  ::mlir::OpOperand &getLabelSmoothingMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction, ::mlir::Value ignore_index, ::mlir::Value label_smoothing);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value target, ::mlir::Value weight, ::mlir::Value reduction, ::mlir::Value ignore_index, ::mlir::Value label_smoothing);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCrossEntropyLossOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCudaOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCudaOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCudaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCudaOpGenericAdaptorBase(AtenCudaOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCudaOpGenericAdaptor : public detail::AtenCudaOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCudaOpGenericAdaptorBase;
public:
  AtenCudaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCudaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCudaOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCudaOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCudaOp>>>
  AtenCudaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCudaOpAdaptor : public AtenCudaOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCudaOpGenericAdaptor::AtenCudaOpGenericAdaptor;
  AtenCudaOpAdaptor(AtenCudaOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCudaOp : public ::mlir::Op<AtenCudaOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCudaOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCudaOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cuda");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCudaOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCumprodOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCumprodOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCumprodOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCumprodOpGenericAdaptorBase(AtenCumprodOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCumprodOpGenericAdaptor : public detail::AtenCumprodOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCumprodOpGenericAdaptorBase;
public:
  AtenCumprodOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCumprodOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCumprodOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCumprodOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCumprodOp>>>
  AtenCumprodOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCumprodOpAdaptor : public AtenCumprodOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCumprodOpGenericAdaptor::AtenCumprodOpGenericAdaptor;
  AtenCumprodOpAdaptor(AtenCumprodOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCumprodOp : public ::mlir::Op<AtenCumprodOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCumprodOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCumprodOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cumprod");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::Value getDtype();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getDtypeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value dtype);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value dtype);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCumprodOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenCumsumOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenCumsumOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenCumsumOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenCumsumOpGenericAdaptorBase(AtenCumsumOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenCumsumOpGenericAdaptor : public detail::AtenCumsumOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenCumsumOpGenericAdaptorBase;
public:
  AtenCumsumOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenCumsumOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenCumsumOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenCumsumOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenCumsumOp>>>
  AtenCumsumOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDim() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenCumsumOpAdaptor : public AtenCumsumOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenCumsumOpGenericAdaptor::AtenCumsumOpGenericAdaptor;
  AtenCumsumOpAdaptor(AtenCumsumOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenCumsumOp : public ::mlir::Op<AtenCumsumOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenCumsumOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenCumsumOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.cumsum");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim();
  ::mlir::Value getDtype();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDimMutable();
  ::mlir::OpOperand &getDtypeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value dtype);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dim, ::mlir::Value dtype);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenCumsumOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDeleteDictStrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDeleteDictStrOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDeleteDictStrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDeleteDictStrOpGenericAdaptorBase(AtenDeleteDictStrOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDeleteDictStrOpGenericAdaptor : public detail::AtenDeleteDictStrOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDeleteDictStrOpGenericAdaptorBase;
public:
  AtenDeleteDictStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDeleteDictStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDeleteDictStrOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDeleteDictStrOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDeleteDictStrOp>>>
  AtenDeleteDictStrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getKey() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDeleteDictStrOpAdaptor : public AtenDeleteDictStrOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDeleteDictStrOpGenericAdaptor::AtenDeleteDictStrOpGenericAdaptor;
  AtenDeleteDictStrOpAdaptor(AtenDeleteDictStrOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDeleteDictStrOp : public ::mlir::Op<AtenDeleteDictStrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDeleteDictStrOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDeleteDictStrOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.Delete.Dict_str");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::DictType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getKey();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getKeyMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value self, ::mlir::Value key);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value key);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDeleteDictStrOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDetachCopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDetachCopyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDetachCopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDetachCopyOpGenericAdaptorBase(AtenDetachCopyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDetachCopyOpGenericAdaptor : public detail::AtenDetachCopyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDetachCopyOpGenericAdaptorBase;
public:
  AtenDetachCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDetachCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDetachCopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDetachCopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDetachCopyOp>>>
  AtenDetachCopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDetachCopyOpAdaptor : public AtenDetachCopyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDetachCopyOpGenericAdaptor::AtenDetachCopyOpGenericAdaptor;
  AtenDetachCopyOpAdaptor(AtenDetachCopyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDetachCopyOp : public ::mlir::Op<AtenDetachCopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDetachCopyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDetachCopyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.detach_copy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDetachCopyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDetachOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDetachOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDetachOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDetachOpGenericAdaptorBase(AtenDetachOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDetachOpGenericAdaptor : public detail::AtenDetachOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDetachOpGenericAdaptorBase;
public:
  AtenDetachOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDetachOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDetachOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDetachOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDetachOp>>>
  AtenDetachOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDetachOpAdaptor : public AtenDetachOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDetachOpGenericAdaptor::AtenDetachOpGenericAdaptor;
  AtenDetachOpAdaptor(AtenDetachOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDetachOp : public ::mlir::Op<AtenDetachOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDetachOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDetachOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.detach");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDetachOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDeviceWithIndexOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDeviceWithIndexOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDeviceWithIndexOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDeviceWithIndexOpGenericAdaptorBase(AtenDeviceWithIndexOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDeviceWithIndexOpGenericAdaptor : public detail::AtenDeviceWithIndexOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDeviceWithIndexOpGenericAdaptorBase;
public:
  AtenDeviceWithIndexOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDeviceWithIndexOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDeviceWithIndexOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDeviceWithIndexOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDeviceWithIndexOp>>>
  AtenDeviceWithIndexOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getType() {
    return (*getODSOperands(0).begin());
  }

  ValueT getIndex() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDeviceWithIndexOpAdaptor : public AtenDeviceWithIndexOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDeviceWithIndexOpGenericAdaptor::AtenDeviceWithIndexOpGenericAdaptor;
  AtenDeviceWithIndexOpAdaptor(AtenDeviceWithIndexOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDeviceWithIndexOp : public ::mlir::Op<AtenDeviceWithIndexOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::DeviceType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDeviceWithIndexOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDeviceWithIndexOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.device.with_index");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getType();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getIndex();
  ::mlir::OpOperand &getTypeMutable();
  ::mlir::OpOperand &getIndexMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::DeviceType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value type, ::mlir::Value index);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value type, ::mlir::Value index);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value type, ::mlir::Value index);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDeviceWithIndexOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDiagonalCopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDiagonalCopyOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDiagonalCopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDiagonalCopyOpGenericAdaptorBase(AtenDiagonalCopyOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDiagonalCopyOpGenericAdaptor : public detail::AtenDiagonalCopyOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDiagonalCopyOpGenericAdaptorBase;
public:
  AtenDiagonalCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDiagonalCopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDiagonalCopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDiagonalCopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDiagonalCopyOp>>>
  AtenDiagonalCopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOffset() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDim1() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDim2() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDiagonalCopyOpAdaptor : public AtenDiagonalCopyOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDiagonalCopyOpGenericAdaptor::AtenDiagonalCopyOpGenericAdaptor;
  AtenDiagonalCopyOpAdaptor(AtenDiagonalCopyOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDiagonalCopyOp : public ::mlir::Op<AtenDiagonalCopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDiagonalCopyOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDiagonalCopyOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.diagonal_copy");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getOffset();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim1();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim2();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOffsetMutable();
  ::mlir::OpOperand &getDim1Mutable();
  ::mlir::OpOperand &getDim2Mutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value offset, ::mlir::Value dim1, ::mlir::Value dim2);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value offset, ::mlir::Value dim1, ::mlir::Value dim2);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDiagonalCopyOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDiagonalScatterOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDiagonalScatterOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDiagonalScatterOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDiagonalScatterOpGenericAdaptorBase(AtenDiagonalScatterOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDiagonalScatterOpGenericAdaptor : public detail::AtenDiagonalScatterOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDiagonalScatterOpGenericAdaptorBase;
public:
  AtenDiagonalScatterOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDiagonalScatterOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDiagonalScatterOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDiagonalScatterOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDiagonalScatterOp>>>
  AtenDiagonalScatterOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getSrc() {
    return (*getODSOperands(1).begin());
  }

  ValueT getOffset() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDim1() {
    return (*getODSOperands(3).begin());
  }

  ValueT getDim2() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDiagonalScatterOpAdaptor : public AtenDiagonalScatterOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDiagonalScatterOpGenericAdaptor::AtenDiagonalScatterOpGenericAdaptor;
  AtenDiagonalScatterOpAdaptor(AtenDiagonalScatterOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDiagonalScatterOp : public ::mlir::Op<AtenDiagonalScatterOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDiagonalScatterOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDiagonalScatterOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.diagonal_scatter");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getSrc();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getOffset();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim1();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getDim2();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getSrcMutable();
  ::mlir::OpOperand &getOffsetMutable();
  ::mlir::OpOperand &getDim1Mutable();
  ::mlir::OpOperand &getDim2Mutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value src, ::mlir::Value offset, ::mlir::Value dim1, ::mlir::Value dim2);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value src, ::mlir::Value offset, ::mlir::Value dim1, ::mlir::Value dim2);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDiagonalScatterOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDimOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDimOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDimOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDimOpGenericAdaptorBase(AtenDimOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDimOpGenericAdaptor : public detail::AtenDimOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDimOpGenericAdaptorBase;
public:
  AtenDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDimOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDimOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDimOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDimOp>>>
  AtenDimOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDimOpAdaptor : public AtenDimOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDimOpGenericAdaptor::AtenDimOpGenericAdaptor;
  AtenDimOpAdaptor(AtenDimOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDimOp : public ::mlir::Op<AtenDimOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::IntType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDimOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDimOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.dim");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::OpOperand &getSelfMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value self);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDimOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivFloatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivFloatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivFloatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivFloatOpGenericAdaptorBase(AtenDivFloatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivFloatOpGenericAdaptor : public detail::AtenDivFloatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivFloatOpGenericAdaptorBase;
public:
  AtenDivFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivFloatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivFloatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivFloatOp>>>
  AtenDivFloatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivFloatOpAdaptor : public AtenDivFloatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivFloatOpGenericAdaptor::AtenDivFloatOpGenericAdaptor;
  AtenDivFloatOpAdaptor(AtenDivFloatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivFloatOp : public ::mlir::Op<AtenDivFloatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivFloatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivFloatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div.float");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivFloatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivIntOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivIntOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivIntOpGenericAdaptorBase(AtenDivIntOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivIntOpGenericAdaptor : public detail::AtenDivIntOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivIntOpGenericAdaptorBase;
public:
  AtenDivIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivIntOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivIntOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivIntOp>>>
  AtenDivIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivIntOpAdaptor : public AtenDivIntOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivIntOpGenericAdaptor::AtenDivIntOpGenericAdaptor;
  AtenDivIntOpAdaptor(AtenDivIntOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivIntOp : public ::mlir::Op<AtenDivIntOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivIntOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivIntOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div.int");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivIntOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivOpGenericAdaptorBase(AtenDivOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivOpGenericAdaptor : public detail::AtenDivOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivOpGenericAdaptorBase;
public:
  AtenDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivOp>>>
  AtenDivOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivOpAdaptor : public AtenDivOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivOpGenericAdaptor::AtenDivOpGenericAdaptor;
  AtenDivOpAdaptor(AtenDivOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivOp : public ::mlir::Op<AtenDivOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getA();
  ::mlir::Value getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivScalarOpGenericAdaptorBase(AtenDivScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivScalarOpGenericAdaptor : public detail::AtenDivScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivScalarOpGenericAdaptorBase;
public:
  AtenDivScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivScalarOp>>>
  AtenDivScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivScalarOpAdaptor : public AtenDivScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivScalarOpGenericAdaptor::AtenDivScalarOpGenericAdaptor;
  AtenDivScalarOpAdaptor(AtenDivScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivScalarOp : public ::mlir::Op<AtenDivScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivTensorModeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivTensorModeOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivTensorModeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivTensorModeOpGenericAdaptorBase(AtenDivTensorModeOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivTensorModeOpGenericAdaptor : public detail::AtenDivTensorModeOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivTensorModeOpGenericAdaptorBase;
public:
  AtenDivTensorModeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivTensorModeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivTensorModeOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivTensorModeOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivTensorModeOp>>>
  AtenDivTensorModeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getRoundingMode() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivTensorModeOpAdaptor : public AtenDivTensorModeOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivTensorModeOpGenericAdaptor::AtenDivTensorModeOpGenericAdaptor;
  AtenDivTensorModeOpAdaptor(AtenDivTensorModeOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivTensorModeOp : public ::mlir::Op<AtenDivTensorModeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivTensorModeOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivTensorModeOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div.Tensor_mode");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::Value getRoundingMode();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getRoundingModeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value rounding_mode);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value rounding_mode);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivTensorModeOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDivTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDivTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDivTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDivTensorOpGenericAdaptorBase(AtenDivTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDivTensorOpGenericAdaptor : public detail::AtenDivTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDivTensorOpGenericAdaptorBase;
public:
  AtenDivTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDivTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDivTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDivTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDivTensorOp>>>
  AtenDivTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDivTensorOpAdaptor : public AtenDivTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDivTensorOpGenericAdaptor::AtenDivTensorOpGenericAdaptor;
  AtenDivTensorOpAdaptor(AtenDivTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDivTensorOp : public ::mlir::Op<AtenDivTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDivTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDivTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDivTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDiv_ScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDiv_ScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDiv_ScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDiv_ScalarOpGenericAdaptorBase(AtenDiv_ScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDiv_ScalarOpGenericAdaptor : public detail::AtenDiv_ScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDiv_ScalarOpGenericAdaptorBase;
public:
  AtenDiv_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDiv_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDiv_ScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDiv_ScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDiv_ScalarOp>>>
  AtenDiv_ScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDiv_ScalarOpAdaptor : public AtenDiv_ScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDiv_ScalarOpGenericAdaptor::AtenDiv_ScalarOpGenericAdaptor;
  AtenDiv_ScalarOpAdaptor(AtenDiv_ScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDiv_ScalarOp : public ::mlir::Op<AtenDiv_ScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDiv_ScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDiv_ScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div_.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDiv_ScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDiv_TensorModeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDiv_TensorModeOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDiv_TensorModeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDiv_TensorModeOpGenericAdaptorBase(AtenDiv_TensorModeOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDiv_TensorModeOpGenericAdaptor : public detail::AtenDiv_TensorModeOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDiv_TensorModeOpGenericAdaptorBase;
public:
  AtenDiv_TensorModeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDiv_TensorModeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDiv_TensorModeOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDiv_TensorModeOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDiv_TensorModeOp>>>
  AtenDiv_TensorModeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  ValueT getRoundingMode() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDiv_TensorModeOpAdaptor : public AtenDiv_TensorModeOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDiv_TensorModeOpGenericAdaptor::AtenDiv_TensorModeOpGenericAdaptor;
  AtenDiv_TensorModeOpAdaptor(AtenDiv_TensorModeOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDiv_TensorModeOp : public ::mlir::Op<AtenDiv_TensorModeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDiv_TensorModeOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDiv_TensorModeOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div_.Tensor_mode");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::Value getRoundingMode();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  ::mlir::OpOperand &getRoundingModeMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other, ::mlir::Value rounding_mode);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other, ::mlir::Value rounding_mode);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDiv_TensorModeOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDiv_TensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDiv_TensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDiv_TensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDiv_TensorOpGenericAdaptorBase(AtenDiv_TensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDiv_TensorOpGenericAdaptor : public detail::AtenDiv_TensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDiv_TensorOpGenericAdaptorBase;
public:
  AtenDiv_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDiv_TensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDiv_TensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDiv_TensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDiv_TensorOp>>>
  AtenDiv_TensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDiv_TensorOpAdaptor : public AtenDiv_TensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDiv_TensorOpGenericAdaptor::AtenDiv_TensorOpGenericAdaptor;
  AtenDiv_TensorOpAdaptor(AtenDiv_TensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDiv_TensorOp : public ::mlir::Op<AtenDiv_TensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDiv_TensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDiv_TensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.div_.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDiv_TensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDropoutOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDropoutOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDropoutOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDropoutOpGenericAdaptorBase(AtenDropoutOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDropoutOpGenericAdaptor : public detail::AtenDropoutOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDropoutOpGenericAdaptorBase;
public:
  AtenDropoutOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDropoutOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDropoutOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDropoutOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDropoutOp>>>
  AtenDropoutOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getInput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTrain() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDropoutOpAdaptor : public AtenDropoutOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDropoutOpGenericAdaptor::AtenDropoutOpGenericAdaptor;
  AtenDropoutOpAdaptor(AtenDropoutOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDropoutOp : public ::mlir::Op<AtenDropoutOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDropoutOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDropoutOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.dropout");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getInput();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getP();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getTrain();
  ::mlir::OpOperand &getInputMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getTrainMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value input, ::mlir::Value p, ::mlir::Value train);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value input, ::mlir::Value p, ::mlir::Value train);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDropoutOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenDropout_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenDropout_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenDropout_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenDropout_OpGenericAdaptorBase(AtenDropout_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenDropout_OpGenericAdaptor : public detail::AtenDropout_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenDropout_OpGenericAdaptorBase;
public:
  AtenDropout_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenDropout_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenDropout_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenDropout_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenDropout_Op>>>
  AtenDropout_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getP() {
    return (*getODSOperands(1).begin());
  }

  ValueT getTrain() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenDropout_OpAdaptor : public AtenDropout_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenDropout_OpGenericAdaptor::AtenDropout_OpGenericAdaptor;
  AtenDropout_OpAdaptor(AtenDropout_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenDropout_Op : public ::mlir::Op<AtenDropout_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenDropout_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenDropout_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.dropout_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getP();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getTrain();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getPMutable();
  ::mlir::OpOperand &getTrainMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value p, ::mlir::Value train);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value p, ::mlir::Value train);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenDropout_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEinsumOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEinsumOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEinsumOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEinsumOpGenericAdaptorBase(AtenEinsumOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEinsumOpGenericAdaptor : public detail::AtenEinsumOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEinsumOpGenericAdaptorBase;
public:
  AtenEinsumOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEinsumOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEinsumOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEinsumOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEinsumOp>>>
  AtenEinsumOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getEquation() {
    return (*getODSOperands(0).begin());
  }

  ValueT getTensors() {
    return (*getODSOperands(1).begin());
  }

  ValueT getPath() {
    return (*getODSOperands(2).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEinsumOpAdaptor : public AtenEinsumOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEinsumOpGenericAdaptor::AtenEinsumOpGenericAdaptor;
  AtenEinsumOpAdaptor(AtenEinsumOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEinsumOp : public ::mlir::Op<AtenEinsumOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEinsumOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEinsumOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.einsum");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getEquation();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getTensors();
  ::mlir::Value getPath();
  ::mlir::OpOperand &getEquationMutable();
  ::mlir::OpOperand &getTensorsMutable();
  ::mlir::OpOperand &getPathMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value equation, ::mlir::Value tensors, ::mlir::Value path);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value equation, ::mlir::Value tensors, ::mlir::Value path);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEinsumOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEluBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEluBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEluBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEluBackwardOpGenericAdaptorBase(AtenEluBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEluBackwardOpGenericAdaptor : public detail::AtenEluBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEluBackwardOpGenericAdaptorBase;
public:
  AtenEluBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEluBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEluBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEluBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEluBackwardOp>>>
  AtenEluBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(1).begin());
  }

  ValueT getScale() {
    return (*getODSOperands(2).begin());
  }

  ValueT getInputScale() {
    return (*getODSOperands(3).begin());
  }

  ValueT getIsResult() {
    return (*getODSOperands(4).begin());
  }

  ValueT getSelfOrResult() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEluBackwardOpAdaptor : public AtenEluBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEluBackwardOpGenericAdaptor::AtenEluBackwardOpGenericAdaptor;
  AtenEluBackwardOpAdaptor(AtenEluBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEluBackwardOp : public ::mlir::Op<AtenEluBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEluBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEluBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.elu_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getAlpha();
  ::mlir::Value getScale();
  ::mlir::Value getInputScale();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getIsResult();
  ::mlir::Value getSelfOrResult();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getAlphaMutable();
  ::mlir::OpOperand &getScaleMutable();
  ::mlir::OpOperand &getInputScaleMutable();
  ::mlir::OpOperand &getIsResultMutable();
  ::mlir::OpOperand &getSelfOrResultMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value grad_output, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale, ::mlir::Value is_result, ::mlir::Value self_or_result);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale, ::mlir::Value is_result, ::mlir::Value self_or_result);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEluBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEluOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEluOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEluOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEluOpGenericAdaptorBase(AtenEluOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEluOpGenericAdaptor : public detail::AtenEluOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEluOpGenericAdaptorBase;
public:
  AtenEluOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEluOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEluOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEluOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEluOp>>>
  AtenEluOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(1).begin());
  }

  ValueT getScale() {
    return (*getODSOperands(2).begin());
  }

  ValueT getInputScale() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEluOpAdaptor : public AtenEluOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEluOpGenericAdaptor::AtenEluOpGenericAdaptor;
  AtenEluOpAdaptor(AtenEluOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEluOp : public ::mlir::Op<AtenEluOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEluOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEluOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.elu");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getAlpha();
  ::mlir::Value getScale();
  ::mlir::Value getInputScale();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getAlphaMutable();
  ::mlir::OpOperand &getScaleMutable();
  ::mlir::OpOperand &getInputScaleMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEluOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenElu_Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenElu_OpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenElu_OpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenElu_OpGenericAdaptorBase(AtenElu_Op op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenElu_OpGenericAdaptor : public detail::AtenElu_OpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenElu_OpGenericAdaptorBase;
public:
  AtenElu_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenElu_OpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenElu_OpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenElu_Op, typename = std::enable_if_t<std::is_same_v<LateInst, AtenElu_Op>>>
  AtenElu_OpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getAlpha() {
    return (*getODSOperands(1).begin());
  }

  ValueT getScale() {
    return (*getODSOperands(2).begin());
  }

  ValueT getInputScale() {
    return (*getODSOperands(3).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenElu_OpAdaptor : public AtenElu_OpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenElu_OpGenericAdaptor::AtenElu_OpGenericAdaptor;
  AtenElu_OpAdaptor(AtenElu_Op op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenElu_Op : public ::mlir::Op<AtenElu_Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenElu_OpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenElu_OpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.elu_");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getAlpha();
  ::mlir::Value getScale();
  ::mlir::Value getInputScale();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getAlphaMutable();
  ::mlir::OpOperand &getScaleMutable();
  ::mlir::OpOperand &getInputScaleMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value alpha, ::mlir::Value scale, ::mlir::Value input_scale);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenElu_Op)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmbeddingBagPaddingIdxOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmbeddingBagPaddingIdxOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmbeddingBagPaddingIdxOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmbeddingBagPaddingIdxOpGenericAdaptorBase(AtenEmbeddingBagPaddingIdxOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmbeddingBagPaddingIdxOpGenericAdaptor : public detail::AtenEmbeddingBagPaddingIdxOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmbeddingBagPaddingIdxOpGenericAdaptorBase;
public:
  AtenEmbeddingBagPaddingIdxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmbeddingBagPaddingIdxOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmbeddingBagPaddingIdxOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmbeddingBagPaddingIdxOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmbeddingBagPaddingIdxOp>>>
  AtenEmbeddingBagPaddingIdxOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getWeight() {
    return (*getODSOperands(0).begin());
  }

  ValueT getIndices() {
    return (*getODSOperands(1).begin());
  }

  ValueT getOffsets() {
    return (*getODSOperands(2).begin());
  }

  ValueT getScaleGradByFreq() {
    return (*getODSOperands(3).begin());
  }

  ValueT getMode() {
    return (*getODSOperands(4).begin());
  }

  ValueT getSparse() {
    return (*getODSOperands(5).begin());
  }

  ValueT getPerSampleWeights() {
    return (*getODSOperands(6).begin());
  }

  ValueT getIncludeLastOffset() {
    return (*getODSOperands(7).begin());
  }

  ValueT getPaddingIdx() {
    return (*getODSOperands(8).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmbeddingBagPaddingIdxOpAdaptor : public AtenEmbeddingBagPaddingIdxOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmbeddingBagPaddingIdxOpGenericAdaptor::AtenEmbeddingBagPaddingIdxOpGenericAdaptor;
  AtenEmbeddingBagPaddingIdxOpAdaptor(AtenEmbeddingBagPaddingIdxOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmbeddingBagPaddingIdxOp : public ::mlir::Op<AtenEmbeddingBagPaddingIdxOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<4>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<9>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::OpAsmOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmbeddingBagPaddingIdxOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmbeddingBagPaddingIdxOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  void getAsmResultNames(::mlir::OpAsmSetValueNameFn setNameFn);
  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.embedding_bag.padding_idx");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getWeight();
  ::mlir::Value getIndices();
  ::mlir::Value getOffsets();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getScaleGradByFreq();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getMode();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getSparse();
  ::mlir::Value getPerSampleWeights();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getIncludeLastOffset();
  ::mlir::Value getPaddingIdx();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getIndicesMutable();
  ::mlir::OpOperand &getOffsetsMutable();
  ::mlir::OpOperand &getScaleGradByFreqMutable();
  ::mlir::OpOperand &getModeMutable();
  ::mlir::OpOperand &getSparseMutable();
  ::mlir::OpOperand &getPerSampleWeightsMutable();
  ::mlir::OpOperand &getIncludeLastOffsetMutable();
  ::mlir::OpOperand &getPaddingIdxMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult0();
  ::mlir::Value getResult1();
  ::mlir::Value getResult2();
  ::mlir::Value getResult3();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result0, ::mlir::Type result1, ::mlir::Type result2, ::mlir::Type result3, ::mlir::Value weight, ::mlir::Value indices, ::mlir::Value offsets, ::mlir::Value scale_grad_by_freq, ::mlir::Value mode, ::mlir::Value sparse, ::mlir::Value per_sample_weights, ::mlir::Value include_last_offset, ::mlir::Value padding_idx);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value weight, ::mlir::Value indices, ::mlir::Value offsets, ::mlir::Value scale_grad_by_freq, ::mlir::Value mode, ::mlir::Value sparse, ::mlir::Value per_sample_weights, ::mlir::Value include_last_offset, ::mlir::Value padding_idx);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmbeddingBagPaddingIdxOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmbeddingDenseBackwardOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmbeddingDenseBackwardOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmbeddingDenseBackwardOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmbeddingDenseBackwardOpGenericAdaptorBase(AtenEmbeddingDenseBackwardOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmbeddingDenseBackwardOpGenericAdaptor : public detail::AtenEmbeddingDenseBackwardOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmbeddingDenseBackwardOpGenericAdaptorBase;
public:
  AtenEmbeddingDenseBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmbeddingDenseBackwardOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmbeddingDenseBackwardOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmbeddingDenseBackwardOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmbeddingDenseBackwardOp>>>
  AtenEmbeddingDenseBackwardOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getGradOutput() {
    return (*getODSOperands(0).begin());
  }

  ValueT getIndices() {
    return (*getODSOperands(1).begin());
  }

  ValueT getNumWeights() {
    return (*getODSOperands(2).begin());
  }

  ValueT getPaddingIdx() {
    return (*getODSOperands(3).begin());
  }

  ValueT getScaleGradByFreq() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmbeddingDenseBackwardOpAdaptor : public AtenEmbeddingDenseBackwardOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmbeddingDenseBackwardOpGenericAdaptor::AtenEmbeddingDenseBackwardOpGenericAdaptor;
  AtenEmbeddingDenseBackwardOpAdaptor(AtenEmbeddingDenseBackwardOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmbeddingDenseBackwardOp : public ::mlir::Op<AtenEmbeddingDenseBackwardOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmbeddingDenseBackwardOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmbeddingDenseBackwardOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.embedding_dense_backward");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getGradOutput();
  ::mlir::Value getIndices();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getNumWeights();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getPaddingIdx();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getScaleGradByFreq();
  ::mlir::OpOperand &getGradOutputMutable();
  ::mlir::OpOperand &getIndicesMutable();
  ::mlir::OpOperand &getNumWeightsMutable();
  ::mlir::OpOperand &getPaddingIdxMutable();
  ::mlir::OpOperand &getScaleGradByFreqMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value grad_output, ::mlir::Value indices, ::mlir::Value num_weights, ::mlir::Value padding_idx, ::mlir::Value scale_grad_by_freq);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value grad_output, ::mlir::Value indices, ::mlir::Value num_weights, ::mlir::Value padding_idx, ::mlir::Value scale_grad_by_freq);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmbeddingDenseBackwardOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmbeddingOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmbeddingOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmbeddingOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmbeddingOpGenericAdaptorBase(AtenEmbeddingOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmbeddingOpGenericAdaptor : public detail::AtenEmbeddingOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmbeddingOpGenericAdaptorBase;
public:
  AtenEmbeddingOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmbeddingOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmbeddingOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmbeddingOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmbeddingOp>>>
  AtenEmbeddingOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getWeight() {
    return (*getODSOperands(0).begin());
  }

  ValueT getIndices() {
    return (*getODSOperands(1).begin());
  }

  ValueT getPaddingIdx() {
    return (*getODSOperands(2).begin());
  }

  ValueT getScaleGradByFreq() {
    return (*getODSOperands(3).begin());
  }

  ValueT getSparse() {
    return (*getODSOperands(4).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmbeddingOpAdaptor : public AtenEmbeddingOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmbeddingOpGenericAdaptor::AtenEmbeddingOpGenericAdaptor;
  AtenEmbeddingOpAdaptor(AtenEmbeddingOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmbeddingOp : public ::mlir::Op<AtenEmbeddingOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmbeddingOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmbeddingOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.embedding");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getWeight();
  ::mlir::Value getIndices();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getPaddingIdx();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getScaleGradByFreq();
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getSparse();
  ::mlir::OpOperand &getWeightMutable();
  ::mlir::OpOperand &getIndicesMutable();
  ::mlir::OpOperand &getPaddingIdxMutable();
  ::mlir::OpOperand &getScaleGradByFreqMutable();
  ::mlir::OpOperand &getSparseMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value weight, ::mlir::Value indices, ::mlir::Value padding_idx, ::mlir::Value scale_grad_by_freq, ::mlir::Value sparse);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value weight, ::mlir::Value indices, ::mlir::Value padding_idx, ::mlir::Value scale_grad_by_freq, ::mlir::Value sparse);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmbeddingOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmptyLikeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmptyLikeOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmptyLikeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmptyLikeOpGenericAdaptorBase(AtenEmptyLikeOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmptyLikeOpGenericAdaptor : public detail::AtenEmptyLikeOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmptyLikeOpGenericAdaptorBase;
public:
  AtenEmptyLikeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmptyLikeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmptyLikeOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmptyLikeOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmptyLikeOp>>>
  AtenEmptyLikeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(1).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(4).begin());
  }

  ValueT getMemoryFormat() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmptyLikeOpAdaptor : public AtenEmptyLikeOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmptyLikeOpGenericAdaptor::AtenEmptyLikeOpGenericAdaptor;
  AtenEmptyLikeOpAdaptor(AtenEmptyLikeOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmptyLikeOp : public ::mlir::Op<AtenEmptyLikeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmptyLikeOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmptyLikeOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.empty_like");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::Value getMemoryFormat();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  ::mlir::OpOperand &getMemoryFormatMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmptyLikeOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmptyMemoryFormatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmptyMemoryFormatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmptyMemoryFormatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmptyMemoryFormatOpGenericAdaptorBase(AtenEmptyMemoryFormatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmptyMemoryFormatOpGenericAdaptor : public detail::AtenEmptyMemoryFormatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmptyMemoryFormatOpGenericAdaptorBase;
public:
  AtenEmptyMemoryFormatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmptyMemoryFormatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmptyMemoryFormatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmptyMemoryFormatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmptyMemoryFormatOp>>>
  AtenEmptyMemoryFormatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSize() {
    return (*getODSOperands(0).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(1).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(2).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(3).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(4).begin());
  }

  ValueT getMemoryFormat() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmptyMemoryFormatOpAdaptor : public AtenEmptyMemoryFormatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmptyMemoryFormatOpGenericAdaptor::AtenEmptyMemoryFormatOpGenericAdaptor;
  AtenEmptyMemoryFormatOpAdaptor(AtenEmptyMemoryFormatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmptyMemoryFormatOp : public ::mlir::Op<AtenEmptyMemoryFormatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmptyMemoryFormatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmptyMemoryFormatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.empty.memory_format");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSize();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::Value getMemoryFormat();
  ::mlir::OpOperand &getSizeMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  ::mlir::OpOperand &getMemoryFormatMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value size, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value size, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory, ::mlir::Value memory_format);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmptyMemoryFormatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEmptyStridedOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEmptyStridedOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEmptyStridedOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEmptyStridedOpGenericAdaptorBase(AtenEmptyStridedOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEmptyStridedOpGenericAdaptor : public detail::AtenEmptyStridedOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEmptyStridedOpGenericAdaptorBase;
public:
  AtenEmptyStridedOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEmptyStridedOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEmptyStridedOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEmptyStridedOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEmptyStridedOp>>>
  AtenEmptyStridedOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSize() {
    return (*getODSOperands(0).begin());
  }

  ValueT getStride() {
    return (*getODSOperands(1).begin());
  }

  ValueT getDtype() {
    return (*getODSOperands(2).begin());
  }

  ValueT getLayout() {
    return (*getODSOperands(3).begin());
  }

  ValueT getDevice() {
    return (*getODSOperands(4).begin());
  }

  ValueT getPinMemory() {
    return (*getODSOperands(5).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEmptyStridedOpAdaptor : public AtenEmptyStridedOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEmptyStridedOpGenericAdaptor::AtenEmptyStridedOpGenericAdaptor;
  AtenEmptyStridedOpAdaptor(AtenEmptyStridedOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEmptyStridedOp : public ::mlir::Op<AtenEmptyStridedOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEmptyStridedOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEmptyStridedOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.empty_strided");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getSize();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getStride();
  ::mlir::Value getDtype();
  ::mlir::Value getLayout();
  ::mlir::Value getDevice();
  ::mlir::Value getPinMemory();
  ::mlir::OpOperand &getSizeMutable();
  ::mlir::OpOperand &getStrideMutable();
  ::mlir::OpOperand &getDtypeMutable();
  ::mlir::OpOperand &getLayoutMutable();
  ::mlir::OpOperand &getDeviceMutable();
  ::mlir::OpOperand &getPinMemoryMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value size, ::mlir::Value stride, ::mlir::Value dtype, ::mlir::Value layout, ::mlir::Value device, ::mlir::Value pin_memory);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEmptyStridedOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqDeviceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqDeviceOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqDeviceOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqDeviceOpGenericAdaptorBase(AtenEqDeviceOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqDeviceOpGenericAdaptor : public detail::AtenEqDeviceOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqDeviceOpGenericAdaptorBase;
public:
  AtenEqDeviceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqDeviceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqDeviceOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqDeviceOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqDeviceOp>>>
  AtenEqDeviceOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqDeviceOpAdaptor : public AtenEqDeviceOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqDeviceOpGenericAdaptor::AtenEqDeviceOpGenericAdaptor;
  AtenEqDeviceOpAdaptor(AtenEqDeviceOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqDeviceOp : public ::mlir::Op<AtenEqDeviceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqDeviceOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqDeviceOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.device");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::DeviceType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::DeviceType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqDeviceOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqFloatOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqFloatOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqFloatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqFloatOpGenericAdaptorBase(AtenEqFloatOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqFloatOpGenericAdaptor : public detail::AtenEqFloatOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqFloatOpGenericAdaptorBase;
public:
  AtenEqFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqFloatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqFloatOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqFloatOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqFloatOp>>>
  AtenEqFloatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqFloatOpAdaptor : public AtenEqFloatOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqFloatOpGenericAdaptor::AtenEqFloatOpGenericAdaptor;
  AtenEqFloatOpAdaptor(AtenEqFloatOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqFloatOp : public ::mlir::Op<AtenEqFloatOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqFloatOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqFloatOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.float");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::FloatType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqFloatOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqIntListOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqIntListOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqIntListOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqIntListOpGenericAdaptorBase(AtenEqIntListOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqIntListOpGenericAdaptor : public detail::AtenEqIntListOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqIntListOpGenericAdaptorBase;
public:
  AtenEqIntListOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqIntListOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqIntListOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqIntListOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqIntListOp>>>
  AtenEqIntListOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqIntListOpAdaptor : public AtenEqIntListOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqIntListOpGenericAdaptor::AtenEqIntListOpGenericAdaptor;
  AtenEqIntListOpAdaptor(AtenEqIntListOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqIntListOp : public ::mlir::Op<AtenEqIntListOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqIntListOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqIntListOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.int_list");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::ListType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqIntListOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqIntOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqIntOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqIntOpGenericAdaptorBase(AtenEqIntOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqIntOpGenericAdaptor : public detail::AtenEqIntOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqIntOpGenericAdaptorBase;
public:
  AtenEqIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqIntOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqIntOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqIntOp>>>
  AtenEqIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqIntOpAdaptor : public AtenEqIntOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqIntOpGenericAdaptor::AtenEqIntOpGenericAdaptor;
  AtenEqIntOpAdaptor(AtenEqIntOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqIntOp : public ::mlir::Op<AtenEqIntOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqIntOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqIntOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.int");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::IntType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqIntOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqScalarOpGenericAdaptorBase(AtenEqScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqScalarOpGenericAdaptor : public detail::AtenEqScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqScalarOpGenericAdaptorBase;
public:
  AtenEqScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqScalarOp>>>
  AtenEqScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqScalarOpAdaptor : public AtenEqScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqScalarOpGenericAdaptor::AtenEqScalarOpGenericAdaptor;
  AtenEqScalarOpAdaptor(AtenEqScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqScalarOp : public ::mlir::Op<AtenEqScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqScalarOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqStrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqStrOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqStrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqStrOpGenericAdaptorBase(AtenEqStrOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqStrOpGenericAdaptor : public detail::AtenEqStrOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqStrOpGenericAdaptorBase;
public:
  AtenEqStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqStrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqStrOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqStrOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqStrOp>>>
  AtenEqStrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getA() {
    return (*getODSOperands(0).begin());
  }

  ValueT getB() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqStrOpAdaptor : public AtenEqStrOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqStrOpGenericAdaptor::AtenEqStrOpGenericAdaptor;
  AtenEqStrOpAdaptor(AtenEqStrOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqStrOp : public ::mlir::Op<AtenEqStrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::BoolType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly, ::mlir::InferTypeOpInterface::Trait> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqStrOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqStrOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.str");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getA();
  ::mlir::TypedValue<::mlir::torch::Torch::StringType> getB();
  ::mlir::OpOperand &getAMutable();
  ::mlir::OpOperand &getBMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::BoolType> getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
  ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqStrOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEqTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEqTensorOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEqTensorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEqTensorOpGenericAdaptorBase(AtenEqTensorOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEqTensorOpGenericAdaptor : public detail::AtenEqTensorOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEqTensorOpGenericAdaptorBase;
public:
  AtenEqTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEqTensorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEqTensorOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEqTensorOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEqTensorOp>>>
  AtenEqTensorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEqTensorOpAdaptor : public AtenEqTensorOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEqTensorOpGenericAdaptor::AtenEqTensorOpGenericAdaptor;
  AtenEqTensorOpAdaptor(AtenEqTensorOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEqTensorOp : public ::mlir::Op<AtenEqTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement, ::mlir::torch::Torch::OpTrait::HasValueSemantics, ::mlir::torch::Torch::OpTrait::ReadOnly> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEqTensorOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEqTensorOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq.Tensor");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::Value getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand &getOtherMutable();
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
  ::mlir::Operation::result_range getODSResults(unsigned index);
  ::mlir::Value getResult();
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value self, ::mlir::Value other);
  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
  void print(::mlir::OpAsmPrinter &p);
  ::mlir::LogicalResult verifyInvariantsImpl();
  ::mlir::LogicalResult verifyInvariants();
public:
};
} // namespace Torch
} // namespace torch
} // namespace mlir
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::torch::Torch::AtenEqTensorOp)

namespace mlir {
namespace torch {
namespace Torch {

//===----------------------------------------------------------------------===//
// ::mlir::torch::Torch::AtenEq_ScalarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AtenEq_ScalarOpGenericAdaptorBase {
public:
protected:
  ::mlir::DictionaryAttr odsAttrs;
  ::std::optional<::mlir::OperationName> odsOpName;
  ::mlir::RegionRange odsRegions;
public:
  AtenEq_ScalarOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});

  AtenEq_ScalarOpGenericAdaptorBase(AtenEq_ScalarOp op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
  ::mlir::DictionaryAttr getAttributes();
};
} // namespace detail
template <typename RangeT>
class AtenEq_ScalarOpGenericAdaptor : public detail::AtenEq_ScalarOpGenericAdaptorBase {
  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
  using Base = detail::AtenEq_ScalarOpGenericAdaptorBase;
public:
  AtenEq_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}

  AtenEq_ScalarOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : AtenEq_ScalarOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}

  template <typename LateInst = AtenEq_ScalarOp, typename = std::enable_if_t<std::is_same_v<LateInst, AtenEq_ScalarOp>>>
  AtenEq_ScalarOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
  }

  RangeT getODSOperands(unsigned index) {
    auto valueRange = getODSOperandIndexAndLength(index);
    return {std::next(odsOperands.begin(), valueRange.first),
             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
  }

  ValueT getSelf() {
    return (*getODSOperands(0).begin());
  }

  ValueT getOther() {
    return (*getODSOperands(1).begin());
  }

  RangeT getOperands() {
    return odsOperands;
  }

private:
  RangeT odsOperands;
};
class AtenEq_ScalarOpAdaptor : public AtenEq_ScalarOpGenericAdaptor<::mlir::ValueRange> {
public:
  using AtenEq_ScalarOpGenericAdaptor::AtenEq_ScalarOpGenericAdaptor;
  AtenEq_ScalarOpAdaptor(AtenEq_ScalarOp op);

  ::mlir::LogicalResult verify(::mlir::Location loc);
};
class AtenEq_ScalarOp : public ::mlir::Op<AtenEq_ScalarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::torch::Torch::NonValueTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::torch::Torch::OpTrait::IsTrailingUnderscoreInplaceVariant, ::mlir::torch::Torch::OpTrait::AllowsTypeRefinement> {
public:
  using Op::Op;
  using Op::print;
  using Adaptor = AtenEq_ScalarOpAdaptor;
  template <typename RangeT>
  using GenericAdaptor = AtenEq_ScalarOpGenericAdaptor<RangeT>;
  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
    return {};
  }

  static constexpr ::llvm::StringLiteral getOperationName() {
    return ::llvm::StringLiteral("torch.aten.eq_.Scalar");
  }

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
  ::mlir::Operation::operand_range getODSOperands(unsigned index);
  ::mlir::TypedValue<::mlir::torch::Torch::NonValueTensorType> getSelf();
  ::mlir::Value getOther();
  ::mlir::OpOperand &getSelfMutable();
  ::mlir::OpOperand