shޏpSSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r J r J r J r J r JrJrJr SSKJr SSKrSSKrSSKJs Jr SSKJr SS KJrJrJrJr \"S 5r\\ S r \ S r!S(S jr""SS\ \5r#\RH"S5RJr&S)Sjr'\'"\#5r("SS\#\ 5r)\)RU5 "SS\)5r+"SS5r,"SS\,\)5r-"SS\)5r."SS\)5r/"SS\/5r0"S S!\ 5r1"S"S#\)5r2"S$S%\+5r3"S&S'\/5r4g)*) annotationsN)StringIO)AnyCallableGenericLiteral NamedTupleOptionalTypeVarUnion)patch) OrderedSet)IndentedBufferreduction_num_outputssympy_index_symbol sympy_strT atomic_add) argmaxargminwelford_reducewelford_combineanymaxminprodsumxor_sumcl[U[R5(a [U5$[ U5$N) isinstancesympyExprrstras o/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/torch/_inductor/ops_handler.py_arg_strr*%s&!UZZ  | q6Mc\rSrSrSrSSjrSSjrSSjrSSjrSSjr SSjr SS jr SS jr SSS jjr SSjrSSjrSSjrSSjrSSjrSSjrSSSjjrSSjrSSSjjrSSjrSSjrSSjrSSjrSSSjjrSSjrSSjrSSjrSSjrSS jr SS!jr!SS"jr"SS#jr#SS$jr$SS%jr%SS&jr&SS'jr'SS(jr(SS)jr)SS*jr*SS+jr+SS,jr,SS-jr-SS.jr.SS/jr/SS0jr0SS1jr1SS2jr2SS3jr3SS4jr4SS5jr5SS6jr6SS7jr7SS8jr8SS9jr9SS:jr:SS;jr;SS<jrjr>SS?jr?SS@jr@SSAjrASSBjrBSSCjrCSSDjrDSSEjrESSFjrFSSGjrGSSHjrHSSIjrISSJjrJSSKjrKSSLjrLSSMjrMSSNjrNSSOjrOSSPjrPSSQjrQSSRjrRSSSjrSSSTjrTSSUjrUSSVjrVSSWjrWSSXjrXSSYjrYSSZjrZSS[jr[SS\jr\SS]jr]SS^jr^SS_jr_SS`jr`SSajraSSbjrbSScjrcSSdjrdSSejreSSfjrfSSgjrgSShjrhSSijriSSjjrjSSkjrkSSljrlSSmjrmSSnjrnSSojroSSpjrpSSqjrqSSrjrrSSsjrsSStjrtSSujruSSvjrvSSwjrwSSxjrxSSyjrySSzjrzSS{jr{SS|jr|SS}jr}SS~jr~SSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrS \GR8S SS.SSjjrSSjrSSjrSrg ) OpsHandler,a Protocol describing the set of valid operations on ``torch._inductor.virtualized.ops``, as well as the contract for op handlers. The type T signifies the domain of the abstract analysis AKA what all the functions return / take as arguments anywhere compute occurs. While these operators are typically dtype polymorphic (e.g., you can use mul on both integers and floats), they do NOT do promotion and usually return the same dtype as the input. You are expected to have handled type promotion during ATen decompositions. Most operators correspond exactly to pointwise operations as defined by torch, so when in doubt about semantics, check the corresponding torch documentation. These are all scalar operations (so they are defined to operate on a single element at a time.) For convenience, many operators take a src_dtype which indicates what the dtype of the input argument is. Although in principle this can be derived by an analysis, providing this for ops where it is useful helps avoid having to repeatedly recompute dtype in code generation. Note that this often describes a class of static methods, for stateless ops handlers. Handlers are often defined using metaprogramming (e.g. _initialize_pointwise_overrides), which means you will not get type errors for those methods. We have tests in test/inductor/test_op_completeness.py which check that all operators are implemented after all the metaprogramming has run. c[e)z)Produces a scalar constant of type dtype.NotImplementedError)selfvaluedtypes r)constantOpsHandler.constantI!!r+c[e)z$Computes inductor_prims.lookup_seed.r0)r2nameoffsets r) load_seedOpsHandler.load_seedMr7r+c[e)zIComputes inductor_prims.random with mode="rand". offset has dtype int32.r0r2seedr:s r)randOpsHandler.randQr7r+c[e)zJComputes inductor_prims.random with mode="randn". offset has dtype int32.r0r>s r)randnOpsHandler.randnUr7r+c[e)z9Computes inductor_prims.randint. offset has dtype int32.r0)r2r?r:lowhighs r) randint64OpsHandler.randint64Yr7r+c[e)a Computes body, but only perform loads/stores if the boolean mask evaluates to true. For example, you would use this if you needed to perform an indirect load that may not be valid on some elements; without masking, invalid accesses can cause IMAs. When mask is true, the result is the result of body; otherwise it is other. Here, `other` needs to be a constant. Contrast this with ops.where, which can multiplex between two values that have been unconditionally computed. r0)r2maskbodyothers r)maskedOpsHandler.masked] "!r+c[e)zU Computes torch.where: when condition is true, return input; otherwise return other. r0)r2 conditioninputrMs r)whereOpsHandler.wherek "!r+c[e)z Converts a sympy expression into a scalar of type dtype. expr is typically an indexing expression, thus the name; however, it can also be used in non-indexing situations. r0)r2exprr4s r) index_exprOpsHandler.index_exprqs "!r+NTc[e)z Convert x to dtype. src_dtype can be optionally set to specify what the original dtype of x was, which can improve code generation (used by torch to(dtype=dtype)). r0)r2xr4 src_dtypeuse_compute_typess r)to_dtypeOpsHandler.to_dtypey "!r+c[e)a Convert x to dtype with truncation semantics (similar to how the int constructor works in Python). In Inductor codegen, this just decays to trunc and then to_dtype, but this composite operation helps roundtrips for Sympy evaluation. dtype is taken as an explicit parameter because the desired output dtype is typically the index dtype, which may vary between int32 and int64 depending on if we've shown that all the indexing operations can be done in int32. r0r2r\r4s r) trunc_to_intOpsHandler.trunc_to_intrPr+c[ezD Convert x to dtype with ceiling semantics. See also trunc_to_int. r0rcs r) ceil_to_intOpsHandler.ceil_to_intrVr+c[ergr0rcs r) floor_to_intOpsHandler.floor_to_intrVr+c[e)zJ Convert x to dtype with round-to-even semantics. See also trunc_to_int. r0rcs r) round_to_intOpsHandler.round_to_intrVr+c[e)z} Reinterpret cast x to dtype (reinterpreting the bits in memory as another dtype.) src_dtype must be the original type of x. r0)r2r\r4r]s r)to_dtype_bitcastOpsHandler.to_dtype_bitcast "!r+c[e)z0 Returns x as is. This is used to trigger CSE. r0r2r\s r)identityOpsHandler.identityrVr+c[e)au Convert an integral x into a sympy.Expr that can be subsequently used in indexing computation. 'size' represents an upper bound on what valid indexes can be; when 'check' is True, we check that the x is in bounds. NB: This is typically mandatory to implement for any analysis, because you MUST return a valid sympy.Expr of some sort (even if it's a meaningless symbol). r0)r2r\sizecheckwrap_negs r)indirect_indexingOpsHandler.indirect_indexingrar+c[e)zS Load from the memory location 'name', offset by some indexing expression 'index'. r0)r2r9indexs r)loadOpsHandler.loadrVr+c[e)z Store 'value' to the memory location 'name' offset by 'expr'. If specified, 'mode' can require the store to be an atomic addition. r0)r2r9rr3modes r)storeOpsHandler.storerar+c[e)a Perform a 'reduction_type' reduction on 'value' of dtype 'src_dtype', using 'dtype' as the accumulation dtype for the reduction. The result is an intermediate computation which should be stored to the final location using 'ops.store_reduction'. Valid reduction types are . For Welford reduction types, this function returns multiple outputs; consult reduction_num_outputs to determine the amount in metaprogramming applications. r0)r2r4r]reduction_typer3s r) reductionOpsHandler.reductions ""!r+c[e)zc Store the fully accumulated result of 'reduction' to the memory location 'name' offset by 'expr'. r0)r2r9rr3s r)store_reductionOpsHandler.store_reductionrsr+c[e)z) Perform an associative scan on 'value'. r0)r2dtypes combine_fnvaluess r)scanOpsHandler.scan "!r+c[e)z, Sort values along the reduction dimension. r0)r2rrstable descendings r)sortOpsHandler.sortrr+c[er"r0)r2r boundariesboundary_indicesindexing_dtyperightsortersorter_indicess r) bucketizeOpsHandler.bucketizerar+c[er"r0r2x0s r)absOpsHandler.abs%!!r+c[er"r0rs r)expOpsHandler.exp(rr+c[er"r0rs r)exp2OpsHandler.exp2+rr+c[er"r0rs r)expm1OpsHandler.expm1.rr+c[er"r0rs r)sqrtOpsHandler.sqrt1rr+c[er"r0rs r)reluOpsHandler.relu4rr+c[er"r0r2rx1s r)minimumOpsHandler.minimum7rr+c[er"r0rs r)maximumOpsHandler.maximum:rr+c[er"r0rs r)cosOpsHandler.cos=rr+c[er"r0rs r)sinOpsHandler.sin@rr+c[er"r0rs r)lgammaOpsHandler.lgammaCrr+c[er"r0rs r)erfOpsHandler.erfFrr+c[er"r0rs r)coshOpsHandler.coshIrr+c[er"r0rs r)sinhOpsHandler.sinhLrr+c[er"r0rs r)acosOpsHandler.acosOrr+c[er"r0rs r)acoshOpsHandler.acoshRrr+c[er"r0rs r)asinOpsHandler.asinUrr+c[er"r0rs r)asinhOpsHandler.asinhXrr+c[er"r0rs r)atan2OpsHandler.atan2[rr+c[er"r0rs r)atanOpsHandler.atan^rr+c[er"r0rs r)atanhOpsHandler.atanharr+c[er"r0rs r)copysignOpsHandler.copysigndrr+c[er"r0rs r)erfcOpsHandler.erfcgrr+c[er"r0rs r)erfinvOpsHandler.erfinvjrr+c[er"r0rs r)frexpOpsHandler.frexpmrr+c[er"r0rs r)hypotOpsHandler.hypotprr+c[er"r0rs r)log10OpsHandler.log10srr+c[er"r0rs r)log2OpsHandler.log2vrr+c[er"r0rs r) nextafterOpsHandler.nextafteryrr+c[er"r0rs r) logical_andOpsHandler.logical_and|rr+c[er"r0rs r) logical_notOpsHandler.logical_notrr+c[er"r0rs r) logical_orOpsHandler.logical_orrr+c[er"r0rs r) logical_xorOpsHandler.logical_xorrr+c[er"r0rs r) bitwise_andOpsHandler.bitwise_andrr+c[er"r0rs r) bitwise_notOpsHandler.bitwise_notrr+c[er"r0rs r) bitwise_orOpsHandler.bitwise_orrr+c[er"r0rs r) bitwise_xorOpsHandler.bitwise_xorrr+c[er"r0rs r)bitwise_left_shiftOpsHandler.bitwise_left_shiftrr+c[er"r0rs r)bitwise_right_shiftOpsHandler.bitwise_right_shiftrr+c[er"r0rs r)rsqrtOpsHandler.rsqrtrr+c[er"r0rs r)log1pOpsHandler.log1prr+c[er"r0rs r)tanOpsHandler.tanrr+c[er"r0rs r)tanhOpsHandler.tanhrr+c[er"r0rs r)sigmoidOpsHandler.sigmoidrr+c[er"r0rs r)signbitOpsHandler.signbitrr+c[er"r0rs r)fmodOpsHandler.fmodrr+c[er"r0rs r)logOpsHandler.logrr+c[er"r0rs r)isinfOpsHandler.isinfrr+c[er"r0rs r)isnanOpsHandler.isnanrr+c[er"r0rs r)roundOpsHandler.roundrr+c[er"r0rs r)floorOpsHandler.floorrr+c[er"r0rs r)signOpsHandler.signrr+c[er"r0rs r)truncOpsHandler.truncrr+c[er"r0rs r)ceilOpsHandler.ceilrr+c[er"r0rs r)negOpsHandler.negrr+c[er"r0rs r) reciprocalOpsHandler.reciprocalrr+c[er"r0rs r)eq OpsHandler.eqrr+c[er"r0rs r)ne OpsHandler.nerr+c[er"r0rs r)lt OpsHandler.ltrr+c[er"r0rs r)gt OpsHandler.gtrr+c[er"r0rs r)le OpsHandler.lerr+c[er"r0rs r)ge OpsHandler.gerr+c[er"r0rs r)addOpsHandler.addrr+c[er"r0rs r)subOpsHandler.subrr+c[er"r0rs r)mulOpsHandler.mulrr+c[er"r0rs r)powOpsHandler.powrr+c[er"r0rs r)and_OpsHandler.and_rr+c[er"r0rs r)or_OpsHandler.or_rr+c[er"r0rs r)xorOpsHandler.xorrr+c[er"r0rs r)lshiftOpsHandler.lshiftrr+c[er"r0rs r)rshiftOpsHandler.rshiftrr+c[er"r0rus r)airy_aiOpsHandler.airy_airr+c[er"r0rus r) bessel_j0OpsHandler.bessel_j0 rr+c[er"r0rus r) bessel_j1OpsHandler.bessel_j1 rr+c[er"r0rus r) bessel_y0OpsHandler.bessel_y0rr+c[er"r0rus r) bessel_y1OpsHandler.bessel_y1rr+c[er"r0rus r)digammaOpsHandler.digammarr+c[er"r0rus r)erfcxOpsHandler.erfcxrr+c[er"r0)r2r\yzs r)fmaOpsHandler.fmarr+c[er"r0r2r\rs r)igammaOpsHandler.igammarr+c[er"r0rs r)igammacOpsHandler.igammac!rr+c[er"r0rs r)gammaincOpsHandler.gammainc$rr+c[er"r0rs r) gammainccOpsHandler.gammaincc'rr+c[er"r0rus r)i0 OpsHandler.i0*rr+c[er"r0rus r)i0eOpsHandler.i0e-rr+c[er"r0rus r)i1 OpsHandler.i10rr+c[er"r0rus r)i1eOpsHandler.i1e3rr+c[er"r0rus r)log_ndtrOpsHandler.log_ndtr6rr+c[er"r0rus r)modified_bessel_i0OpsHandler.modified_bessel_i09rr+c[er"r0rus r)modified_bessel_i1OpsHandler.modified_bessel_i1<rr+c[er"r0rus r)modified_bessel_k0OpsHandler.modified_bessel_k0?rr+c[er"r0rus r)modified_bessel_k1OpsHandler.modified_bessel_k1Brr+c[er"r0rus r)ndtrOpsHandler.ndtrErr+c[er"r0rus r)ndtriOpsHandler.ndtriHrr+c[er"r0rs r) polygammaOpsHandler.polygammaKrr+c[er"r0rus r)scaled_modified_bessel_k0$OpsHandler.scaled_modified_bessel_k0Nrr+c[er"r0rus r)scaled_modified_bessel_k1$OpsHandler.scaled_modified_bessel_k1Qrr+c[er"r0rus r)spherical_bessel_j0OpsHandler.spherical_bessel_j0Trr+c[er"r0rs r)zetaOpsHandler.zetaWrr+c[er"r0rs r)chebyshev_polynomial_t!OpsHandler.chebyshev_polynomial_tZrr+c[er"r0rs r)chebyshev_polynomial_u!OpsHandler.chebyshev_polynomial_u]rr+c[er"r0rs r)chebyshev_polynomial_v!OpsHandler.chebyshev_polynomial_v`rr+c[er"r0rs r)chebyshev_polynomial_w!OpsHandler.chebyshev_polynomial_wcrr+c[er"r0rs r)legendre_polynomial_p OpsHandler.legendre_polynomial_pfrr+c[er"r0rs r)shifted_chebyshev_polynomial_t)OpsHandler.shifted_chebyshev_polynomial_tirr+c[er"r0rs r)shifted_chebyshev_polynomial_u)OpsHandler.shifted_chebyshev_polynomial_ulrr+c[er"r0rs r)shifted_chebyshev_polynomial_v)OpsHandler.shifted_chebyshev_polynomial_vorr+c[er"r0rs r)shifted_chebyshev_polynomial_w)OpsHandler.shifted_chebyshev_polynomial_wrrr+c[er"r0rs r)hermite_polynomial_hOpsHandler.hermite_polynomial_hurr+c[er"r0rs r)hermite_polynomial_he OpsHandler.hermite_polynomial_hexrr+c[er"r0rs r)laguerre_polynomial_l OpsHandler.laguerre_polynomial_l{rr+c[e)zxC-style trunc division between integers only. Computes the true division of two numbers and rounds the result to zero. r0rs r)truncdivOpsHandler.truncdivrVr+c[e)zPython-style floor division between integers only. Computes the true division of two numbers and floors the result. If you want floor division for floats, do regular truediv and floor the result. r0rs r)floordivOpsHandler.floordivrsr+c[e)z~True division between floats. Integer inputs are NOT valid. To do Python-style (int, int) -> float division, use int_truedivr0rs r)truedivOpsHandler.truediv "!r+c[e)zTrue division between integers. This is NOT the same as promoting to float and doing integer division, there is a bespoke algorithm for doing the division in higher precision than the above. r0rs r) int_truedivOpsHandler.int_truedivrsr+c[e)z)C-style modulus, take sign from LHS (x0).r0rs r)modOpsHandler.modr7r+c[e)z.Python-style modulus, take sign from RHS (x1).r0rs r) remainderOpsHandler.remainderr7r+c[er"r0rs r)squareOpsHandler.squarerr+c[er"r0)r2rXryloweruppers r) check_boundsOpsHandler.check_boundsrr+c[er"r0rs r) libdevice_absOpsHandler.libdevice_absrr+c[er"r0rs r) libdevice_expOpsHandler.libdevice_exprr+c[er"r0rs r)libdevice_sqrtOpsHandler.libdevice_sqrtrr+c[er"r0rs r) libdevice_cosOpsHandler.libdevice_cosrr+c[er"r0rs r) libdevice_sinOpsHandler.libdevice_sinrr+c[er"r0rs r)libdevice_sigmoidOpsHandler.libdevice_sigmoidrr+c[er"r0rs r) libdevice_logOpsHandler.libdevice_logrr+c[er"r0)r2r3ryrzs r) halide_clampOpsHandler.halide_clamprr+r) constraintsr4is_purepackc[er"r0)r2asmr*r4r+r,inputss r)inline_asm_elementwise!OpsHandler.inline_asm_elementwises "!r+c[ez2This is a fake op used in analysis but not codegenr0)r2argss r)outputOpsHandler.outputr7r+c[er3r0)r2rs r) placeholderOpsHandler.placeholderr7r+)r3zUnion[bool, float, int]r4 torch.dtypereturnr)r9r&r:rr<r)r?rr:rr<r) r?rr:rrFrrGrr<r)rKrrLzCallable[[], T]rMrr<r)rRrrSrrMrr<r)rX sympy.Exprr4r;r<r)NT) r\rr4r;r]zOptional[torch.dtype]r^boolr<r)r\rr4r;r<r)r\rr4r;r]r;r<r)r\rr<rTT)r\rryr=rzr>r<r=)r9r&rr=r<rr") r9r&rr=r3rr StoreModer<None) r4r;r]r;r ReductionTyper3rr<zUnion[T, tuple[T, ...]])r9r&rr=r3rr<rA)rtuple[torch.dtype, ...]rz7Callable[[tuple[T, ...], tuple[T, ...]], tuple[T, ...]]r tuple[T, ...]r<rD) rrCrrDrr>rr>r<rDNNrrrz.tuple[str, sympy.Expr, sympy.Expr, sympy.Expr]rrrr;rr>rz Optional[tuple[str, sympy.Expr]]rz Optional[T]r<r)rrr<r)rrrrr<r)rr)r\rrrrrr<r)r\rrrr<r) rXr=ryr=rr>rr>r<rA)r3rryr=rzr>r<r)r/rr.r&r*z Optional[str]r4r;r+r>r,intr<r)r4rr<rA)rrGr<r)__name__ __module__ __qualname____firstlineno____doc__r5r;r@rCrHrNrTrYr_rdrhrkrnrqrvr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr r#r&r)r,r/r2r5r8r;r>rArDrGrJrMrPrSrVrYr\r_rbrerhrkrnrqrtrwrzr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr"r%r(torchfloat32r0r5r8__static_attributes__r:r+r)r-r-,s8""""" "" ",0"& "  " ") "  " " "" " " "" DH " "$ "-1 "  "" " " " "  "  " """& "  " ! "," "' "L " "  " "' " " "  "  "&48&* " "C " " $ "  "1 "$ "  """"""""""""""""""""""""""""""""""""""""""""""""""" """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" "" """"""&0"9="FJ" "$""""""""&*"]] " " "# "  "  " "  """r+r-z _.*|parencz[[U5Vs/sHn[U5(aMUPM sn5$s snfr")rdir _ignore_op_re)clsr\s r)list_opsrTs* #c(C(Q-2Bq(C DDCs88cL\rSrSrSSjrS Sjr\S Sj5r\S5r Sr g) DefaultHandleric[e)a Default implementation for all ops. Override in a subclass to provide generic op behavior. Args: name: name of the op, see OpHandler.{name} args: positional args passed to the op kwargs: keyword args passed to the op Returns: return value of the op r0r2r9r4kwargss r)_defaultDefaultHandler._defaults "!r+cP^^SUU4Sjjn[R"STS35 U$)Nc(>TRTX5$r"rZ)r4rYr9r2s r)fallback,DefaultHandler.__getattr__..fallbacks==t4 4r+zundefined OpHandler.z, please add missing op schema)r4rrYrr<r)warningswarn)r2r9r_s`` r) __getattr__DefaultHandler.__getattr__s+ 5 5  ,TF2PQRr+c"^U4SjnTUlU$)Nc(>URTX5$r"r^)r2r4rYtargets r) call_default2DefaultHandler._call_default..call_default s==6 6r+)rH)rgrhs` r) _call_defaultDefaultHandler._call_default s 7!' r+c [5n[Hn[R"[ [ U55n[ SURR555(aURR5tpEUS:XdeURSUSSRU5SU<SSRU5S3 R55 URS 5 M[XURU55 M 0n[UR!5U5 UR#5Hup'U[;dM[XU5 M g ) z Here we codegen many functions of the form: def add(self, a, b): return self._default('add', (a, b), {}) and install them in cls. This is the same as _call_default above, but is about 1.2x faster since CPython varargs parsing is slow. c3# UHYnUR[RR:H=(a& UR[RR Lv M[ g7fr")kindinspect ParameterPOSITIONAL_OR_KEYWORDdefaultempty).0ps r) +DefaultHandler._init_cls.. sP1A'++AAA9II!2!2!8!8890sA!A#r2z def z(self, , z0): return self._default(z, (z, ), {}) z N)rOP_NAMESro signaturegetattrr-all parametersrkeyswritejoinstripsetattrrjexecgetvalueitems)rScodergsigself_argr4ctximpls r) _init_clsDefaultHandler._init_clss+zF##GJ$?@C..0 #&.."5"5"76)))  $'89..4Zs499T?:KL   6"S%6%6v%>?%(! T]]_c"IIKLF!T*(r+r:Nr9r&r4ztuple[Any, ...]rYzdict[str, Any]r<r)r9r&r<r)rgr&) rHrIrJrKrZrc staticmethodrj classmethodrrOr:r+r)rVrVs4" #+#+r+rVc\rSrSrSrS Sjr\S Sj5r\S Sj5r\S Sj5r \S Sj5r \SSSjj5r Sr g ) NoopHandleri<cgr"r:rXs r)rZNoopHandler._default?sr+cgr"r:rKrLrMs r)rNNoopHandler.maskedBsr+cg)NrEr:r\s r)rNoopHandler.frexpFsr+cS[U5-$Nr"lenrrrs r)rNoopHandler.scanJV$$r+cS[U5-$rrrrrrs r)rNoopHandler.sortNrr+c6[RR$r")r$SZero index_varryrzr{s r)r|NoopHandler.indirect_indexingRsww||r+r:Nrr<rA)r<ztuple[None, None])r<ztuple[None, ...]r?r<z sympy.Symbol rHrIrJrKr9rZrrNrrrr|rOr:r+r)rr<sp D%%%%r+rcD\rSrSr\S5r\S5r\S5r\S5r\S5r \S5r \S5r \S 5r \S 5r \S 5r\S 5r\S 5r\S5r\S5r\S5r\S5r\S5r\S5r\S5rSrg)BasicMathOpsMixiniWcUSU3$)Nz + r:r(bs r)rbBasicMathOpsMixin.addXCs|r+cUSU3$)Nz - r:rs r)reBasicMathOpsMixin.sub\rr+cUSU3$)Nz * r:rs r)rhBasicMathOpsMixin.mul`rr+cUSU3$)Nz // r:rs r)rBasicMathOpsMixin.floordivdD}r+cUSU3$)Nz / r:rs r)rBasicMathOpsMixin.truedivhrr+cUSU3$)Nz % r:rs r)rBasicMathOpsMixin.modlsCs|r+cUSU3$)Nz ** r:rs r)rkBasicMathOpsMixin.powqrr+cUSU3$)Nz << r:rs r)rwBasicMathOpsMixin.lshifturr+cUSU3$)Nz >> r:rs r)rzBasicMathOpsMixin.rshiftyrr+cUSU3$)Nz & r:rs r)rnBasicMathOpsMixin.and_}rr+cUSU3$)Nz | r:rs r)rqBasicMathOpsMixin.or_rr+cUSU3$)Nz ^ r:rs r)rtBasicMathOpsMixin.xorrr+cUSU3$)Nz == r:rs r)rPBasicMathOpsMixin.eqrr+cUSU3$)Nz != r:rs r)rSBasicMathOpsMixin.nerr+cUSU3$)Nz < r:rs r)rVBasicMathOpsMixin.ltrr+cUSU3$)Nz > r:rs r)rYBasicMathOpsMixin.gtrr+cUSU3$)Nz <= r:rs r)r\BasicMathOpsMixin.lerr+cUSU3$)Nz >= r:rs r)r_BasicMathOpsMixin.gerr+c SU3$)N-r:r's r)rJBasicMathOpsMixin.negs 1#wr+r:N)rHrIrJrKrrbrerhrrrrkrwrzrnrqrtrPrSrVrYr\r_rJrOr:r+r)rrWs|r+rc~\rSrSrSrS Sjr\S Sj5r\S5r\S5r \S5r \S S Sjj5r Sr g ) MockHandleric/[[U5QnUR5H$upVURUS[U535 M& SUSSR U5S3$)N=zops.(rx))mapr*rappendr)r2r9r4rYfargskvs r)rZMockHandler._defaults_&#h%&LLNDA LLA3a }- .#dV1TYYu-.a00r+c$SUSU"5SUS3$)Nz ops.masked(rxrr:rs r)rNMockHandler.maskedsTF"TVHBugQ77r+cSUS3SUS34$)Nz ops.frexp(z)[0]z)[1]r:rs r)rMockHandler.frexpsQCt$ 1#T&:;;r+cZ^^^[UUU4Sj[[T5555$)Nc 3B># UHnSTSTSTSUS3 v M g7f)z ops.scan(rx)[]Nr:)rtirrrs r)rv#MockHandler.scan..s3 'xr*Rxr!A >'stuplerangerrs```r)rMockHandler.scans& 3v;'   r+c^^^^^[UUUU4Sj[[T5555$)Nc 3H># UHnSTSTSTSTSUS3 v M g7f)z ops.sort(rxz , stable=z , descending=rrNr:)rtrrrrrs r)rv#MockHandler.sort..s= 'xr&6(- |SUVWUXXY Z's"rrs````r)rMockHandler.sorts& 3v;'   r+c*[[U55$r")rr&rs r)r|MockHandler.indirect_indexings!#i.11r+r:Nrr<r&r?rrr:r+r)rrsp D1 88<<    22r+rct\rSrSrS Sjr\S S Sjj5rSSjrSrSSjr SSjr S r S r g)KernelFormatterHandlericdXl[S5Ul[R"5Ulg)Nr)parent_handlerr_output itertoolscount var_counter)r2rs r)__init__KernelFormatterHandler.__init__s#,%a( $??,r+Nc RSSKJn SSKJn UbX/OU/nUbSS/OS/n[ [ 55nUR RS5 UR RSSRU5S 35 SSS5 [Xe5HupU (dMSRU V s/sH5n [[U [[R45(aS OU 5PM7 sn 5n UR RU S U35 M UR!U5 ["R$"US S 5 U"U6n UR'U 5sSSS5 sSSS5 $!,(df  N=fs sn f!,(df  O=fSSS5 g!,(df  g=f)Nr)FlexibleLayout)Vrrindexz def inner_fn(rxz):_ = allow_indexingT)irr virtualizedrrrrindent writelinerzipr&r#rGr$Integerset_ops_handlerr objectr) ir_fnrrrrr4names formatterr9argrlhsresults r) ir_to_string#KernelFormatterHandler.ir_to_stringsd&""("45''-'9(#y*;=9    % %b )    ' '- %8H7I(L M*U)IDsii"%!$A:a#u}}1E#F#FCAN!$ !!++se3tf,=>*   i ( LL)94 @D\F%%f- A @ ) (* )  A @ @ ) ( (s6/E'-E= F' E5= F F F&c:URR"U0UD6$r")rr|r2r4rYs r)r|(KernelFormatterHandler.indirect_indexings""44dEfEEr+cvS[UR53nURRUSU35 U$)Ntmpr )nextrrr)r2linevarnames r)_writeKernelFormatterHandler._writes<T--./0 '#dV45r+cx[R"UR[URU5"U0UD65$r")pytreetree_mapr%r{rrXs r)rZKernelFormatterHandler._defaults3 KK!4!4d;TLVL  r+cFURRXX45n[U5n[U5Vs/sHnS[ UR 53PM nnUR RSRU5SU35 US:a [U5$US$s snf)Nr!,r rr) rrrrr"rrrrr) r2r4r]rr3r# num_valuesr varnamess r)r KernelFormatterHandler.reductions"",,U~U*>: \rSrSr%S\S'S\S'S\S'S\S'S rg ) OpCountResultirGnum_opszOrderedSet[str]used_opsz list[str] read_buffersnontrivial_read_countr:N)rHrIrJrK__annotations__rOr:r+r)rErEs Lr+rEc^\rSrSrSrS U4SjjrS SjrSrSrSSjr SSjr SSS jjr S r S r U=r$) OpCounterCSEi#z#Shim to count how many ops are usedc>[TU]5 XlSUl0Ul[ 5Ul/UlSUlg)Nr) superrrop_count var_namesr _used_ops _read_names_nontrivial_read_countr2r9 __class__s r)rOpCounterCSE.__init__&s; # )+*4,&(&'#r+cURRU5 [R"UR[ UR U5"U0UD65$r")rQrbr(r) _update_countr{rrXs r)rZOpCounterCSE._default/sG 4    (;(;T BD SF S  r+cURRU5nU(d2SUR3nU=RS- slX RU'U$)Nr!r)rPgetrO)r2rBr$s r)rXOpCounterCSE._update_count5sH..$$S)DMM?+G MMQ M")NN3 r+cpURRS5 URR"U0UD6$)Nr|)rQrbrr|rs r)r|OpCounterCSE.indirect_indexing=s1 ./""44dEfEEr+cXURRX5nX0R;apURR S5 UR R U5 [U[R[45(dU=RS- sl URU5$)Nrr) rrrPrQrbrRrr#r$rrGrSrX)r2r9rrBs r)rOpCounterCSE.loadAs!!&&t3 nn $ NN  v &    # #D )eemmS%9::++q0+!!#&&r+cURRX5nX0R;a6URR S5 UR R U5 URU5$)Nr;)rr;rPrQrbrRrrX)r2r9r:rBs r)r;OpCounterCSE.load_seedJsY!!++D9 nn $ NN  { +    # #D )!!#&&r+c 8URRUUUUUUU5nXR;aZURR S5 UR R US5 UbUR R US5 URU5$)z# See [Note: Inductor bucketize op] rr)rrrPrQrbrRrrX) r2rrrrrrrrBs r)rOpCounterCSE.bucketizeQs!!++         nn $ NN  { +    # #JqM 2!  ''q 2!!#&&r+cn[URURURUR5$r")rErOrQrRrS)r2s r)rOpCounterCSE.getvaluens, MM4>>4+;+;T=X=X  r+)rSrRrQrOrrPr=r)r9r&rr=r<r&)r9r&r:rrErF)rHrIrJrKrLrrZrXr|rr;rrrO __classcell__rUs@r)rLrL#s-( F''48&*''C' ' $ '  '1'$' ':  r+rLc(\rSrSrSSjrSSjrSrg)ExtractConstantsHandleritcXlgr"device)r2rms r)r ExtractConstantsHandler.__init__us r+czSSKJn URXUR=(d [R "5S9$)Nr)r )r3r4rm)torch._inductorr ConstantrmrMget_default_device)r2r3r4r s r)r5 ExtractConstantsHandler.constantxs2&{{T[[-VE[TU]U5 0Ul[5Ulgr")rNr cse_cachermockrTs r)rSimpleCSEHandler.__init__s  ACM r+c$>[TU]"U0UD6$r")rNr|)r2r4rYrUs r)r|"SimpleCSEHandler.indirect_indexingsw($9&99r+c[S5eNzstore not implementedr0rs r)rSimpleCSEHandler.store!"9::r+c[S5er}r0rs r)r SimpleCSEHandler.store_reductionrr+c[URU5"U0UD6nURRU5nUbU$[URU5"U0UD6nXPRU'U$r")r{rxrwr[r8)r2r9r4rYkeyrBs r)rZSimpleCSEHandler._defaultsedii&77nn  % ?Jdkk4($9&9!s r+)rwrx)r9r)r<r=rr) rHrIrJrKrLrr|rrrZrOrgrhs@r)rurus& " :;;r+ru)r(rr<r&)rSz type[Any])5 __future__rrorreraiortypingrrrrr r r r unittest.mockr r$rMtorch.utils._pytreeutils_pytreer(utils._ordered_setrrrrrrr@rBr*r-compile fullmatchrRrTryrVrrrrrr5r?rErLrjrur:r+r)rsC" XXX $$+WW CL W\* +    x "x "v <(22 E J E+Z_E+P.6LL^!2#^!2H?'^?'D;^;nJN >N b  k  ~r+