+ j^RIHt^RIt^RIt^RIt^RIHt^RIHt^RI H t H t H t H t ^RIHt^RIt^RIt^RIt^RIHtHtHtHtHt^RIHt] 'd^R IHtHt^R IHtR s R s!R s"R:R R llt#RRlt$RRlt%!RR4t&RRlt'Rt(Rt)Rt*RRlt+RRlt,R;RRllt-]P\R;RR ll4t/]P\R!4t0!R"R#]&4t1!R$R%] 4t2]2t3R&R'lt4R(R)lt5R*R+lt6RR9t?R#)=) annotationsN)deque) dataclass)castoverloadProtocol TYPE_CHECKING)TypeIs)_get_dispatch_stack_at_len_torch_dispatch_stack_pop_torch_dispatch_stack_push_on_torch_dispatch_stack DispatchKey)/set_is_in_mode_without_ignore_compile_internals)MappingSequence)CustomClassBaseFc V^8dQhRRRR/#)include_infra_modesboolreturn)formats"]/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/utils/_python_dispatch.py __annotate__r+s44c*V'd\#\#N)_is_in_torch_dispatch_mode$_is_in_non_infra_torch_dispatch_mode)rs&ris_in_torch_dispatch_moder"+s  #2rcV^8dQhRR/#rrrr)rs"rrr3s<<R# R#)TF)torch_Cr ranger is_infra_modeignore_compile_internals) stack_lenidxmodes r any_torch_dispatch_mode_on_stackr27s[224IY%c*        ( ( * *   rca]tRt^HtRtRtV3RltRRltRtRRlt Rt Rt ] R 4t ] R R l4t] R R l4t] RRl4tRtV;t#)TorchDispatchModea A ``TorchDispatchMode`` allows you to override the meaning of all ``__torch_dispatch__`` overridable functions within a dynamic scope, without having to actually create a tensor subclass or manually monkey-patch functions in the PyTorch API. Some common situations where you should use a mode: * You want to override the meaning of factory functions, or other functions that do not otherwise take a tensor as an argument (these cannot be overridden with tensor subclasses). * You want to override the behavior of all functions without needing to wrap your inputs in tensor subclasses; e.g., if you are just interested in logging intermediate computations. * You want to control the order of execution of various tensor subclasses explicitly, rather than implicitly via the return of ``NotImplemented``. Independent subclasses of :class:`TorchDispatchMode` are compositional: modes can be pushed onto a stack using ``with MyMode():``. When you call functions in the PyTorch API inside your ``__torch_dispatch__`` implementation, by default, they will forward on to the next mode on the mode stack. If you want recursively call back into your current ``__torch_dispatch__`` implementation, either explicitly invoke ``self.__torch_dispatch__(...)``, or use the context manager ``self`` to make PyTorch API self-referential (beware of infinite loops, in this case!) Fc <\SV`!R/VBVP4'd^RVP9dKVPR,p\ V\ 4'g \ P!VRR7VnR#R#R#R#)__torch_dispatch__T) recursiveNr) super__init_subclass___should_skip_dynamo__dict__ isinstance classmethodr*_disable_dynamor6)clskwargsraw __class__s&, rr9#TorchDispatchMode.__init_subclass__mso !+F+  " " $ $#s||3ll#78!#{33-2-B-B3RV-WC*44 %rc VeD\V\PP4'g \ R4hWP R&\ 4Vn\ 4Vn\ 4Vn R#)Nz,_dispatch_key must be a torch._C.DispatchKey _dispatch_key) r<r*r+rAssertionErrorr;rold_dispatch_mode_flags!old_non_infra_dispatch_mode_flags8old_without_ignore_compile_internals_dispatch_mode_flags)selfrEs&&r__init__TorchDispatchMode.__init__usX  $mUXX-A-ABB$%STT-:MM/ *49G$>Cg. G Erc \VR4'g\4Vn\VR4'g\4Vn\VR4'g\4VnR#R#)rGrHrIN)hasattrrrGrHrIrJs&r"_lazy_init_old_dispatch_mode_flags4TorchDispatchMode._lazy_init_old_dispatch_mode_flagssYt6778=D (t@AABG'D 2 L    I rc \hr)NotImplementedErrorrJfunctypesargsr@s&&&&&rr6$TorchDispatchMode.__torch_dispatch__s!!rc VP4VPP\4RsVPP\ 4\ ;'gVP 4'*sVPP\4\;'gVP4'*s\\4\V4V#T) rPrGappendr rHr!r-rIr&r.r _push_moderOs&r __enter__TorchDispatchMode.__enter__s //1 $$++,FG%)" ..55 0  1 L L8J8J8L4L - EELL <  = 3 30022 9 8 <  4 rc NVPPRR4pVfVPPRR4pVPP4sVP P4sVPP4s\\4\V4R#)rEN _mode_key) r;getrGpopr rHr!rIr&r _pop_mode)rJexc_typeexc_valexc_tbmb_dk_or_mode_keys&&&& r__exit__TorchDispatchMode.__exit__s MM--otD  $!% 1 1+t D %)%A%A%E%E%G"  2 2 6 6 8 -  I I M M O 9 8 <  #$rc F\P!R^R7V!V/VBpV#)zP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`) stacklevel)warningswarn)r?rWr@instances&*, rpushTorchDispatchMode.pushs* ^ ''rcV^8dQhRR/#r$r)rs"rrTorchDispatchMode.__annotate__sdrc R#)Frr?s&rr-TorchDispatchMode.is_infra_modesrcV^8dQhRR/#r$r)rs"rrrrsDrc R#)aSkip Dynamo when the flag is set to True This is temporary measure to rollout a feature that skips PT2 compilation inside __torch_dispatch__ frames. If this flag is off, we would expect following: class YoloMode(TorchDispatchMode): @classmethod def _should_skip_dynamo(cls): return False def __torch_dispatch__(self, func, types, args=(), kwargs=None): return torch.ops.aten.mul.Tensor(args[0], args[1]) x = torch.ones(5) with YoloMode(): out = torch.compile(torch.add, backend=backend, fullgraph=True)(x, x) # instead of recursively disabling, we are compiling into __torch_dispatch__ assert len(backend.graphs) == 1 Trrts&rr:%TorchDispatchMode._should_skip_dynamos0rcV^8dQhRR/#r$r)rs"rrrrsrc 6VP4'dR#R#)aIgnore operators that are compiled via torch.compile. If ``True``, then this TorchDispatchMode ignores operators that are optimized by :func:`torch.compile`. Mechanically, this involves turning off the TorchDispatchMode throughout the whole compilation process, and turning it back on for the runtime of the compiled artifact(s). For example, @torch.compile def f(x): return x.sin().cos() with LoggingMode(): f(x) The above example will not log anything if ``LoggingMode.ignore_compile_internals()`` is True. torch.compile will fuse sin() and cos() into a single operation and this TorchDispatchMode will not be passed sin and cos. If ``False`` (default), :func:`torch.compile` will respect the eager semantics of passing this TorchDispatchMode all operators that would have run during eager execution. The way this will usually happen is that :func:`torch.compile` will just fallback to eager-mode PyTorch. TF)r-rts&rr.*TorchDispatchMode.ignore_compile_internalss8     r)rGrHrIrrN)__name__ __module__ __qualname____firstlineno____doc__supports_higher_order_operatorsr9rKrPr6r]rhr=ror-r:r.__static_attributes__ __classcell__)rBs@rr4r4HsD',#X   ">%*2rr4cV^8dQhRR/#)rrzTorchDispatchMode | Noner)rs"rrrs$<rcL\4pV^8d\V^, 4#R#)z_ Return the top user mode on the stack (the next one that would be executed) if there are any. N)r r )r/s r_get_current_dispatch_moders% *+I1}%i!m44 rcV\PPP\PPP39dY\ R\PPP R\PPP RV 24h^RIHpV!V4p\PPV4pVeVe \ R4hVfV#V#)zkey must be either FUNCTIONAL (z) or PROXY (z1) _TorchDispatchModeKey, got )_get_dispatch_mode_pre_dispatchzEAt most one of pre_dispatch_mode and post_dispatch_mode may be active) r*r+_TorchDispatchModeKey FUNCTIONALPROXYrF torch._opsr_get_dispatch_mode)keyrpre_dispatch_modepost_dispatch_modes& r_detect_infra_moders  &&11 &&,,-ehh.L.L.W.W-XY 8899??@A   ;7<44S9$);)G S   !! rc ^RIHpHpV!V4p\PP V4pV'dV'd \ R4hV'd V!V4pV#V'd \PPV4#R#)r)runset_mode_pre_dispatchzECan't have active infra mode on both pre and post dispatch mode stackN)rrrr*r+rrF_unset_dispatch_mode)rrrrrr1s& r_unset_infra_moder3slS7<44S9/ S  &s+ xx,,S11rc#*"V\PPP\PPP39d \ R4h\ V4pVxVe\V4R#R# Te \T4ii;i5i)z+B>BBcV^8dQhRR/#)rrzlist[TorchDispatchMode]r)rs"rrrTsAA*AArch\4p\V4Uu.uFp\V4NK up#uupi)z Returns the current stack of dispatch modes, with the most recent (i.e., the one that will be processed first) at the end of the list (standard stack convention). )r r,r )r/is r _get_current_dispatch_mode_stackrTs1 *+I/4Y/? @/?! "1 %/? @@ @s/c V^8dQhRRRR/#)rr1r4rNoner)rs"rrr^s!!&!4!rc\VR4'd VPMRpVe5V\PPP 8wd \ R4hVf\V4R#^RIH pH p\PPV4pV!4FpVFpVPV4K K V!V4R#)rENz:mode._dispatch_key must be None or DispatchKey.PreDispatch)_set_mode_pre_dispatchget_cached_ops) rNrEr*r+r PreDispatchrFrrrr_functionality_to_backend_keys_uncache_dispatch)r1krrksoprs& rr\r\^s%dO<<$A}ehh22>>> H   y%d+A  0 0 3BC   %4 rcV^8dQhRR/#)rrz3DispatchKey | torch._C._TorchDispatchModeKey | Noner)rs"rrrss,,D,rcV\PPP8Xd^RIHpV!4#Ve+\ V\PP4'd \V4#R#)r)_pop_mode_from_pre_dispatchN) r*r+rrrrr<rr )rrs& rrcrcssREHH , ,,:*,,yJq%(("@"@AA(++BrcV^8dQhRR/#)rrzDispatchKey | Noner)rs"rrr~s/rc#d"\V4pVx\V4R# \T4i;i5ir)rcr\)rolds& r_pop_mode_temporarilyr}s& A,C 3 3s 0 0 -0c#"^RIHpHp^RIHp^RIHp^RIHpV!4p\V4Uu.uF qa!4NK ppRpRp Rp VF>p \W4'dRp\W4'dRp \W4'gK<Rp K@ \4p \V 4Uu.uF p\4NK p pV Fqp\W4'dV 'd \R4h\W4'dV'd \R4h\W4'gK^V 'gKh\R 4h W},x\V 4Fp\V4K \V4Fp\V4K R #uupiuupi \T 4Fp\T4K \T4Fp\T4K i;i5i) r)&_len_torch_dispatch_stack_pre_dispatchr)FunctionalTensorMode)SchemaCheckMode)ProxyTorchDispatchModeFTzFCan't have FunctionalMode available both in PreDispatch and Python KeyzNCan't have ProxyTorchDispatchMode available both in PreDispatch and Python KeyzGCan't have SchemaCheckMode available both in PreDispatch and Python KeyN)rrr#torch._subclasses.functional_tensorr#torch._subclasses.schema_check_moder"torch.fx.experimental.proxy_tensorrr,r<r rcrFreversedr\)rrrrrmode_len_pre_dispatch_old_pre_dispatch_modeshas_proxy_mode_in_pre_dispatch#has_functional_mode_in_pre_dispatch%has_schema_check_mode_in_pre_dispatchrmode_len old_modesrr1s r_disable_current_modesrsICIBD/45J/K/K!#%/K&+"*/',1) # a 0 0-1 * a . .26 / a ) )48 1 $)*H&+Ho6ooI6 s 1 13 X  c 2 27U `  c + +0U0U Y $$00Y'D t (34D t 5U"7.Y'D t (34D t 5sT/F?E6AF?F?#E;6F?#F?:F?F?" F?0 F:AF?FT$V$$rrr|)r}r~rrr6rrrrrrs %%rrc&]tRtRt$RtRRlt]RRl4tR]R&] RR R ll4t ] R R l4t ] RRRll4t ] RRl4t RRlt RRlt ] RRR /RRlll4t] R RR /RRlll4t] RRR /RRlll4tRtR #)!TraceableWrapperSubclassiaP Canonical protocol for wrapper tensor subclasses that PT2 can trace through. ``__tensor_flatten__`` must return stable attribute names for the inner values that participate in tracing together with any metadata needed to rebuild the outer subclass. ``__tensor_unflatten__`` must reconstruct an equivalent wrapper subclass instance from the flattened inner values, metadata, and requested outer size/stride. Callers may pass tensor attrs and registered reference-type opaques in ``inner_tensors``. The returned tensor is expected to preserve the requested outer size/stride. If ``attrs, metadata = x.__tensor_flatten__()``, then ``type(x).__tensor_unflatten__`` must round- trip from ``{name: getattr(x, name) for name in attrs}``, ``metadata``, ``x.size()``, and ``x.stride()`` to an equivalent instance of ``x``. ``__tensor_unflatten__`` may be implemented as either a ``@staticmethod`` or a ``@classmethod``; the runtime check below intentionally uses duck typing to support both forms, even though static type checkers may only recognize the ``@staticmethod`` form as conforming to this protocol. cV^8dQhRR/#)rrztuple[Sequence[str], object]r)rs"rr%TraceableWrapperSubclass.__annotate__sEE$@Erc R#rrrOs&r__tensor_flatten__+TraceableWrapperSubclass.__tensor_flatten__s#rc ,V^8dQhRRRRRRRRRR /#) r inner_tensorsz,Mapping[str, torch.Tensor | CustomClassBase]metadataobject outer_sizezSequence[int | torch.SymInt] outer_strider torch.Tensorr)rs"rrrs:C13   rc R#rr)rrrrs&&&&r__tensor_unflatten__-TraceableWrapperSubclass.__tensor_unflatten__s rz torch._C.SizeshapeNc V^8dQhRRRR/#rdimrrztuple[int, ...]r)rs"rrrs>>$>/>rc R#rrrJrs&&rstrideTraceableWrapperSubclass.strides;>rc V^8dQhRRRR/#rrintrr)rs"rrrs**#*#*rc R#rrrs&&rrrs'*rc V^8dQhRRRR/#rr)rs"rrrs<<<> ** << (((  59 59 59 rrc V^8dQhRRRR/#)rtrrrr)rs"rrrsSSS4SrcB\VR4;'d \VR4#)rr)rNrs&r(_has_traceable_wrapper_subclass_protocolrs 1* + R R;Q0RRrc V^8dQhRRRR/#)rrrrz TypeIs[TraceableWrapperSubclass]r)rs"rrr#s G GV G0P Grc\V\P4;'d\V4\PJpT;'d \ V4#)a Returns whether ``t`` is a tensor subclass that matches the ``TraceableWrapperSubclass`` protocol at runtime. See ``TraceableWrapperSubclass`` for the canonical flatten/unflatten contract. Matching the protocol is necessary but not sufficient for full PT2 support: the subclass's ``__torch_dispatch__`` implementation must also desugar into traceable dispatcher operations and preserve aliasing semantics with ``return_and_correct_aliasing()`` when needed. )r<r*Tensortyper)r is_subclasss& ris_traceable_wrapper_subclassr #s=Q -MM$q'2MK  F FCAFFrc V^8dQhRRRR/#)rrr rz&TypeIs[type[TraceableWrapperSubclass]]r)rs"rrr2s +rc\V\P4;'d&V\PJ;'d \V4#)z@Same as above, but takes a type argument instead of an instance.) issubclassr*r rrs&r"is_traceable_wrapper_subclass_typer2s? 1ell# 8 8 U\\ ! 8 8 4Q 7rc VeTMVP4pVeTMVP4pVP4wrE/pVFpV!V\W44Wg&K \ V4P WeW#4pVP V8wd(\R\ V4 RV RVP 24hVP4V8wd,\R\ V4 RV RVP4 24hV#)a Given a traceable, wrapper tensor subclass ``t`` that implements ``__torch_dispatch__`` and holds some inner tensors, and a callback of type ``Callable[[str, torch.Tensor], torch.Tensor]``, `transform_subclass` will construct a fresh instance of the wrapper tensor subclass. It will do so by grabbing each inner tensor attribute from the wrapper, passing them into ``callback`` to get a transformed tensor, and putting each transformed tensor into the fresh tensor subclass instance. Note: this function will not handle ensuring that the fresh subclass gets the same (autograd, and aliasing) metadata as the original tensor. This is generally handled in other subsystems like AOTAutograd. zExpected return value from z.__tensor_unflatten__() to have shape equal to z , but got: z/__tensor_unflatten__() to have stride equal to )rrrgetattrr rrrF) rcallbackrrattrsctxtransformed_tensors_dictattrsubs &&&& rtransform_subclassr=s *51668J#/#;<L%%'JE!)1$8H)I & q' & & z C yyJ)$q'3(\SYYK A   zz||#)$q'3+nK ~ G  JrcV^8dQhRR/#rrrr)rs"rrrgs?C?C?Crca\S\PP4'g\ R\ V4 24h\V\ 4'g\ R\ V4 24h\V\\ 34'g\ R\ V4 24hRV3RllpVPFwrVV!W%,W6,4K R#)a Given: an OpOverload, a SchemaInfo (cached information from torchgen about schema), and the inputs/outputs to the OpOverload, this function checks to see if func is a view operator (by checking if any of the outputs in the op's schema are immutable aliases of inputs). If so, this function manually aliases the storage of the output tensor with its corresponding input tensor alias. It does this by unsafely overwriting the storage field of the output tensor to be the same storage as the input. z func must be an OpOverload, got zargs must be a tuple, got z"outs must be a list or tuple, got cV^8dQhRR/#rr)rs"rr/_correct_storage_aliasing..__annotate__zs)6)6t)6rc b<\V4p\V4pW#Jd\V4'g\V4'dm\V\4'dTMV.pVFKp\V4\V4JgK\ R\ S4 R\V4 R\V4 R24h \V\4'd"VFp\ P!WP4K R#\V\ P4'g\ R\V4 24h\ P!W4R#)zCalled z with input of type z and output of type z. But expected types to match.zexpected torch.Tensor, got N) r rr<listrFstrr*_functionalize_unsafe_setr )argretarg_typeret_typeret_listrrUs&& ralias_non_inplace_storage<_correct_storage_aliasing..alias_non_inplace_storagezs99  # .x 8 81(;;(d33s#H9DG+(!#d),@c L..23i[8VX" c4 //7c5<<00$'B49+%NOO  + +C 5rN) r<r*_ops OpOverloadrFr tupler!read_only_alias_match_indexes)rU schema_inforWoutsr*arg_idx return_idxsf&&& r_correct_storage_aliasingr4gs dEJJ11 2 2?T |LMM dE " "9$t*FGG dT5M * *A$t*NOO)6)6V +HH!$-1AB IrcV^8dQhRR/#)rr str | Noner)rs"rrrs ! !: !rcVPpV'dVP'gR#\V4^8wd \R4h\ \ V44#)Nz1Expected alias_set to contain exactly one element) alias_setis_writelenrFnextiter)xr8s& r_get_write_aliasr>sB I AJJJ 9~PQQ Y  rc6]tRtRt$R]R&R]R&R]R&RtR #) AliasInfoizset[str]r8rr9r6namerNr}r~rrrrrrrr@r@sN rr@cJ]tRtRt$R]R&R]R&R]R&R]R&R ]R &R tR #) SchemaInfoizlist[AliasInfo]rWr1ris_inplace_view_opzlist[str] | Noneouts_write_aliaseszlist[tuple[int, int]]r/rNrBrrrrDrDs$   )($98rrDcV^8dQhRR/#)rrrDr)rs"rrrs__J_rc VPR8XEd\VP4pVPR4'g \ R4hVR,p^RIpVP RRV4pVP RRV4pVP R R V4p\PPPV4pVPPUu.uFzp\VPf \4M\VPP 4VPRJ;'dVPP"VP$R 7NK| ppVP&Uu.uFzp\VPf \4M\VPP 4VPRJ;'dVPP"VP$R 7NK| ppEM4VPPUu.uFzp\VP(f \4M\VP(P*4VP(RJ;'dVP(P"VP$R 7NK| ppVPP&Uu.uFzp\VP(f \4M\VP(P*4VP(RJ;'dVP(P"VP$R 7NK| pp.p\-V4Fkwr\-V4FWwrV P V P ,;'dV P"'*p V 'gKEVP/W34KY Km VU u.uFp \1V 4NK pp \3R V44pV^8XdRpMPV\5V48wd&\7R \VP4,4h\9\:\,V4p\=VV\>P@PBVPD9VVR7pV#uupiuupiuupiuupiuup i)atenzaten::z6Expected torchgen schema string to start with 'aten::':NNNz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=\[(-?[0-9]+), (-?[0-9]+)\]z=[\1,\2])r8r9rAc3("TFqRJxK R#5irr).0r=s& r !get_alias_info.. sC+BaTM+BszUnsupported schema: )rWr1rErFr/)# namespacer"_schema startswithrFrertorchgenmodelFunctionSchemaparse argumentsflat_allr@ annotationsetr8r9rAreturns alias_info before_set enumerater[r>sumr: RuntimeErrorrr!rDr*Tag inplace_viewtags)rUtorchgen_schema_strrRtorchgen_schemaa arg_schemas out_schemasr/r2 schema_argr3 schema_outis_read_only_alias_matchr)outs_write_aliases_list non_nonesrFr0s& rget_alias_inforns ~~!$,,/"--h77 H  2"5!ff^T;NO ff^T;NO ff *K9L #..77==>QR%..77  8 \\1CEs1<<;Q;Q7RT1KKall6K6KVV  8   $%,,  - \\1CEs1<<;Q;Q7RT1KKall6K6KVV  -   (\\++  , \\1CEs1<<;R;R7ST1KKall6K6KVV  ,   $\\))  * \\1CEs1<<;R;R7ST1KKall6K6KVV  *   %'!(5&/ &< "J$$z';';;(*(* ))) %('-44g5JK '= 6&11%0[1C+BCCIA~/3 c12 21C 4EEFF!$s)-DE  !9911TYY>-&CK Q        &1s:AQ&+Q!AQ6+Q=AQ+QAQ!,+Q!Q&c$V^8dQhRRRRRR/#)rrUztorch._ops.OpOverload flat_argszSequence[torch.Tensor | object]rrr)rs"rrr5s$7(7( 7(,K7( 7(rcRpVFp\V\P4'gK%\PP \PP VP P44pVf#\RVP P 24h\PPVP4V4pV'*# V'*#)a Suppose that an operator has CompositeImplicitAutograd decomp registered. Would autograd have used this decomposition? It will only use it if there isn't an explicit backend registration for the device as well. This function will tell if this would have occurred. Why do we need to apply these decompositions later? When inference mode is on, the autograd key is bypassed entirely, so a lower level mode cannot rely on the decomposition having been applied. It's easy to accidentally never apply the decomposition, resulting in an operator showing up in a graph that is unexpected. Why do we need to AVOID applying the decomposition when autograd wouldn't have decomposed? If autograd doesn't decompose, this means in eager mode we would have run the fused kernel. It must be possible to trace this fused kernel directly into the graph for fidelity with eager (NB: a user has the option of then further decomposing at proxy tensor mode via decomposition table, but we must preserve it to proxy mode to have the choice.) Why does functionalization need to also perform the test here? This is because some CompositeImplicitAutograd decompositions are not functional. If we are eventually going to decompose, we need to do this while we can still turn functionalization back on, so those decompositions get functionalized. So an early decomposition in functionalization may still be necessary. Note that if proxy tensor decomposition process could turn functionalization back on, this wouldn't be necessary, and maybe that is a useful thing to do anyway because the decomposition table is user specified and a user could violate the functional decomp requirement with a bad decomp. If this happened, then you could always pass through functionalization. Fz(failed to parse dispatch key for device ) r<r*r r+_parse_dispatch_key_dispatch_key_for_devicerr rF%_dispatch_has_kernel_for_dispatch_keyrA)rUrphas_backend_registrationrf backend_keys&& rautograd_would_have_decomposedrw5sD %  a & &((6611!((--@K"$>qxx}}oN (-xx'U'U [( $ ' '')(( ''rc a\S4pV3Rlp\SYA\V\4'gV3MT4VP'Ed\ V4UUu.uF'wrg\ VPV,4fK%VNK) ppp\V4^8wd \R4h^RI H p \V^,V 4'g\PPP4;_uu_4\P P#4p \P P%R4S!V/VB\P P%V 4RRR4VP&p V fV#\V 4^8XdV!V ^,WAV4#\)V4!V U u.uF p V!WW4NK up 4p V #uuppi \P P%T 4i;i +'giL;iuup i)a. This function should be used by wrapper tensor ``__torch_dispatch__`` subclasses that would like to work with torch.compile. It ensures that the subclass properly implements the aliasing behavior of every op, which is needed for correctness in AOTAutograd. This function will handle: * When we see a view op, we will alias the storages of any input and output tensor subclasses * When we see an inplace or out= op, we will directly return the corresponding input tensor, instead of returning a (potentially) fresh output tensor. c<\PPPS W#R7wrE\ VP 4UUu.uFwrgWP 9gKVNK ppp\V4^8wd \R4hV^,p VP V ,p V Pe$V PV9dWZP,#WI,#uuppi))rWr@z>Expected exactly one argument index for the given output alias) r*fxoperator_schemasnormalize_functionr^rWr8r:rFrA) output_aliasr0rWr@new_args new_kwargsrrf arg_indicesr0arg_inforUs &&&& rget_arg_from_alias7return_and_correct_aliasing..get_arg_from_aliass$xx88KK t L  $K$4$45 5$!9TAA5   { q  P !n##C( == $*)Dmm, ,} s C CNz5expected exactly one mutated arg for inplace_view ops)FunctionalTensorT)rnr4r<r.rEr^r>rWr:rFrrr*utils _mode_utils no_dispatchr+_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includerFr )rUrWr@outr0rrr= mutated_argsr meta_in_tlsschema_info_outs_write_aliases write_aliasouts_to_returnsf&&& rreturn_and_correct_aliasingros$!&K* kz#u/E/E#3 %%% "$ ' 0 0 34 A'   |  ! G  I,q/+;<<((4466$hhDDF ::4@L$)&)HH>>{K7&1%C%C"%-  )*a/! *1 -{&  #Y > =  $ G= N ] 2HH>>{K760 s6"GG4>G*3G;G*%G=!G''G** G: rZr)NN)@ __future__r contextlib functoolsrl collectionsr dataclassesrtypingrrrr typing_extensionsr r*rStorchgen.modeltorch._Cr r r rrtorch._C._dynamo.guardsrcollections.abcrrtorch._custom_class_baserr r!r&r"r'r2r4rrrrrr\rccontextmanagerrrrrTensorWithFlattenrr rrr4r>r@rDcachernrwrrrrrsm"!::$ T18#',$380<"CCL42" # A!*,  55p%-%PxPf-S G'T?CD !     9 9  9$ __D7(t`r