tjnddlmZddlZddlZddlZddlmZddlmZddl m Z m Z m Z m Z ddlmZddlZddlZddlZddlmZmZmZmZmZddlmZe rdd lmZmZdd lmZd a d a!d a"d@dAdZ#dBdZ$dBdZ%GddZ&dCdZ'dZ(dZ)dZ*dDdZ+dEdZ,dFdGd!Z-ej.dFdHd#Z/ej.d$Z0Gd%d&e&Z1Gd'd(e Z2e2Z3dId+Z4dJd-Z5dKd0Z6dLd1Z7dMd2Z8dNd4Z9eGd5d6Z:eGd7d8Z;ej<dOd9Z=dPd>Z>d?Z?dS)Q) 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) OpaqueBaseFTinclude_infra_modesboolreturnc"|rtntSN)_is_in_torch_dispatch_mode$_is_in_non_infra_torch_dispatch_mode)rs Z/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/utils/_python_dispatch.pyis_in_torch_dispatch_moder+s  2"" 1ctSr)0_is_in_any_mode_without_ignore_compile_internalsrr/is_in_any_mode_without_ignore_compile_internalsr!3s ;;rctj}t|D]=}t |}|r&|r;dSdS)NTF)torch_Cr ranger is_infra_modeignore_compile_internals) stack_lenidxmodes r any_torch_dispatch_mode_on_stackr+7su2244IY  %c**         ( ( * *  tt 5rceZdZdZdZfdZddZdZddZd Z d Z e d Z e ddZ e ddZe ddZxZS)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 tjdi||rHd|jvrA|jd}t |t s!t j|d|_dSdSdSdS)N__torch_dispatch__T) recursiver ) super__init_subclass___should_skip_dynamo__dict__ isinstance classmethodr#_disable_dynamor/)clskwargsraw __class__s rr2z#TorchDispatchMode.__init_subclass__ms!!++F+++  " " $ $ X#s|33l#78!#{33X-2-B3RV-W-W-WC***  X X33XXrNc|8t|tjjst d||jd<t |_t |_t |_ dS)Nz,_dispatch_key must be a torch._C.DispatchKey _dispatch_key) r5r#r$rAssertionErrorr4rold_dispatch_mode_flags!old_non_infra_dispatch_mode_flags8old_without_ignore_compile_internals_dispatch_mode_flags)selfr=s r__init__zTorchDispatchMode.__init__ush  $mUX-ABB U$%STTT-:DM/ *49GG$>Cgg. GG EEErct|dst|_t|dst|_t|dst|_dSdS)Nr?r@rA)hasattrrr?r@rArBs r"_lazy_init_old_dispatch_mode_flagsz4TorchDispatchMode._lazy_init_old_dispatch_mode_flagss{t677 @8=D (t@AA JBG''D 2 L      I I I  rr ctr)NotImplementedErrorrBfunctypesargsr9s rr/z$TorchDispatchMode.__torch_dispatch__s!!rc||jtda|jt t p| a|jttp| attt||S)NT) rGr?appendrr@rr&rArr'r _push_moderFs r __enter__zTorchDispatchMode.__enter__s //111 $++,FGGG%)" .55 0    1 L8J8J8L8L4L - ELL <    = 300222 9 8 <    4 rcR|jdd}||jdd}|ja|ja|jattt|dS)Nr= _mode_key) r4getr?poprr@rrArr _pop_mode)rBexc_typeexc_valexc_tbmb_dk_or_mode_keys r__exit__zTorchDispatchMode.__exit__s M--otDD  $!% 1 1+t D D %)%A%E%E%G%G"  2 6 6 8 8 -  I M M O O 9 8 <    #$$$$$rcBtjdd||i|}|S)NzP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`) stacklevel)warningswarn)r8rMr9instances rpushzTorchDispatchMode.pushs< ^    3'''rrrcdS)NFr r8s rr&zTorchDispatchMode.is_infra_modesurcdS)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 Tr rds rr3z%TorchDispatchMode._should_skip_dynamos 0trc2|rdSdS)a9Ignore 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&rds rr'z*TorchDispatchMode.ignore_compile_internalss"8      4urrr Nrr)__name__ __module__ __qualname____doc__supports_higher_order_operatorsr2rCrGr/rQr[r6rbr&r3r' __classcell__)r;s@rr-r-Hs D',#XXXXX        """">%%%*[[[2[rr-TorchDispatchMode | NonecRt}|dkrt|dz SdS)zk Return the top user mode on the stack (the next one that would be executed) if there are any. rN)r r r(s r_get_current_dispatch_moderss/ *++I1}}%i!m444 4rcp|tjjjtjjjfvr@t dtjjjdtjjjd|ddlm}||}tj|}||t d||S|S)Nzkey must be either FUNCTIONAL (z) or PROXY (z1) _TorchDispatchModeKey, got r)_get_dispatch_mode_pre_dispatchzEAt most one of pre_dispatch_mode and post_dispatch_mode may be active) r#r$_TorchDispatchModeKey FUNCTIONALPROXYr> torch._opsru_get_dispatch_mode)keyrupre_dispatch_modepost_dispatch_modes r_detect_infra_moder~s  &1 &, eh.L.W   89?       ;:::::77<<44S99$);)G S    !! rcddlm}m}||}tj|}|r|rt d|r ||}|S|rtj|SdS)Nr)ruunset_mode_pre_dispatchzECan't have active infra mode on both pre and post dispatch mode stack)ryrurr#r$rzr>_unset_dispatch_mode)r{rurr|r}r*s r_unset_infra_moder3sSSSSSSSS77<<44S99 /  S   &&s++ 2x,,S11122rc#K|tjjjtjjjfvrt dt |} |V|t|dSdS#|t|wwxYw)NzrrP)r{ mode_unsets r_disable_infra_moderDs  &1 &, J   #3''J#  ! z " " " " " " !: ! z " " " " "s A))A=list[TorchDispatchMode]cPt}dt|DS)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). c,g|]}t|Sr )r ).0is r z4_get_current_dispatch_mode_stack..[s! @ @ @! "1 % % @ @ @r)r r%rrs r _get_current_dispatch_mode_stackrTs+ *++I @ @uY/?/? @ @ @@rr*Nonecft|dr|jnd}|)|tjjjkrt d|t|dSddlm }m }tj |}|D]}|D]}| |||dS)Nr=z:mode._dispatch_key must be None or DispatchKey.PreDispatchr)_set_mode_pre_dispatchget_cached_ops) rEr=r#r$r PreDispatchr>rryrr_functionality_to_backend_keys_uncache_dispatch)r*krrksopr{s rrPrP^s%dO<<F$A}eh2>>> H    y%d+++AAAAAAAA  0 0 3 3Bn&& & &C   % % % % &4     rr3DispatchKey | torch._C._TorchDispatchModeKey | Nonec|tjjjkrddlm}|S|t |tjjrt|SdS)Nr)_pop_mode_from_pre_dispatch) r#r$rrryrr5rvr )rrs rrVrVsscEH ,,,::::::**,,,yJq%("@AAy(+++yrDispatchKey | Nonec#xKt|} |Vt|dS#t|wxYwr)rVrP)rolds r_pop_mode_temporarilyr}s> A,,C 3 3s(9c#LKddlm}mddlm}ddlm}ddlm}|}fdt|D}d}d}d}|D]8} t| |rd}t| |rd}t| |rd}9t} d t| D} | D]e} t| |r|rtd t| |r|rtd t| |r|rtd f || zVt| D]} t| t|D]} t| dS#t| D]} t| t|D]} t| wxYw) Nr)&_len_torch_dispatch_stack_pre_dispatchr)FunctionalTensorMode)SchemaCheckMode)ProxyTorchDispatchModec$g|] } Sr r )r_rs rrz*_disable_current_modes..s0*+##%%rFTc*g|]}tSr )rV)rrs rrz*_disable_current_modes..s666666rzFCan'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 Key)ryrr#torch._subclasses.functional_tensorr#torch._subclasses.schema_check_moder"torch.fx.experimental.proxy_tensorrr%r5r r>reversedrP)rrrrmode_len_pre_dispatchold_pre_dispatch_modeshas_proxy_mode_in_pre_dispatch#has_functional_mode_in_pre_dispatch%has_schema_check_mode_in_pre_dispatchrmode_len old_modesrr*rs @r_disable_current_modesrsIHHHHHCCCCCCIIIIIIBBDD/45J/K/K&+"*/',1) #99 a/ 0 0 2-1 * a- . . 726 / a ) ) 948 1(**H66eHoo666I s0 1 1 3 !X  c1 2 2 7U  `  c? + + 0U  Y  $y0000Y''  D t    344  D t      Y''  D t    344  D t     s EAF#ceZdZddZdS)BaseTorchDispatchModer Nc|i}||i|Srr rJs rr/z(BaseTorchDispatchMode.__torch_dispatch__s! >FtT$V$$$rrg)rirjrkr/r rrrrs(%%%%%%rrc"eZdZUdZd+dZed,d Zded<ed-d.dZ ed/dZ ed-d.dZ ed/dZ d0dZ d0dZ e d1ddd2d$Z e d3ddd4d(Z e d1ddd5d*Z dS)6TraceableWrapperSubclassa 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. rtuple[Sequence[str], object]cdSrr rFs r__tensor_flatten__z+TraceableWrapperSubclass.__tensor_flatten__r inner_tensors'Mapping[str, torch.Tensor | OpaqueBase]metadataobject outer_sizeSequence[int | torch.SymInt] outer_stride torch.TensorcdSrr )rrrrs r__tensor_unflatten__z-TraceableWrapperSubclass.__tensor_unflatten__s srz torch._C.SizeshapeNdimrtuple[int, ...]cdSrr rBrs rstridezTraceableWrapperSubclass.strides;>3rintcdSrr rs rrzTraceableWrapperSubclass.strides'*srcdSrr rs rsizezTraceableWrapperSubclass.sizes9<rcdSrr rs rrzTraceableWrapperSubclass.sizes%(SrcdSrr rFs rstorage_offsetz'TraceableWrapperSubclass.storage_offsetrrcdSrr rFs rrzTraceableWrapperSubclass.dimrrF) memory_formatdtypetorch.types._dtype non_blockingrcopyrtorch.memory_format | NonecdSrr )rBrrrrs rtozTraceableWrapperSubclass.to srdevice)torch._prims_common.DeviceLikeType | Nonetorch.types._dtype | NonecdSrr )rBrrrrrs rrzTraceableWrapperSubclass.tos srothercdSrr )rBrrrrs rrzTraceableWrapperSubclass.torr)rr) rrrrrrrrrrr)rrrr)rrrr)rr)FF) rrrrrrrrrr)NNFF) rrrrrrrrrrrr) rrrrrrrrrr)rirjrkrlr staticmethodr__annotations__rrrrrrr rrrrs,FEEE\ >>>>X> ***X* <<<<X< (((X((((( #  59 X=A+/" 59X#  59 XrrtrcBt|dot|dS)Nrr)rErs r(_has_traceable_wrapper_subclass_protocolrs# 1* + + R;Q0R0RRr TypeIs[TraceableWrapperSubclass]ct|tjot|tju}|ot |S)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. )r5r#Tensortyper)r is_subclasss ris_traceable_wrapper_subclassr#s;Q --M$q''2MK  FCAFFFrr&TypeIs[type[TraceableWrapperSubclass]]cpt|tjo|tjuot|S)z@Same as above, but takes a type argument instead of an instance.) issubclassr#rrrs r"is_traceable_wrapper_subclass_typer2s7 1el## 8 U\ ! 8 4Q 7 7rc .||n|}||n|}|\}}i}|D]}||t||||< t |||||}|j|kr*tdt |d|d|j||kr7tdt |d|d||S)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. NzExpected return value from z.__tensor_unflatten__() to have shape equal to z , but got: z/__tensor_unflatten__() to have stride equal to )rrrgetattrrrrr>) rcallbackrrattrsctxtransformed_tensors_dictattrsubs rtransform_subclassr=sm *516688J#/#;<<L%%''JE3!JJ)1$48H8H)I)I && q'' & & #z<  C yJ A$q'' A A( A A58Y A A    zz|||## G$q'' G G+ G G8;  G G   Jrcttjjst dt |t|t st dt |t|tt fst dt |dfd }|jD]\}}|||||dS) 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 rrc t|}t|}||urt|st|r}t|tr|n|g}|D]`}t|t|ur@t dt dt|dt|dat|tr|D]}t j||dSt|t jst dt|t j||dS)NzCalled z with input of type z and output of type z. But expected types to match.zexpected torch.Tensor, got ) rrr5listr>strr#_functionalize_unsafe_setr)argretarg_typeret_typeret_listrrKs ralias_non_inplace_storagez<_correct_storage_aliasing..alias_non_inplace_storagezsx9999 8 # # .x 8 8 $1(;; $)d33>ss#H  99DGG++(X#d))XXcXX.23iiXXX, c4  6 8 8/37777 8 8c5<00 P$%N499%N%NOOO  +C 5 5 5 5 5rNrr) r5r#_ops OpOverloadr>rtuplerread_only_alias_match_indexes)rK schema_inforMoutsrarg_idx return_idxs` r_correct_storage_aliasingrgs dEJ1 2 2NLT LLMMM dE " "HF$t**FFGGG dT5M * *PN$t**NNOOO)6)6)6)6)6)6V +HCC!!$w-j1ABBBBCCr str | Nonec|j}|r|jsdSt|dkrtdt t |S)Nrqz1Expected alias_set to contain exactly one element) alias_setis_writelenr>nextiter)xrs r_get_write_aliasrsU I AJt 9~~PQQQ Y  rc.eZdZUded<ded<ded<dS) AliasInfozset[str]rrrrnameNrirjrkrr rrrrs3NNNrrcBeZdZUded<ded<ded<ded<ded <d S) SchemaInfozlist[AliasInfo]rMr ris_inplace_view_opzlist[str] | Noneouts_write_aliaseszlist[tuple[int, int]]r Nrr rrrrsR )(((988888rrc8|jdkrt|j}|dst d|dd}ddl}|dd|}|dd |}|d d |}tjj |}d |j j D}d |j D}n,d|jj D}d|jj D}g}t|D]J\}}t|D]5\} } |j| jzo|j } | r||| f6Kd|D} t%d| D} | dkrd}nW| t'| kr$t)dt|jzt+t,t| }t/||t0jj|jv||}|S)Natenzaten::z6Expected torchgen schema string to start with 'aten::'rz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=\[(-?[0-9]+), (-?[0-9]+)\]z=[\1,\2]cg|]X}t|jtnt|jj|jduo |jj|jYSN)rrrr annotationsetrrrras rrz"get_alias_info..q     \1CEEEs1<;Q7R7RT1Kal6KV        rcg|]X}t|jtnt|jj|jduo |jj|jYSr&r'r*s rrz"get_alias_info..r,rcg|]X}t|jtnt|jj|jduo |jj|jYSr&r alias_infor) before_setrrr*s rrz"get_alias_info..q     \1CEEEs1<;R7S7ST1Kal6KV        rcg|]X}t|jtnt|jj|jduo |jj|jYSr&r/r*s rrz"get_alias_info.. r2rc,g|]}t|Sr )r)rrs rrz"get_alias_info..s.111 !111rc3K|]}|duV dSrr )rrs r z!get_alias_info.. s&CCaATMCCCCCCrzUnsupported schema: )rMr r r!r ) namespacer_schema startswithr>rertorchgenmodelFunctionSchemaparse argumentsflat_allreturns enumeraterrrOsumr RuntimeErrorrrrr#Tag inplace_viewtags)rKtorchgen_schema_strr:torchgen_schema arg_schemas out_schemasr r schema_argr schema_outis_read_only_alias_matchouts_write_aliases_list non_nonesr!r s rget_alias_inforQs ~!$,//"--h77  H  2!""5 !ff^T;NOO ff^T;NOO ff *K9L  #.7==>QRR   %.7       %,       \+       \)    %'!(55LL&/ &<&< L L "J $z';;(* )) %( L-44gz5JKKK  L11%0111CC+BCCCCCIA~~/3 c122 2 21C 4E4EEFFF!$s)-DEE  !91TY>-&CK rrKtorch._ops.OpOverload flat_argsSequence[torch.Tensor | object]czd}|D]}t|tjrtjtj|jj}|td|jjtj | |}n| S)aP 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. FNz(failed to parse dispatch key for device ) r5r#rr$_parse_dispatch_key_dispatch_key_for_devicerrr>%_dispatch_has_kernel_for_dispatch_keyr)rKrShas_backend_registrationr+ backend_keys rautograd_would_have_decomposedr[5sD %  a & & (6611!(-@@K"$Nqx}NN (-x'U'U [(( $ E% &( ''rc  t fd t t|ts|fn| jr fdt D}t |dkrtdddlm }t|d|stj j 5tj}tjd itj|n$#tj|wxYw dddn #1swxYwY j}||St |dkr |d St%|  fd |D}|S) aZ 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. cRtjj ||\}}fdt |jD}t |dkrtd|d}|j|}|j|j|vr ||jS||S)N)rMr9c,g|]\}}|jv|Sr )r)rrr+ output_aliass rrzKreturn_and_correct_aliasing..get_arg_from_alias..s0   !Q9T9TA9T9T9Trrqz>Expected exactly one argument index for the given output aliasr) r#fxoperator_schemasnormalize_functionrBrMrr>r) r_r rMr9new_args new_kwargs arg_indicesr)arg_inforKs ` rget_arg_from_aliasz7return_and_correct_aliasing..get_arg_from_aliass$x8KK tF L  *    #K$455    {  q  P !n#C( = $*)D)Dhm, ,}rcNg|]!\}}tj||"Sr)rrM)rrrr s rrz/return_and_correct_aliasing..s=   1 0 344@ @@@rrqz5expected exactly one mutated arg for inplace_view opsr)FunctionalTensorTNc,g|]}|Sr r )r write_aliasrMrgr9r s rrz/return_and_correct_aliasing..s:     [$ G G   r)rQrr5r r rBrr>rrir#utils _mode_utils no_dispatchr$_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includer!r) rKrMr9out mutated_argsri meta_in_tlsschema_info_outs_write_aliasesouts_to_returnrgr s ``` @@rreturn_and_correct_aliasingrvos$!&&K* k4z#u/E/E!N#3 %L    !$    |   ! ! G  IHHHHH,q/+;<< L(4466 L L$hDDFF ::4@@@LD$)&)))H>>{KKKKEH>>{KKKKK L L L L L L L L L L L L L L L&1%C"%-  )**a//!! *1 -{D&   T#YY       =   N s*>E D/ E /!EE  E$'E$)T)rrrrrh)rro)rr)r*r-rrr)rr)rr)rrrr)rrrr)rrrr)NNr)rr)rr)rKrRrSrTrr)@ __future__r contextlib functoolsr_ collectionsr dataclassesrtypingrrrr typing_extensionsr r#r;torchgen.modeltorch._Cr r r rrtorch._C._dynamo.guardsrcollections.abcrrtorch._opaque_baserrrrrr!r+r-rsr~rrrrPrVcontextmanagerrrrrTensorWithFlattenrrrrrrrrcacherQr[rvr rrrsB""""""!!!!!!::::::::::::$$$$$$ TSSSSS.11111111------#',$380<<<<"CCCCCCCCL4222" # # # AAAA!!!!*,,,,,  555p%%%%%-%%%PPPPPxPPPf-SSSS G G G G''''T?C?C?C?CD ! ! ! !     9 9 9 9 9 9 9  9$ ____D7(7(7(7(t`````r