Ë
    g^(hw) ã                  óÂ	  — U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlmZmZ ddlmZ ddlmZmZmZmZmZ ddlmZ ddlmZmZmZmZm Z m!Z!m"Z" dd	l#m$Z$m%Z% ddl&Z&ddl'Z&ddl(Z&ddl)m*c m+Z, dd
l-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZD ddlEmFZFmGZG ddlHmIZI ddlJmKZKmLZL ddlMmNZN ddlOmCZC ddlPmQZQ ddlRmSZS  e	j¨                  eU«      ZVe&j®                  j°                  ZXe&j®                  j²                  ZYeZZe"eZe&jš                  j¶                  f   Z\ G d„ de «      Z] G d„ d e «      Z^ G d!„ d"e «      Z_ e!d#«      Z`e"e&jš                  jÂ                  jÄ                  ecf   Zd G d$„ d%«      Ze ee«       Zf	 d‡	 	 	 	 	 	 	 dˆd&„Zg G d'„ d(«      Zh G d)„ d*ei«      Zje"ehejf   Zkd‰d+„Zl G d,„ d-«      Zm G d.„ d/e«      Zn G d0„ d1en«      Zo G d2„ d3en«      Zp G d4„ d5en«      Zq G d6„ d7en«      Zr G d8„ d9en«      Zseted:f   Zu G d;„ d<es«      Zv G d=„ d>ev«      Zw G d?„ d@ev«      Zx G dA„ dBev«      Zy G dC„ dDes«      Zz G dE„ dFez«      Z{ G dG„ dHez«      Z| G dI„ dJez«      Z} G dK„ dLen«      Z~ G dM„ dNen«      Z G dO„ dPen«      Z€ G dQ„ dR«      Z� G dS„ dTe «      Z‚e�j                   G dU„ dV«      «       Z„e�j                   G dW„ dXe„«      «       Z…e�j                   G dY„ dZe„«      «       Z†e�j                   G d[„ d\e„«      «       Z‡dŠd]„Zˆd‹d^„Z‰	 dŒ	 	 	 	 	 	 	 	 	 d�d`„ZŠeˆddadd_f	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dŽdb„Z‹ eAec   «       ZŒ	 	 	 	 	 	 	 	 	 	 	 	 d�dc„Z� eeŽ«      �j                  ddz  dez  Z�g Z‘dfe’dg<   eˆddad_f	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d�dh„Z“ eD�j(                  d_¬i«      	 	 d‘	 	 	 	 	 	 	 	 	 	 	 d’dj„«       Z•	 	 d‘	 	 	 	 	 	 	 	 	 	 	 d“dk„Z–eˆfd_dlœ	 	 	 	 	 	 	 	 	 d”dm„Z—eˆfd_dlœ	 	 	 	 	 	 	 	 	 d”dn„Z˜d•do„Z™ e�j4                  dp«      Z›d–dq„Zœd—dr„Z�d˜ds„Zžd™dt„ZŸdšdu„Z d›dv„Z¡ G dw„ dx«      Z¢dœdy„Z£	 	 	 	 d�	 	 	 	 	 	 	 	 	 	 	 dždz„Z¤ e&�jJ                  «       d{dd|œ	 	 	 	 	 	 	 	 	 dŸd}„«       Z¦ e&�jN                  «       d d~„«       Z¨d¡d„Z©d›d€„Zªd¢d�„Z«d£d‚„Z¬d¤dƒ„Z­ eAec   «       Z®	 d¥	 	 	 	 	 	 	 d¦d„„Z¯d§d…„Z°d¨d†„Z±y)©a4  
# Inductor Pattern Matcher

The pattern matcher enables search/replace within an FX graph.

The main entrypoint to the pattern matcher is register_replacement(). Given a
search function and a replacement function this will register a replacement with
a pass (such as torch._inductor.fx_passes.joint_graph.patterns).

Internally the pattern matcher represents patterns as a graph (a DAG). Creating
new patterns manually as a graph is cumbersome and error-prone so the standard
way to create patterns (using register_replacement()) is to provide a search
function and a replacement function which is traced and converted into a graph.

Because the search functions are built somewhat generic (they tend to ignore
tensor sizes, for example) register_replacement() allows you to specify an
`extra_check` function which performs additional checks to verify that the
matched pattern fully matches before returning it.

## Precompiled Patterns

New patterns are added using register_replacement(). Patterns added in this way
can have a compile-time overhead because they need to be traced before
use. Patterns can be precompiled and added using gen_register_replacement()
instead. To do this you call gen_register_replacement() instead of
register_replacement(). The arguments are the same except for an additional
unique name which is used as a lookup key.

## Internals

The match DAG is represented by a graph of `PatternExpr` nodes. Each PatternExpr
implements a `_match` method which returns either a `Match` object for a
successful match or a `FailedMatch` object for a failure to match.
é    )ÚannotationsN)ÚABCÚabstractmethod)Údefaultdict)Ú
CollectionÚ	GeneratorÚIterableÚMappingÚSequence)ÚPath)ÚAnyÚCallableÚNoReturnÚOptionalÚProtocolÚTypeVarÚUnion)ÚSelfÚTypeIs)Úenable_python_dispatcher)Úcounters)Úis_integer_dtype)Úunset_fake_temporarily)Úmake_fx©Ústatically_known_true)Ú	_get_attr)Úimmutable_dictÚimmutable_list)ÚGraphTransformObserver)Ú
OrderedSeté   ©Úconfig)Úaot_functionÚmake_boxed_func)Údefault_partition)Ú
FakeTensorÚFakeTensorMode)ÚTransformeré   )Úselect_decomp_table)Ú%fallback_node_due_to_unsupported_typec                  ó    — e Zd ZU ded<   dd„Zy)ÚSearchFnÚstrÚ__name__c                 ó   — y ©N© ©ÚselfÚargsÚkwargss      ú]/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/_inductor/pattern_matcher.pyÚ__call__zSearchFn.__call__]   ó   � ó    N©r7   r   r8   r   Úreturnr   )r1   Ú
__module__Ú__qualname__Ú__annotations__r:   r4   r<   r9   r/   r/   Z   s
   … ØƒMä=r<   r/   c                  ó   — e Zd Zdd„Zy)Ú	ReplaceFnc                 ó   — y r3   r4   r5   s      r9   r:   zReplaceFn.__call__a   r;   r<   Nr=   ©r1   r?   r@   r:   r4   r<   r9   rC   rC   `   s   „ Ü=r<   rC   c                  ó$   — e Zd Z	 	 	 	 	 	 	 	 dd„Zy)ÚTraceFnc                 ó   — y r3   r4   )r6   Úfnr7   r8   s       r9   r:   zTraceFn.__call__e   s   € à"r<   N)rI   zUnion[SearchFn, ReplaceFn]r7   r   r8   r   r>   útorch.fx.GraphModulerE   r4   r<   r9   rG   rG   d   s'   „ ð#Ø,ð#Ø58ð#ØDGð#à	ô#r<   rG   ÚTc                  ó   — e Zd Zdd„Zy)ÚMultiplec                ó2   — dt        «       vs| t        u sJ ‚y y )NÚMULTIPLE)ÚglobalsrO   ©r6   s    r9   Ú__init__zMultiple.__init__q   s   € à¤£Ñ*¨d´hÑ.>Ð>Ð>Ð.>Ð*r<   N©r>   ÚNone)r1   r?   r@   rR   r4   r<   r9   rM   rM   p   s   „ ô?r<   rM   c                óš  — ddl m}m} t        j                  j
                  ry| j                  dg «      j                  «       }|j                   ||||j                  «      «       | j                  d„ |j                  j                  «       D «       «       || d<   y | j                  d„ |j                  j                  «       D «       «       y )Nr   )Ú
NodeSourceÚNodeSourceActionÚ	from_nodec              3  óv   K  — | ]1  \  }}|t         j                  j                  j                  v r||f–— Œ3 y ­wr3   ©ÚtorchÚfxÚproxyÚ_COPY_META_FIELDS©Ú.0ÚkÚvs      r9   ú	<genexpr>z!_transfer_meta.<locals>.<genexpr>†   ó6   è ø€ ò 
á��1Ø”E—H‘H—N‘N×4Ñ4Ñ4ð �ŒFñ
ùó   ‚79c              3  óv   K  — | ]1  \  }}|t         j                  j                  j                  v r||f–— Œ3 y ­wr3   rZ   r_   s      r9   rc   z!_transfer_meta.<locals>.<genexpr>�   rd   re   )Útorch.fx.tracebackrV   rW   r$   ÚtraceÚenabledÚgetÚcopyÚappendÚREPLACEÚupdateÚmetaÚitems)Únew_metaÚold_nodeÚ	pass_namerV   rW   Únew_from_nodes         r9   Ú_transfer_metaru   z   s¦   € ÷ @ô
 ‡|�|×Òà Ÿ™ [°"Ó5×:Ñ:Ó<ˆØ×Ñ™Z¨°)Ð=M×=UÑ=UÓVÔWØ�‰ñ 
à Ÿ™×+Ñ+Ó-ô
ô 	
ð
 !.ˆ�Òà�‰ñ 
à Ÿ™×+Ñ+Ó-ô
õ 	
r<   c                  óú   ‡ — e Zd ZU dZded<   ded<   ded<   ded	<   d
ed<   ded<   ded<   	 	 d	 	 	 	 	 	 	 	 	 dˆ fd„Zedd„«       Zdd„Zdd„Z	dd„Z
d d„Zd!d„Zd"d„Z	 	 	 	 	 	 d#d„Z	 	 d$	 	 	 	 	 	 	 	 	 d%d„Zˆ xZS )&ÚMatcha‹  
    Represents a successfully matched pattern.

    The `Match` object is returned to represent a successfully matched
    pattern. Included in the Match are the pattern that was matched, the graph
    nodes matched, and any args that were used during the matching.

    The args and kwargs are specific to the type of pattern that was matched and
    provide hints about what was matched.
    ÚPatternExprÚpatternú	list[Any]r7   údict[str, Any]r8   úlist[torch.fx.Node]Únodesz'dict[_TargetExpr, torch.fx.node.Target]ÚtargetsÚMatchContextÚctxzOptional[torch.fx.GraphModule]Úreplacement_graphc                ó¦   •— t         ‰| �  «        || _        t        |xs g «      | _        |xs i | _        g | _        i | _        || _        d | _	        y r3   )
ÚsuperrR   ry   Úlistr7   r8   r}   r~   r€   r�   )r6   r€   ry   r7   r8   Ú	__class__s        €r9   rR   zMatch.__init__¨   sO   ø€ ô 	‰ÑÔØˆŒä˜š Ó$ˆŒ	Ø’l ˆŒàˆŒ
àˆŒØˆŒØ!%ˆÕr<   c                ó.   — | j                   j                  S r3   )r€   ÚgraphrQ   s    r9   r‡   zMatch.graph»   s   € à�x‰x�~‰~Ðr<   c                ó2  — | j                   rwt        | j                   j                  «       «      t        |j                   j                  «       «      z  D ]-  }| j                   |   |j                   |   k7  sŒ#t        d|«      ‚ | j                  j                  |j                  «       | j                  j                  |j                  «       | j                   j                  |j                   «       | j                  j                  |j                  «       y )Nzkwarg mismatch: {})	r8   r!   ÚkeysÚFailedMatchr7   Úextendr}   rn   r~   )r6   ÚotherÚkeys      r9   r‹   zMatch.extend¿   sÅ   € Ø�;Š;Ü! $§+¡+×"2Ñ"2Ó"4Ó5¼
À5Ç<Á<×CTÑCTÓCVÓ8WÑWò A�Ø—;‘;˜sÑ# u§|¡|°CÑ'8Ó8Ü%Ð&:¸CÓ@Ð@ðAð 	�	‰	×Ñ˜Ÿ™Ô$Ø�
‰
×Ñ˜%Ÿ+™+Ô&Ø�‰×Ñ˜5Ÿ<™<Ô(Ø�‰×Ñ˜EŸM™MÕ*r<   c                óf   — | j                   rt        | j                   «      g| _         | S g | _         | S r3   )r7   ÚtuplerQ   s    r9   ÚbundlezMatch.bundleÉ   s.   € à*.¯)ª)”U˜4Ÿ9™9Ó%Ð&ˆŒ	Øˆð :<ˆŒ	Øˆr<   c                ó<   — d| j                   › d| j                  › d�S )NzMatch(..., ú, ú)©r7   r8   rQ   s    r9   Ú__repr__zMatch.__repr__Î   s   € Ø˜TŸY™Y˜K r¨$¯+©+¨°aÐ8Ð8r<   c                ó¦   — | j                   }t        | j                  «      D ]-  }|j                  rŒ|j                  rŒ|j                  |«       Œ/ y r3   )r‡   Úreversedr}   Ú_erasedÚusersÚ
erase_node)r6   r‡   Úns      r9   Úerase_nodeszMatch.erase_nodesÑ   s>   € Ø—
‘
ˆÜ˜$Ÿ*™*Ó%ò 	$ˆAØ—9“9 Q§W£WØ× Ñ  Õ#ñ	$r<   c                óŠ   — | j                   j                  D �cg c]  }|�| j                   j                  |   nd ‘Œ! c}S c c}w r3   )r€   ÚoutputsÚpattern_to_node)r6   Úps     r9   Úoutput_nodeszMatch.output_nodes×   sF   € ð —X‘X×%Ñ%ö
àð -.¨MˆT�X‰X×%Ñ% aÒ(¸tÑCò
ð 	
ùò 
s   ™$A c                óB   — t        d„ | j                  «       D «       «      S )Nc              3  ó&   K  — | ]	  }|sŒ|–— Œ y ­wr3   r4   )r`   r    s     r9   rc   z$Match.output_node.<locals>.<genexpr>Þ   s   è ø€ Ò8˜!²a”AÑ8ùs   ‚Š)Únextr¡   rQ   s    r9   Úoutput_nodezMatch.output_nodeÝ   s   € ÜÑ8˜t×0Ñ0Ó2Ô8Ó8Ð8r<   c                ó\   — t         j                  | | j                  j                  ||«       y r3   )ÚReplacementPatternEntryÚreplace_with_graphr€   r‡   )r6   r�   r7   s      r9   r¨   zMatch.replace_with_graphà   s$   € ô 	 ×2Ñ2Ø�$—(‘(—.‘.Ð"3°Tõ	
r<   c                óX  — ddl m}m} t        |j                  |«      r|j                  €|j                  nt        j                  «       }|5  |€t        j                  t        |¬«      } ||t        j                  j                  |d„ «      «      }t        | j                  «      dk(  r@|j                  j                  D ]'  }	t!        |	j"                  | j                  d   d¬«       Œ) t$        j'                  | | j(                  j                  ||«       ddd«       y# 1 sw Y   yxY w)	a	  Replace with a graph generated by tracing the replacement_fn.

        Args:
            run_functional_passes (bool). If we should run passes that
                assume functional IR (like DCE, remove_noop_ops), on the
                replacement graph.

        r   )ÚNullHandlerÚVN)Úrun_functional_passesc                ó    — | j                   d   S ©NÚval©ro   )Úargs    r9   ú<lambda>z*Match.replace_by_example.<locals>.<lambda>  s   € À3Ç8Á8ÈEÁ?€ r<   r+   Úreplace_by_example©rq   rr   rs   )Útorch._inductor.virtualizedrª   r«   Ú
isinstanceÚ	fake_modeÚ
contextlibÚnullcontextÚ	functoolsÚpartialÚfwd_onlyr[   r\   Úmap_argÚlenr}   r‡   ru   ro   r§   r¨   r€   )
r6   Úreplacement_fnr7   Útrace_fnr¬   rª   r«   ÚcontextÚreplacementr›   s
             r9   r³   zMatch.replace_by_exampleç   s  € ÷ 	?ô ˜qŸ{™{¨KÔ8¸Q¿[¹[Ð=Pð �KŠKä×'Ñ'Ó)ð 	ð ñ 	ØÐÜ$×,Ñ,ÜÐ4Iô�ñ #Ø¤§¡× 0Ñ 0°Ñ7RÓ SóˆKô �4—:‘:‹ !Ò#Ø$×*Ñ*×0Ñ0ò �AÜ"Ø!"§¡Ø!%§¡¨A¡Ø"6öðô $×6Ñ6ØØ—‘—‘ØØô	÷!	÷ 	ñ 	ús   ÁC
D Ä D))NN)
r€   r   ry   rx   r7   zOptional[Sequence[Any]]r8   zOptional[dict[str, Any]]r>   rT   )r>   útorch.fx.Graph)rŒ   rw   r>   rT   )r>   rw   ©r>   r0   rS   )r>   zlist[Optional[torch.fx.Node]])r>   útorch.fx.Node)r�   rÃ   r7   úSequence[Any]r>   rT   ©NT)
r¿   rC   r7   rÆ   rÀ   zOptional[TraceFn]r¬   Úboolr>   rT   )r1   r?   r@   Ú__doc__rA   rR   Úpropertyr‡   r‹   r�   r•   rœ   r¡   r¥   r¨   r³   Ú__classcell__©r…   s   @r9   rw   rw   ”   sü   ø… ñ	ð ÓØ
ƒOØÓØÓØ4Ó4Ø	ÓØ5Ó5ð )-Ø+/ð&àð&ð ð&ð &ð	&ð
 )ð&ð 
õ&ð& òó ðó+óó
9ó$ó
ó9ð
Ø!/ð
Ø7Dð
à	ó
ð '+Ø&*ð,à!ð,ð ð,ð $ð	,ð
  $ð,ð 
÷,r<   rw   c                  ó4   — e Zd ZU dZded<   dd„Zd	d„Zd
d„Zy)rŠ   zƒ
    Represents a unsuccessful match.

    The `FailedMatch` object is returned to represent a failure to match a
    pattern.
    r0   Úformat_stringc                óf   — || _         t        |«      dkD  rt        d|› �«      ‚|| _        || _        y )NéÈ   zUFormat string too long - use lazy construction of strings instead. Format string is
 )rÎ   r¾   ÚRuntimeErrorr7   r8   )r6   rÎ   r7   r8   s       r9   rR   zFailedMatch.__init__   sB   € Ø*ˆÔô ˆ}Ó Ò#ÜØhÐivÐhwÐxóð ð ˆŒ	Øˆ�r<   c                ób   —  | j                   j                  | j                  i | j                  ¤ŽS r3   )rÎ   Úformatr7   r8   rQ   s    r9   Ú__str__zFailedMatch.__str__+  s(   € Ø(ˆt×!Ñ!×(Ñ(¨$¯)©)ÐC°t·{±{ÑCÐCr<   c                 ó   — y©NFr4   rQ   s    r9   Ú__bool__zFailedMatch.__bool__.  ó   € Ør<   N)rÎ   r0   r7   r   r8   r   r>   rT   rÄ   ©r>   rÈ   )r1   r?   r@   rÉ   rA   rR   rÔ   r×   r4   r<   r9   rŠ   rŠ     s   … ñð Óó	óDôr<   rŠ   c                ó   — t        | «      S )z|
    TypeIs cannot act on `self`. Thus this function exists to let mypy
    recognize FailedMatch.__bool__ as a TypeIs.
    )rÈ   )Úms    r9   Úis_matchrÜ   5  s   € ô
 �‹7€Nr<   c                  ód   — e Zd ZU dZded<   ded<   ded<   ded	<   	 d	 	 	 	 	 	 	 dd„Zdd„Zdd„Zy
)r   zC
    Internal state needed while running PatternExpr._match().
    úlist[Optional[PatternExpr]]rž   z*dict[PatternExpr, Optional[torch.fx.Node]]rŸ   rÃ   r‡   zlist[NodeOrConstant]Úexclusive_node_setNc               óV   — || _         |€i n
t        |«      | _        || _        g | _        y r3   )rž   ÚdictrŸ   r‡   rß   )r6   rž   rŸ   r‡   s       r9   rR   zMatchContext.__init__G  s.   € ð ˆŒØ%4Ð%<™rÄ$ÀÓBWˆÔØˆŒ
Ø"$ˆÕr<   c                óÞ   — || j                   v r)| j                   |   |k(  rt        | |«      S t        d«      S |j                  || «      }|| j                   vsJ ‚|r|nd| j                   |<   |S )z)wrapper to check reused nodes in patternszrepeated pattern differsN)rŸ   rw   rŠ   Ú_match)r6   ry   ÚnoderÛ   s       r9   ÚmatchzMatchContext.matchS  sy   € à�d×*Ñ*Ñ*Ø×#Ñ# GÑ,°Ò4Ü˜T 7Ó+Ð+ä"Ð#=Ó>Ð>Ø�N‰N˜4 Ó&ˆØ˜d×2Ñ2Ñ2Ð2Ð2Ù01©°tˆ×Ñ˜WÑ%Øˆr<   c                óŽ   — | j                   j                  «       D ��ci c]  \  }}|j                  «       r|�||“Œ c}}S c c}}w r3   )rŸ   rp   Úhas_multiple_users)r6   ry   rä   s      r9   Úfilter_multi_user_patternsz'MatchContext.filter_multi_user_patterns_  sL   € ð "&×!5Ñ!5×!;Ñ!;Ó!=÷
á�˜Ø×)Ñ)Ô+°Ð0@ð �T‰Mó
ð 	
ùó 
s   žAr3   )rž   rÞ   rŸ   z*Optional[dict[PatternExpr, torch.fx.Node]]r‡   rÃ   r>   rT   )ry   rx   rä   ÚNodeOrConstantr>   ÚMatchResult)r>   z dict[PatternExpr, torch.fx.Node])r1   r?   r@   rÉ   rA   rR   rå   rè   r4   r<   r9   r   r   =  s^   … ñð )Ó(Ø?Ó?ØÓØ,Ó,ð
 GKð
%à,ð
%ð Dð
%ð
 ð
%ð 
ó
%ó
ô
r<   r   c                  óV   — e Zd ZdZed	d„«       Zd
d„Zdd„Zdd„Z	 	 	 	 	 	 dd„Z	dd„Z
y)rx   z+
    Base class for types of patterns.
    c                 ó   — y r3   r4   ©r6   rä   r€   s      r9   rã   zPatternExpr._matchl  s   € ØMPr<   c                ó„   — 	 t        | g|j                  ¬«      j                  | |«      S # t        $ r}|cY d }~S d }~ww xY w©N©r‡   )r   r‡   rå   rŠ   ©r6   rä   Úes      r9   rå   zPatternExpr.matcho  s<   € ð	Ü  ¨d¯j©jÔ9×?Ñ?ÀÀdÓKÐKøÜò 	Ø�Hûð	ús   ‚'* ª	?³:´?º?c                 ó   — yrÖ   r4   rQ   s    r9   rç   zPatternExpr.has_multiple_usersu  rØ   r<   c                ó4   — | j                   j                  dz   S )Nz())r…   r1   rQ   s    r9   r•   zPatternExpr.__repr__x  s   € Ø�~‰~×&Ñ&¨Ñ-Ð-r<   c              #  óL   K  — | |j                   v r|j                   |    –— y y ­wr3   )rŸ   ©r6   r€   Úsearcheds      r9   Úfind_anchor_nodeszPatternExpr.find_anchor_nodes{  s,   è ø€ ð �3×&Ñ&Ñ&Ø×%Ñ% dÑ+Ó+ð 'ùs   ‚"$c                ó.   — t        || j                  «      S )zÀ
        Compare two `PatternExpr`s and return true if they are the
        same. Note this is NOT matching a pattern - it is comparing the pattern
        structures (for debugging).
        )r¶   r…   )r6   rŒ   s     r9   Ú
pattern_eqzPatternExpr.pattern_eq�  s   € ô ˜% §¡Ó0Ð0r<   N©rä   rÅ   r€   r   r>   rê   ©rä   rÅ   r>   rê   rÙ   rÄ   ©r€   r   r÷   úOrderedSet[torch.fx.Node]r>   z.Generator[Optional[torch.fx.Node], None, None]©rŒ   r   r>   rÈ   )r1   r?   r@   rÉ   r   rã   rå   rç   r•   rø   rú   r4   r<   r9   rx   rx   g  sH   „ ñð ÚPó ØPóóó.ð,Øð,Ø+Dð,à	7ó,ô1r<   rx   c                  ó   — e Zd ZdZdd„Zy)ÚArgzn
    Capture an arg which will become an input to the handler.  Args are
    passed in depth first order.
    c                ó    — t        || |g¬«      S )N)r7   ©rw   rí   s      r9   rã   z
Arg._match�  s   € Ü�S˜$ d VÔ,Ð,r<   N©rä   ré   r€   r   r>   rê   ©r1   r?   r@   rÉ   rã   r4   r<   r9   r  r  Š  s   „ ñô
-r<   r  c                  ó(   — e Zd ZdZdd„Zdd„Zdd„Zy)	ÚIgnoredz4
    Match an arg, but don't pass it to handler
    c                ó   — t        || «      S r3   r  rí   s      r9   rã   zIgnored._match™  s   € Ü�S˜$ÓÐr<   c                 ó   — y)NÚ*r4   rQ   s    r9   r•   zIgnored.__repr__œ  s   € Ør<   c                 ó   — y)Nz	Ignored()r4   )r6   Úpps     r9   Úpretty_printzIgnored.pretty_printŸ  s   € Ør<   Nr  rÄ   ©r  ÚPatternPrettyPrinterr>   r0   )r1   r?   r@   rÉ   rã   r•   r  r4   r<   r9   r  r  ”  s   „ ñó óôr<   r  c                  ó@   ‡ — e Zd ZdZdˆ fd„Zdd„Zdd„Zd	ˆ fd„Zˆ xZS )
Ú
KeywordArgúD
    Capture a kwarg which will become an input to the handler.
    c                ó0   •— t         ‰| �  «        || _        y r3   ©rƒ   rR   Úname©r6   r  r…   s     €r9   rR   zKeywordArg.__init__¨  ó   ø€ Ü‰ÑÔØˆ�	r<   c                ó"   — d| j                   ›d�S )NzKeywordArg(r“   ©r  rQ   s    r9   r•   zKeywordArg.__repr__¬  s   € Ø˜TŸY™Y˜M¨Ð+Ð+r<   c                ó6   — t        || | j                  |i¬«      S )N©r8   )rw   r  rí   s      r9   rã   zKeywordArg._match¯  s   € Ü�S˜$¨¯	©	°4Ð'8Ô9Ð9r<   c                óŒ   •— t        j                  t        |«      }t        ‰| �  |«      xr | j
                  |j
                  k(  S r3   ©ÚtypingÚcastr   rƒ   rú   r  ©r6   rŒ   r…   s     €r9   rú   zKeywordArg.pattern_eq²  ó5   ø€ Ü—‘œD %Ó(ˆÜ‰wÑ! %Ó(ÒD¨T¯Y©Y¸%¿*¹*Ñ-DÐDr<   ©r  r0   r>   rT   rÄ   r  rÿ   ©	r1   r?   r@   rÉ   rR   r•   rã   rú   rË   rÌ   s   @r9   r  r  £  s#   ø„ ñõó,ó:÷Eñ Er<   r  c                  óL   ‡ — e Zd ZU dZded<   dˆ fd„Zd	d„Zd
d„Zdˆ fd„Zˆ xZ	S )ÚExclusiveKeywordArgr  r0   r  c                ó0   •— t         ‰| �  «        || _        y r3   r  r  s     €r9   rR   zExclusiveKeywordArg.__init__¾  r  r<   c                ó"   — d| j                   ›d�S )NzExclusiveKeywordArg(r“   r  rQ   s    r9   r•   zExclusiveKeywordArg.__repr__Â  s   € Ø% d§i¡i ]°!Ð4Ð4r<   c                óž   — ||j                   v rt        d«      S |j                   j                  |«       t        || | j                  |i¬«      S )Nzexclusive arg appears twicer  )rß   rŠ   rl   rw   r  rí   s      r9   rã   zExclusiveKeywordArg._matchÅ  sH   € Ø�3×)Ñ)Ñ)ÜÐ<Ó=Ð=à×Ñ×%Ñ% dÔ+Ü�S˜$¨¯	©	°4Ð'8Ô9Ð9r<   c                óŒ   •— t        j                  t        |«      }t        ‰| �  |«      xr | j
                  |j
                  k(  S r3   r  r   s     €r9   rú   zExclusiveKeywordArg.pattern_eqÌ  r!  r<   r"  rÄ   r  rÿ   )
r1   r?   r@   rÉ   rA   rR   r•   rã   rú   rË   rÌ   s   @r9   r%  r%  ·  s*   ø… ñð ƒIõó5ó:÷Eñ Er<   r%  c                  ó¬   ‡ — e Zd ZU dZded<   ded<   	 d	 	 	 	 	 dˆ fd„Zeedd„«       «       Zdd„Z	dd	„Z
dd
„Z	 	 	 	 	 	 dd„Zdd„Zdd„Zdˆ fd„Zˆ xZS )Ú_TargetExprz7
    Base class for filtering match by node.target
    zlist[FnsType]ÚfnszOrderedSet[FnsType]Úfns_setc                óZ  •‡— t         ‰| �  «        t        |«      st        |t        «      r|gn
t        |«      }|D ]O  Št        ‰t        j                  j                  «      sŒ(|j                  ˆfd„‰j                  «       D «       «       ŒQ || _        t        |«      | _        || _        y )Nc              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wr3   )Úgetattr)r`   ÚoverloadrI   s     €r9   rc   z'_TargetExpr.__init__.<locals>.<genexpr>à  s   øè ø€ ÒP°Xœ7 2 x×0ÑPùs   ƒ)rƒ   rR   Úcallabler¶   r0   r„   r[   Ú_opsÚOpOverloadPacketr‹   Ú	overloadsr,  r!   r-  r™   )r6   r,  r™   rI   r…   s      @€r9   rR   z_TargetExpr.__init__Ù  s„   ù€ ô 	‰ÑÔÜ ”}¬
°3¼Ô(<ˆs‰eÄ$ÀsÃ)ˆØò 	QˆBÜ˜"œeŸj™j×9Ñ9Õ:Ø—
‘
ÓPÀÇÁÃÔPÕPð	Qð ˆŒÜ! #“ˆŒØˆ�
r<   c                 ó   — y r3   r4   rQ   s    r9   Úopz_TargetExpr.opæ  s   € àr<   c                ó¾  — | j                   d   }t        |t        «      s|j                  }t	        | j                   «      dkD  rd|› d�S | j                   d   t        t        |d «      u rd|› �S | j                   d   t        t        |d «      u rd|› �S t        | j                   d   t        j                  j                  «      rt        | j                   d   «      S |S )Nr   r+   ú[z, ...]útorch.z	operator.)
r,  r¶   r0   r1   r¾   r0  r[   Úoperatorr3  Ú
OpOverload)r6   Ú
first_reprs     r9   Úfns_reprz_TargetExpr.fns_reprê  sÄ   € Ø—X‘X˜a‘[ˆ
Ü˜*¤cÔ*Ø#×,Ñ,ˆJäˆt�x‰x‹=˜1ÒØ�z�l &Ð)Ð)Ø�X‰X�a‰[œG¤E¨:°tÓ<Ñ<Ø˜J˜<Ð(Ð(Ø�X‰X�a‰[œG¤H¨j¸$Ó?Ñ?Ø˜z˜lÐ+Ð+Ü˜Ÿ™ ™¤U§Z¡Z×%:Ñ%:Ô;Ü�t—x‘x ‘{Ó#Ð#àÐr<   c                óÈ   — | j                   t        u rd}n"| j                   dk7  rd| j                   › d�}nd}| j                  j                  › d| j	                  «       › |› d�S )Nz
, MULTIPLEr+   r’   r“   Ú ú()r™   rO   r…   r1   r>  )r6   Úcomma_userss     r9   r•   z_TargetExpr.__repr__ú  s^   € Ø�:‰:œÑ!Ø&‰KØ�Z‰Z˜1Š_Ø˜tŸz™z˜l¨!Ð,‰KàˆKØ—.‘.×)Ñ)Ð*¨!¨D¯M©M«OÐ+<¸[¸MÈÐKÐKr<   c                óX   — t        | j                  t        «      xs | j                  dkD  S )Nr+   )r¶   r™   rM   rQ   s    r9   rç   z_TargetExpr.has_multiple_users  s    € Ü˜$Ÿ*™*¤hÓ/ÒA°4·:±:À±>ÐAr<   c                ó   — t         ‚r3   ©ÚNotImplementedErrorrö   s      r9   rø   z_TargetExpr.find_anchor_nodes  s
   € ô "Ð!r<   c                ó²   — t        |t        j                  j                  «      xr2 |j                  | j                  k(  xr t        |«      | j                  v S r3   )r¶   r[   r\   ÚNoder7  Úextract_targetr-  )r6   rä   s     r9   Ú
_match_fnsz_TargetExpr._match_fns  sD   € ä�tœUŸX™XŸ]™]Ó+ò 5Ø—‘˜4Ÿ7™7Ñ"ò5ä˜tÓ$¨¯©Ð4ð	
r<   c                óŽ   — | |j                   v xs6 | j                  t        u xs" t        |j                  «      | j                  k(  S r3   )rž   r™   rO   r¾   rí   s      r9   Ú_match_usersz_TargetExpr._match_users  s=   € à�C—K‘KÐò -Ø�z‰zœXÐ%ò-ä�4—:‘:‹ $§*¡*Ñ,ð	
r<   c                óø   •— t        j                  t        |«      }t        ‰| �  |«      xrO | j
                  |j
                  k(  xr4 | j                  |j                  k(  xr | j                  |j                  k(  S r3   )r  r  r   rƒ   rú   r7  r,  r™   r   s     €r9   rú   z_TargetExpr.pattern_eq  sf   ø€ Ü—‘œD %Ó(ˆä‰GÑ˜uÓ%ò *Ø—‘˜5Ÿ8™8Ñ#ò*à—‘˜EŸI™IÑ%ò*ð —
‘
˜eŸk™kÑ)ð		
r<   )r+   )r,  z!Union[FnsType, Sequence[FnsType]]r™   zUnion[Multiple, int]r>   rT   rÄ   rÙ   rý   ©rä   rÅ   r>   rÈ   )rä   rÅ   r€   r   r>   rÈ   rÿ   )r1   r?   r@   rÉ   rA   rR   rÊ   r   r7  r>  r•   rç   rø   rJ  rL  rú   rË   rÌ   s   @r9   r+  r+  Ñ  s”   ø… ñð 
ÓØ Ó ð UVðØ4ðØ=Qðà	õð ØÚó ó àóó LóBð"Øð"Ø+Dð"à	7ó"ó

ó
÷
ñ 
r<   r+  .c                  ó°   ‡ — e Zd ZdZddœ	 	 	 	 	 	 	 	 	 dˆ fd„Ze	 	 	 	 	 	 dd„«       Ze	 	 	 	 	 	 dd„«       Zdd„Zdd„Z	dd	„Z
	 	 	 	 	 	 dd
„Zdˆ fd„Zˆ xZS )Ú_TargetArgsExprzE
    Base class for filtering match by node.{target,args,kwargs}
    r+   )Ú_usersc               ój  •— t         ‰| �  ||«       t        |«      | _        t	        |«      | _        t        d„ t        j                  ||j                  «       «      D «       «      r| j                  | _        n| j                  | _        | j                  | j                  | j
                  «      | _        y )Nc              3  óR   K  — | ]  }t        |t        t        t        f«      –— Œ! y ­wr3   )r¶   rá   r„   r�   ©r`   Úxs     r9   rc   z+_TargetArgsExpr.__init__.<locals>.<genexpr>5  s&   è ø€ ò 
àô �qœ4¤¤uÐ-×.ñ
ùs   ‚%')rƒ   rR   r�   r7   rá   r8   ÚanyÚ	itertoolsÚchainÚvaluesÚpytree_flattenÚflattenÚsimple_flattenÚflat_args_kwargs)r6   r,  rQ  r7   r8   r…   s        €r9   rR   z_TargetArgsExpr.__init__+  s‡   ø€ ô 	‰Ñ˜˜fÔ%Ü˜$“KˆŒ	Ü˜6“lˆŒÜñ 
ä—_‘_ T¨6¯=©=«?Ó;ô
ô 
ð  ×.Ñ.ˆD�Là×.Ñ.ˆDŒLØ $§¡¨T¯Y©Y¸¿¹Ó DˆÕr<   c                ón   — g | ¢|j                  «       ¢­}t        | «      g|j                  «       ¢­}||fS r3   )rY  r¾   r‰   )r7   r8   rY  Úspecs       r9   r\  z_TargetArgsExpr.simple_flatten>  s:   € ð +�4Ð*˜&Ÿ-™-›/Ñ*ˆÜ�D“	Ð*˜FŸK™K›MÑ*ˆØ�tˆ|Ðr<   c                óÆ   ‡‡— t         t        t        t        t        t        iŠdˆˆfd„Št        j                  ‰| |fˆfd„¬«      }t        j                  |«      \  }}||fS )Nc                ó†   •— t        | «      }‰j                  |«      }|�!t        j                  ‰ || «      ˆfd„¬«      S | S )Nc                ó   •— t        | «      ‰v S r3   ©Útype©rU  Útype_mappings    €r9   r²   zF_TargetArgsExpr.pytree_flatten.<locals>.convert_type.<locals>.<lambda>W  s   ø€ ¤d¨1£g°Ð&=€ r<   ©Úis_leaf)rd  rj   ÚpytreeÚtree_map)rU  ÚclsÚ
convert_fnÚconvert_typerf  s      €€r9   rm  z4_TargetArgsExpr.pytree_flatten.<locals>.convert_typeP  sG   ø€ Ü�q“'ˆCØ%×)Ñ)¨#Ó.ˆJØÐ%Ü—‘Ø Ù˜q“MÛ=ôð ð
 ˆHr<   c                ó   •— t        | «      ‰v S r3   rc  re  s    €r9   r²   z0_TargetArgsExpr.pytree_flatten.<locals>.<lambda>^  s   ø€ œd 1›g¨Ð5€ r<   rg  )rU  r   r>   r   )r   r�   r„   r   rá   ri  rj  Útree_flatten)r7   r8   Únormalized_args_treeÚflatr_  rm  rf  s        @@r9   rZ  z_TargetArgsExpr.pytree_flattenF  s_   ù€ ô
 œEÜ”%ÜœDð*
ˆö		ô  &Ÿ™ØØ�6ˆNÛ5ô 
Ðô
 ×(Ñ(Ð)=Ó>‰
ˆˆdØ�TˆzÐr<   c                óÀ  — | j                  «       gt        t        | j                  «      ¢| j                  j                  «       D ��cg c]  \  }}|› d|› �‘Œ c}}¢}| j                  t        u r|j                  d«       n-| j                  dk7  r|j                  d| j                  › �«       | j                  j                  › ddj                  |«      › d�S c c}}w )Nú=ú_users=MULTIPLEr+   ú_users=rA  r’   r“   )r>  ÚmapÚreprr7   r8   rp   r™   rO   rl   r…   r1   Újoin)r6   ra   rb   r7   s       r9   r•   z_TargetArgsExpr.__repr__c  s¾   € à�M‰M‹Oð
ä”�t—y‘yÓ!ð
ð &*§[¡[×%6Ñ%6Ó%8×9™T˜Q ���1�Q�CŠjÓ9ð
ˆð
 �:‰:œÑ!Ø�K‰KÐ)Õ*Ø�Z‰Z˜1Š_Ø�K‰K˜' $§*¡* Ð.Ô/Ø—.‘.×)Ñ)Ð*¨!¨D¯I©I°d«OÐ+<¸AÐ>Ð>ùó :s   ÁCc           
     óÚ  ‡— | j                  «       gˆfd„| j                  D «       ¢| j                  j                  «       D ��cg c]  \  }}|› d‰j	                  |«      › �‘Œ c}}¢}| j
                  t        u r|j                  d«       n-| j
                  dk7  r|j                  d| j
                  › �«       d}| j                  j                  › d|j                  |«      › d�S c c}}w )	Nc              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr3   )r  )r`   rU  r  s     €r9   rc   z/_TargetArgsExpr.pretty_print.<locals>.<genexpr>r  s   øè ø€ Ò4 Qˆb�o‰o˜a× Ñ4ùs   ƒrs  rt  r+   ru  r’   rA  r“   )r>  r7   r8   rp   r  r™   rO   rl   r…   r1   rx  )r6   r  ra   rb   r7   Ú
joiner_strs    `    r9   r  z_TargetArgsExpr.pretty_printo  sÏ   ø€ à�M‰M‹Oð
ã4¨$¯)©)Ô4ð
ð 7;·k±k×6GÑ6GÓ6I×J©d¨a°���1�R—_‘_ QÓ'Ð(Ò)ÓJð
ˆð
 �:‰:œÑ!Ø�K‰KÐ)Õ*Ø�Z‰Z˜1Š_Ø�K‰K˜' $§*¡* Ð.Ô/àˆ
Ø—.‘.×)Ñ)Ð*¨!¨J¯O©O¸DÓ,AÐ+BÀ!ÐDÐDùó Ks   Á C'c                ó˜  — | j                  |«      r+t        |j                  «      t        | j                  «      k7  rt        d|| «      S | j	                  ||«      st        d| «      S |j                  }|j
                  }t        |«      t        | j
                  «      k  rËddlm} t        |j                  «      sJ ‚ ||j                  |j                  |j
                  «      }|€t        d|| «      S |\  }}t        |«      t        | j                  «      k(  rDt        |«      t        | j
                  «      k\  r#|D �ci c]  }|| j
                  v sŒ|||   “Œ }}n/t        d|| «      S |D �ci c]  }|| j
                  v sŒ|||   “Œ }}| j                  ||«      \  }}	| j                  \  }
}|	|k7  rt        d|	|«      S t        |«      t        |
«      k(  sJ ‚t        || «      }t        t        j                  «       |
|«      D ]�  \  }}}t!        |t"        «      r3|j%                  ||«      }t'        |«      s|c S |j)                  |«       ŒJt!        |t*        j,                  j.                  «      s||k7  sŒtt        d||«      c S  |j0                  j3                  |«       |j                  |j4                  | <   |S c c}w c c}w )Nz&function_mismatch: node={}, pattern={}zmultiple_users {}r   )Únormalize_functionzargs_structure {} {}z#constant_args: {} {!r}!={pattern!r})rJ  r¾   r7   rŠ   rL  r8   Útorch.fx.operator_schemasr}  r2  Útargetr[  r]  rw   ÚziprW  Úcountr¶   rx   rå   rÜ   r‹   r[   r\   rH  r}   rl   r~   )r6   rä   r€   Ú_argsÚ_kwargsr}  Únormalized_args_and_kwargsÚiÚ
node_itemsÚ	node_specÚ
self_itemsÚ	self_specrÛ   ry   Ú
child_nodeÚchild_matchs                   r9   rã   z_TargetArgsExpr._match}  ss  € Ø�‰˜tÔ$¬¨D¯I©I«¼#¸d¿i¹i».Ò(HÜÐGÈÈtÓTÐTà× Ñ   sÔ+ÜÐ2°DÓ9Ð9à—	‘	ˆØ—+‘+ˆÜˆw‹<œ#˜dŸk™kÓ*Ò*ÝDä˜DŸK™KÔ(Ð(Ð(Ù);Ø—‘˜TŸY™Y¨¯©ó*Ð&ð *Ð1Ü"Ð#KÈTÐSWÓXÐXà!;‘��wÜ�u“:¤ T§Y¡Y£Ò/´C¸³LÄCÈÏÉÓDTÒ4TØ6=ÖR°ÀÀdÇkÁkÒAQ˜q '¨!¡*™}ÐR�GÑRä&Ø@À$Èóð ð /6ÖJ¨¸¸d¿k¹kÒ9I�q˜' !™*‘}ÐJˆGÐJà $§¡¨U°GÓ <Ñˆ
�IØ $× 5Ñ 5Ñˆ
�IØ˜	Ò!ÜÐ5°yÀ)ÓLÐLÜ�:‹¤# j£/Ò1Ð1Ð1ä�#�tÓˆÜ&)¬)¯/©/Ó*;¸ZÈÓ&Tò 		Ñ"ˆAˆw˜
Ü˜'¤;Ô/Ø!Ÿi™i¨°Ó<�Ü Ô,Ø&Ò&Ø—‘˜Õ%Ü˜J¬¯©¯©Ô6¸*ÈÓ:OÜ"Ø9¸4Àóò ð		ð 	
�‰�‰�tÔØŸ+™+ˆ�	‰	�$‰Øˆùò7 Sùò Ks   Å KÅKÅ0KÆKc              #  óˆ  K  — | |j                   v r|j                   |    –— y| j                  d   D ]Œ  }t        |t        «      sŒ|j	                  ||«      D ]d  }t        |t
        j                  j                  «      sŒ(|j                  D ].  }||vsŒ| j                  |«      sŒ|–— |j                  |«       Œ0 Œf ŒŽ y­w)a  
        This is used when we are matching a pattern with multiple outputs.
        There is a partial match (stored in ctx) and we want to walk
        this pattern to find a connection to an already-matched node.

        Yields candidate nodes that `self._match` might like.
        Nr   )rŸ   r]  r¶   rx   rø   r[   r\   rH  r™   rJ  Úadd)r6   r€   r÷   ry   Ú
other_noderä   s         r9   rø   z!_TargetArgsExpr.find_anchor_nodes°  s¹   è ø€ ð �3×&Ñ&Ñ&Ø×%Ñ% dÑ+Ò+Øà×,Ñ,¨QÑ/ò 		3ˆGÜ˜'¤;Õ/Ø")×";Ñ";¸CÀÓ"Jò 3�JÜ% j´%·(±(·-±-Ô@Ø Ø *× 0Ñ 0ò 3˜Ø xÒ/Ø#Ÿ™¨tÕ4Ø&*¢
Ø (§¡¨TÕ 2ñ	3ñ3ñ		3ùs   ‚ACÁACÂCÂ&Cc                ó  •— t        j                  t        |«      }t        ‰| �  |«      xrW | j
                  d   |j
                  d   k(  xr6 t        d„ t        | j
                  d   |j
                  d   «      D «       «      S )Nr+   c              3  ón   K  — | ]-  \  }}t        |t        «      r|j                  |«      n||k(  –— Œ/ y ­wr3   ©r¶   rx   rú   ©r`   ÚaÚbs      r9   rc   z-_TargetArgsExpr.pattern_eq.<locals>.<genexpr>Î  ó6   è ø€ ò á�A�qô $.¨a´Ô#=�—‘˜Q”À1ÈÁ6ÓIñùó   ‚35r   )r  r  r   rƒ   rú   r]  Úallr€  r   s     €r9   rú   z_TargetArgsExpr.pattern_eqÉ  s€   ø€ Ü—‘œD %Ó(ˆä‰GÑ˜uÓ%ò Ø×%Ñ% aÑ(¨E×,BÑ,BÀ1Ñ,EÑEòäñ ä × 5Ñ 5°aÑ 8¸%×:PÑ:PÐQRÑ:SÓTôó ð	
r<   )
r,  z/Union[torch.fx.node.Target, str, Sequence[Any]]r7   r   rQ  zUnion[int, Multiple]r8   r   r>   rT   )r7   rÆ   r8   zMapping[Any, Any]r>   z9tuple[Sequence[Any], Union[_SimpleSpec, pytree.TreeSpec]]rÄ   r  rû   rý   rÿ   )r1   r?   r@   rÉ   rR   Ústaticmethodr\  rZ  r•   r  rã   rø   rú   rË   rÌ   s   @r9   rP  rP  &  sØ   ø„ ñð ()ñ	Eà<ðEð ðEð %ð	Eð
 ðEð 
õEð& ðØðØ%6ðà	Bòó ðð ðØðØ%6ðà	Bòó ðó8
?óEó1ðf3Øð3Ø+Dð3à	7ó3÷2	
ñ 	
r<   rP  c                  ó   — e Zd ZdZdZy)ÚCallFunctionzR
    Matches a call_function node in the FX graphs: `fns[i](*args, **kwargs)`
    Úcall_functionN©r1   r?   r@   rÉ   r7  r4   r<   r9   rš  rš  Õ  s   „ ñð 
�Br<   rš  c                  ó   — e Zd ZdZdZy)Ú
CallMethodzW
    Matches a call_method node in the FX graphs: `fns[i].method(*args, **kwargs)`
    Úcall_methodNrœ  r4   r<   r9   rž  rž  Ý  ó   „ ñð 
�Br<   rž  c                  ó   — e Zd ZdZdZy)Ú
CallModulezP
    Matches a call_module node in the FX graphs: `module(*args, **kwargs)`
    Úcall_moduleNrœ  r4   r<   r9   r¢  r¢  å  r   r<   r¢  c                  ó   — e Zd ZdZdd„Zy)Ú_TargetExprVarArgsz[
    Matches a call_function node with any arguments which are passed into the pattern
    c                óŒ  — | j                  |«      st        d«      S | j                  ||«      st        d«      S t        || «      }|j                  j                  |«       |j                  |j                  | <   |j                  j                  |j                  «       |j                  j                  |j                  «       |S )NÚfunction_mismatchÚmultiple_users)rJ  rŠ   rL  rw   r}   rl   r  r~   r7   r‹   r8   rn   )r6   rä   r€   rÛ   s       r9   rã   z_TargetExprVarArgs._matchò  s�   € Ø�‰˜tÔ$ÜÐ2Ó3Ð3à× Ñ   sÔ+ÜÐ/Ó0Ð0ä�#�tÓˆØ	�‰�‰�tÔØŸ+™+ˆ�	‰	�$‰Ø	�‰�‰�d—i‘iÔ Ø	�‰�‰˜Ÿ™Ô$Øˆr<   Nrû   r  r4   r<   r9   r¥  r¥  í  s   „ ñôr<   r¥  c                  ó   — e Zd ZdZy)ÚCallFunctionVarArgsr›  N©r1   r?   r@   r7  r4   r<   r9   rª  rª    s   „ Ø	�Br<   rª  c                  ó   — e Zd ZdZy)ÚCallMethodVarArgsrŸ  Nr«  r4   r<   r9   r­  r­    ó   „ Ø	�Br<   r­  c                  ó   — e Zd ZdZy)ÚCallModuleVarArgsr£  Nr«  r4   r<   r9   r°  r°  	  r®  r<   r°  c                  óB   ‡ — e Zd ZdZddˆ fd„Zdd„Zd	d„Zd
ˆ fd„Zˆ xZS )ÚListOfz$
    Matches a repeated pattern
    c                ób   •— t         ‰| �  «        t        |t        «      sJ ‚|| _        || _        y r3   )rƒ   rR   r¶   rx   ry   r»   )r6   ry   r»   r…   s      €r9   rR   zListOf.__init__  s,   ø€ Ü‰ÑÔÜ˜'¤;Ô/Ð/Ð/ØˆŒØˆ�r<   c                óN   — | j                   j                  › d| j                  › d�S ©NrA  r“   )r…   r1   ry   rQ   s    r9   r•   zListOf.__repr__  ó$   € Ø—.‘.×)Ñ)Ð*¨!¨D¯L©L¨>¸Ð;Ð;r<   c                ó(  — t        |t        t        f«      rt        |«      dk(  rt	        d«      S t        || «      }|j                  «       }d}t        |«      D ]›  \  }}t        |j                  ||j                  ¬«      }|j                  | j                  |«      }	|j                  «       }t        |	«      s| j                  st	        d||	«      c S Œ{d}|j                  |	j!                  «       «       Œ� |st	        d«      S |j!                  «       S )Nr   Únon_listFrð   zlist[{}]: {}Tzlist: no_match)r¶   r„   r�   r¾   rŠ   rw   rè   Ú	enumerater   rž   r‡   rå   ry   rÜ   r»   r‹   r�   )
r6   rä   r€   rÛ   rŸ   Úmatchedr…  rŠ  Ú	child_ctxr‹  s
             r9   rã   zListOf._match  sô   € Ü˜$¤¤u Ô.´#°d³)¸q².Ü˜zÓ*Ð*Ü�#�tÓˆð ×8Ñ8Ó:ˆØˆÜ& t›_ò 	+‰MˆAˆzÜ$Ø—‘˜_°J×4DÑ4DôˆIð $Ÿ/™/¨$¯,©,¸
ÓCˆKØ'×BÑBÓDˆOÜ˜KÔ(Ø—|’|Ü& ~°q¸+ÓFÒFØØˆGØ�H‰H�[×'Ñ'Ó)Õ*ð	+ñ ÜÐ/Ó0Ð0Ø�x‰x‹zÐr<   c                óÚ   •— t        j                  t        |«      }t        ‰| �  |«      xr@ | j
                  j	                  |j
                  «      xr | j                  |j                  k(  S r3   )r  r  r   rƒ   rú   ry   r»   r   s     €r9   rú   zListOf.pattern_eq3  sU   ø€ Ü—‘œD %Ó(ˆä‰GÑ˜uÓ%ò .Ø—‘×'Ñ'¨¯©Ó6ò.à—‘ §¡Ñ-ð	
r<   ©F)ry   rx   r»   rÈ   r>   rT   rÄ   )rä   r|   r€   r   r>   rê   rÿ   r#  rÌ   s   @r9   r²  r²    s!   ø„ ñöó<ó÷0
ñ 
r<   r²  c                  ó~   ‡ — e Zd ZU ded<   dˆ fd„Zedd„«       Zdd„Zdd„Zdd„Z		 	 	 	 	 	 dd„Z
dd	„Zdˆ fd
„Zˆ xZS )ÚMultiOutputPatternrÞ   rž   c                óÆ   •— t         ‰| �  «        t        |d   t        «      sJ ‚t	        d„ |D «       «      sJ |«       ‚t        |«      | _        |d   j                  | _        y )Nr   c              3  óH   K  — | ]  }|d u xs t        |t        «      –— Œ y ­wr3   )r¶   rx   rT  s     r9   rc   z.MultiOutputPattern.__init__.<locals>.<genexpr>B  s#   è ø€ ÒL¸q�1˜�9Ò:¤
¨1¬kÓ :Ó:ÑLùs   ‚ ")rƒ   rR   r¶   r+  r—  r„   rž   r7  )r6   rž   r…   s     €r9   rR   zMultiOutputPattern.__init__?  sU   ø€ Ü‰ÑÔÜ˜' !™*¤kÔ2Ð2Ð2ÜÑLÀGÔLÔLÐUÈgÓUÐLÜ˜G“}ˆŒØ˜!‘*—-‘-ˆ�r<   c                óh   — t        j                  t        | j                  d   «      }|j                  S ©Nr   )r  r  r+  rž   r,  )r6   Úoutputs     r9   r,  zMultiOutputPattern.fnsF  s&   € ô —‘œ[¨$¯,©,°q©/Ó:ˆØ�z‰zÐr<   c                óN   — | j                   j                  › d| j                  › d�S rµ  )r…   r1   rž   rQ   s    r9   r•   zMultiOutputPattern.__repr__L  r¶  r<   c                óÈ   — | j                   D �cg c]  }|j                  |«      ‘Œ }}dd› �}| j                  j                  › d|j	                  |«      › �}|› d�}|S c c}w )Nz,
z  z([z
]))rž   r  r…   r1   rx  )r6   r  rU  r7   r{  Ústr_outs         r9   r  zMultiOutputPattern.pretty_printO  sh   € Ø,0¯L©LÖ9 q�—‘ Õ"Ð9ˆÐ9Ø˜4˜&�\ˆ
Ø—^‘^×,Ñ,Ð-¨R°
·±ÀÓ0EÐ/FÐGˆØ�I˜TÐ"ˆØˆùò	 :s   �Ac                ó$  — t        j                  t        | j                  d   «      }|j	                  ||«      }t        |«      s|S | j                  dd  D ]7  }|€Œ| j                  ||«      }t        |«      s|c S |j                  |«       Œ9 |S )Nr   r+   )r  r  r+  rž   rå   rÜ   Ú_match_from_anchorsr‹   )r6   rä   r€   rÄ  rÛ   ry   r‹  s          r9   rã   zMultiOutputPattern._matchV  s‹   € Ü—‘œ[¨$¯,©,°q©/Ó:ˆØ�I‰I�f˜dÓ#ˆÜ˜Œ{ØˆHà—|‘| A BÐ'ò 	"ˆGØˆØØ×2Ñ2°7¸CÓ@ˆKÜ˜KÔ(Ø"Ò"Ø�H‰H�[Õ!ð	"ð ˆr<   c                óæ   — t        |j                  «      }t        d«      }|j                  |t	        «       «      D ]3  }|j                  ||«      }t        |«      r|c S t        |«      |_        Œ5 |S )Nzno anchor found)rá   rŸ   rŠ   rø   r!   rå   rÜ   )r6   ry   r€   ÚpriorrÛ   rä   s         r9   rÉ  z&MultiOutputPattern._match_from_anchorsf  sl   € ô �S×(Ñ(Ó)ˆÜ$Ð%6Ó7ˆØ×-Ñ-¨c´:³<Ó@ò 	.ˆDØ—	‘	˜' 4Ó(ˆAÜ˜Œ{Ø’ä"& u£+ˆCÕð	.ð ˆr<   c                ó–   — 	 t        | j                  |j                  ¬«      j                  | |«      S # t        $ r}|cY d }~S d }~ww xY wrï   )r   rž   r‡   rå   rŠ   rñ   s      r9   rå   zMultiOutputPattern.matchs  s>   € ð	Ü §¡°D·J±JÔ?×EÑEÀdÈDÓQÐQøÜò 	Ø�Hûð	ús   ‚03 ³	A¼A½AÁAc                ó  •— t        j                  t        |«      }t        ‰| �  |«      xr] t        | j                  «      t        |j                  «      k(  xr0 t        d„ t        | j                  |j                  «      D «       «      S )Nc              3  ón   K  — | ]-  \  }}t        |t        «      r|j                  |«      n||k(  –— Œ/ y ­wr3   r‘  r’  s      r9   rc   z0MultiOutputPattern.pattern_eq.<locals>.<genexpr>~  r•  r–  )	r  r  r   rƒ   rú   r¾   rž   r—  r€  r   s     €r9   rú   zMultiOutputPattern.pattern_eqy  sm   ø€ Ü—‘œD %Ó(ˆä‰GÑ˜uÓ%ò Ü�D—L‘LÓ!¤S¨¯©Ó%7Ñ7òäñ ä §¡¨e¯m©mÓ<ôó ð	
r<   )rž   zSequence[Optional[PatternExpr]]r>   rT   )r>   z-Union[Callable[..., Any], str, Sequence[Any]]rÄ   r  rû   )ry   rx   r€   r   r>   rê   rü   rÿ   )r1   r?   r@   rA   rR   rÊ   r,  r•   r  rã   rÉ  rå   rú   rË   rÌ   s   @r9   r¿  r¿  <  s]   ø… Ø(Ó(õ ð òó ðó
<óóð Ø"ðØ)5ðà	óó÷	
ñ 	
r<   r¿  c                  óJ   ‡ — e Zd ZdZdˆ fd„Zedd„«       Zdd„Zd	ˆ fd„Zˆ xZ	S )
ÚRepeatedExprzp
    Checks for a repeated pattern. Useful for repeated operations after a node such as `split` or `unbind`
    c                óR   •— t         ‰| �  «        || _        |j                  | _        y r3   )rƒ   rR   Úinner_patternr7  )r6   rÒ  r…   s     €r9   rR   zRepeatedExpr.__init__Š  s#   ø€ Ü‰ÑÔØ*ˆÔØ×"Ñ"ˆ�r<   c                ó.   — | j                   j                  S r3   )rÒ  r,  rQ   s    r9   r,  zRepeatedExpr.fns�  s   € à×!Ñ!×%Ñ%Ð%r<   c                ó˜  — |j                  | j                  |«      }t        |«      s|S |j                  j	                  | j                  «       | j                  j                  |t        «       «      D ]T  }t        | g|j                  ¬«      j                  | j                  |«      }t        |«      s|c S |j                  |«       ŒV |S rï   )
rå   rÒ  rÜ   rŸ   Úpoprø   r!   r   r‡   r‹   )r6   rä   r€   rÛ   Úanchor_nodeÚanchor_ms         r9   rã   zRepeatedExpr._match“  s±   € Ø�I‰I�d×(Ñ(¨$Ó/ˆÜ˜Œ{ØˆHØ×Ñ×ÑØ×Ñô	
ð  ×-Ñ-×?Ñ?ÀÄZÃ\ÓRò 	ˆKÜ# T F°$·*±*Ô=×CÑCØ×"Ñ" KóˆHô ˜HÔ%Ø’Ø�H‰H�XÕð	ð ˆr<   c                ó¤   •— t        j                  t        |«      }t        ‰| �  |«      xr% | j
                  j	                  |j
                  «      S r3   )r  r  r   rƒ   rú   rÒ  r   s     €r9   rú   zRepeatedExpr.pattern_eq¤  sF   ø€ Ü—‘œD %Ó(ˆÜ‰wÑ! %Ó(ò 
¨T×-?Ñ-?×-JÑ-JØ×Ñó.
ð 	
r<   )rÒ  r+  r>   rT   )r>   zSequence[FnsType]rû   rÿ   )
r1   r?   r@   rÉ   rR   rÊ   r,  rã   rú   rË   rÌ   s   @r9   rÐ  rÐ  …  s0   ø„ ñõ#ð
 ò&ó ð&ó÷"
ñ 
r<   rÐ  c                  óf   — e Zd ZdZdd„Ze ej                  d«      dd	d„«       «       Zd
d„Z	dd„Z
y)r  z˜
    Serializes Patterns to executable python.
    XXX: currently only used and tested for fuse attention patterns. May not cover
    all patterns.
    c                óz   — t         j                  j                  j                  «       | _        i | _        i | _        y r3   )r[   r\   r‡   Ú
_NamespaceÚ	namespaceÚmemoized_objs_namesÚmemoized_objs_pprQ   s    r9   rR   zPatternPrettyPrinter.__init__²  s*   € ÜŸ™Ÿ™×2Ñ2Ó4ˆŒØ;=ˆÔ Ø8:ˆÕr<   Nc                ó  — t        «       }t        | d«      sJ ‚| j                  |¬«      }|j                  D �cg c]#  }|j                  |   › d|j                  |   › �‘Œ% }}|j                  |› d|› �«       dj                  |«      S c c}w )zU
        Serializes obj to python code with obj written out to `output_name`
        r  )r  z = ú
)r  Úhasattrr  rÝ  rÞ  rl   rx  )ÚobjÚoutput_namer  Úout_strr�   rÄ  s         r9   ÚrunzPatternPrettyPrinter.run·  s¤   € ô "Ó#ˆÜ�s˜NÔ+Ð+Ð+Ø×"Ñ" bÐ"Ó)ˆð ×-Ñ-ö
àð ×%Ñ% cÑ*Ð+¨3¨r×/BÑ/BÀ3Ñ/GÐ.HÒIð
ˆð 
ð
 	�‰˜˜ S¨¨	Ð2Ô3à�y‰y˜Ó Ð ùò
s   ¹(B
c                óÒ   — t        |t        «      r0| j                  j                  |«      x}r|S | j	                  |«      S t        |d«      r|j                  | «      S t        |«      S )Nr  )r¶   rP  rÝ  rj   Úmemoizerá  r  rw  )r6   râ  Úmemoized_names      r9   r  z!PatternPrettyPrinter.pretty_printË  sb   € Ü�cœ?Ô+Ø $× 8Ñ 8× <Ñ <¸SÓ AÐAˆ}ÐAØ$Ð$à—|‘| CÓ(Ð(Ü�3˜Ô'Ø×#Ñ# DÓ)Ð)ä�C‹yÐr<   c                óî   — |j                  | «      }|j                  «       }dD ]  }|j                  |d«      }Œ | j                  j	                  |d «      }|| j
                  |<   || j                  |<   |S )N)zaten.r:  zprims.r@  )r  r>  ÚreplacerÜ  Úcreate_namerÝ  rÞ  )r6   râ  Úobj_strÚobj_nameÚprefixÚtmp_names         r9   rç  zPatternPrettyPrinter.memoizeÖ  s{   € Ø×"Ñ" 4Ó(ˆØ—<‘<“>ˆØ3ò 	4ˆFØ×'Ñ'¨°Ó3‰Hð	4ð —>‘>×-Ñ-¨h¸Ó=ˆØ(0ˆ× Ñ  Ñ%Ø%,ˆ×Ñ˜cÑ"Øˆr<   rS   )rÄ  )râ  rx   rã  r0   r>   r0   )râ  r   r>   r0   )râ  rP  r>   r0   )r1   r?   r@   rÉ   rR   r˜  rº   Ú	lru_cacherå  r  rç  r4   r<   r9   r  r  «  s?   „ ñó;ð
 Ø€Y×Ñ˜Óó!ó ó ð!ó$	ô	r<   r  c                  ó   — e Zd Z	 	 	 	 dd„Zy)Ú_PassDictsTypec                 ó   — y r3   r4   )r6   ra   s     r9   Ú__getitem__z_PassDictsType.__getitem__ã  s   € à r<   N)ra   ú tuple[str, torch.fx.node.Target]r>   úlist[PatternEntry])r1   r?   r@   rô  r4   r<   r9   rò  rò  â  s   „ ð!Ø1ð!à	ô!r<   rò  c                  óF   — e Zd ZU ded<   ded<   dd„Z	 	 d		 	 	 	 	 	 	 d
d„Zy)ÚPatternEntryrx   ry   úCallable[[Match], bool]Úextra_checkc                ó   — t         ‚r3   rE  ©r6   rå   r‡   rä   s       r9   ÚapplyzPatternEntry.applyí  s   € Ü!Ð!r<   Nc                ó  — |€Ht        | j                  d«      sJ ‚| j                  j                  D ]  }| j                  |||¬«       Œ y t	        |t
        t        f«      rqt        | j                  d«      sJ ‚|r,|| j                  j                  |f   j                  d| «       y || j                  j                  |f   j                  | «       y t        j                  t        t           |«      }|D ]  }| j                  |||¬«       Œ y )Nr,  ©Úprependr7  r   )rá  ry   r,  Úregisterr¶   rá   ÚPatternMatcherPassr7  Úinsertrl   r  r  r   rò  )r6   Ú
pass_dictsr  r   rI   rU  s         r9   r  zPatternEntry.registerð  sç   € ð ˆ>Ü˜4Ÿ<™<¨Ô/Ð/Ð/Ø—l‘l×&Ñ&ò ?�Ø—‘˜j¨"°g�Õ>ñ?ä˜
¤TÔ+=Ð$>Ô?Ü˜4Ÿ<™<¨Ô.Ð.Ð.ÙØ˜DŸL™LŸO™O¨VÐ4Ñ5×<Ñ<¸QÀÕEà˜DŸL™LŸO™O¨VÐ4Ñ5×<Ñ<¸TÕBäŸ™¤X¬nÑ%=¸zÓJˆJØò :�Ø—‘˜a °�Õ9ñ:r<   ©rå   rw   r‡   rÃ   rä   rÅ   r>   rT   rÖ   )r  ú/Union[_PassDictsType, Sequence[_PassDictsType]]r  z!Union[torch.fx.node.Target, None]r   rÈ   r>   rT   )r1   r?   r@   rA   rý  r  r4   r<   r9   rø  rø  è  sF   … àÓØ(Ó(ó"ð 59Øð	:àCð:ð 2ð:ð ð	:ð
 
ô:r<   rø  c                  ó    — e Zd ZU ded<   dd„Zy)ÚLoweringPatternEntryúCallable[..., Any]Úhandlerc                óè  —  t        j                  | j                  «      t        j                  | j                  |«      «      }|j	                  |«      5  |j                  |t        |j                  «      |j                  «      }|j                  j                  |j                  «       |j                  |«       d d d «       |j                  d   |u sJ ‚|j                  «        y # 1 sw Y   Œ-xY w)Néÿÿÿÿ)rº   Úwrapsr
  r»   Úinserting_beforer›  r�   r7   r8   ro   rn   Úreplace_all_uses_withr}   rœ   )r6   rå   r‡   rä   r
  rÂ   s         r9   rý  zLoweringPatternEntry.apply
  s»   € Ø/”)—/‘/ $§,¡,Ó/´	×0AÑ0AÀ$Ç,Á,ÐPUÓ0VÓWˆØ×#Ñ# DÓ)ñ 	4Ø×-Ñ-¨g´u¸U¿Z¹ZÓ7HÈ%Ï,É,ÓWˆKØ×Ñ×#Ñ# D§I¡IÔ.Ø×&Ñ& {Ô3÷	4ð �{‰{˜2‰ $Ñ&Ð&Ð&Ø×ÑÕ÷	4ð 	4ús   ÁA'C(Ã(C1Nr  )r1   r?   r@   rA   rý  r4   r<   r9   r  r    s   … àÓôr<   r  c                  ó$   — e Zd ZU dZded<   dd„Zy)ÚGraphPatternEntryz8
    A pattern that runs a function on the FX graph
    r	  r
  c                ó¤   — |j                  |«      5   | j                  |g|j                  ¢­i |j                  ¤Ž d d d «       y # 1 sw Y   y xY wr3   )r  r
  r7   r8   rü  s       r9   rý  zGraphPatternEntry.apply  sE   € Ø×#Ñ# DÓ)ñ 	=ØˆD�L‰L˜Ð< §¡Ò<¨u¯|©|Ò<÷	=÷ 	=ñ 	=ús   ’+AÁANr  )r1   r?   r@   rÉ   rA   rý  r4   r<   r9   r  r    s   … ñð  Óô=r<   r  c                  óF   — e Zd ZU ded<   e	 	 	 	 	 	 	 	 	 	 dd„«       Zdd„Zy)r§   zCallable[..., list[Any]]Únormalize_argsc                óà  ‡‡‡‡‡—  G ˆfd„dt         j                  j                  «      }| j                  «       }t	        |«      dk(  r|d   }n�|d   sJ ‚t        |d   j                  j                  «      }|D �cg c]9  }t        |t         j                  j                  «      r|j                  |«      |f‘Œ; }	}t        |	t        j                  d«      ¬«      d   }	 	 	 	 	 	 	 	 	 	 d	d„Š‰j                  |«      5  t        |t         j                  j                  «      sJ ‚  ||«      j                   ‰Ž }
t        |
t         j                  j                  «      r|
g}
d
d„Š	 	 	 	 	 	 dˆˆˆˆˆfd„Št	        |«      t	        |
«      k(  rt#        ||
«      D ]  \  }} ‰||«       Œ nt	        |«      dk(  sJ ‚ ‰|d   |
«       d d d «       | j%                  «        y c c}w # 1 sw Y   ŒxY w)Nc                  ó0   •‡ — e Zd ZdZdZdZdˆ ˆfd„Zˆ xZS )ú<ReplacementPatternEntry.replace_with_graph.<locals>.ReplacerNc                óB  •— |j                   dv rt        ‰| �	  |«      S |j                   dk(  rå|j                  }| j	                  |«      \  }}t        |«      sJ ‚‰j                  |||«      }t        |j                  |d¬«       d|j                  v r}d|j                  vro|j                  d   |j                  d<   t        |j                  d   t        j                  «      r,d|j                  v sJ ‚|j                  d   |j                  d<   |S t        d|› �«      ‚)N)ÚplaceholderrÄ  r›  ÚInterpreter_Replacerr´   r¯   Útensor_metaz
unhandled )r7  rƒ   Úrun_noder  Úfetch_args_kwargs_from_envr2  r›  ru   ro   r¶   r[   ÚTensorrF  )r6   rä   r  r7   r8   Úresultr…   r‡   s         €€r9   r  zEReplacementPatternEntry.replace_with_graph.<locals>.Replacer.run_node1  s  ø€ Ø—7‘7Ð7Ñ7Ü ™7Ñ+¨DÓ1Ð1Ø—7‘7˜oÒ-Ø!Ÿ[™[�FØ#'×#BÑ#BÀ4Ó#H‘L�D˜&Ü# FÔ+Ð+Ð+Ø"×0Ñ0°¸¸vÓF�FÜ"Ø!'§¡Ø!%Ø"8õð
  §	¡	Ñ)¨e¸6¿;¹;Ñ.FØ-1¯Y©Y°uÑ-=˜Ÿ™ EÑ*Ü% d§i¡i°Ñ&6¼¿¹ÔEØ#0°D·I±IÑ#=Ð=Ð#=Ø9=¿¹À=Ñ9Q˜FŸK™K¨Ñ6Ø!�MÜ)¨J°t°fÐ*=Ó>Ð>r<   ©rä   rÅ   r>   r   )r1   r?   r@   rŸ  r£  Úget_attrr  rË   )r…   r‡   s   @€r9   ÚReplacerr  ,  s   ù„ ØˆKØˆKØˆH÷?ò ?r<   r"  r+   r   )r�   c                ó  — | g}t        t        j                  j                     «       }|rc|j	                  «       }||vrK||vrGt        |d«      r;|j                  |«       ||j                  |<   |j                  |j                  «       |rŒby y )Nro   )
r!   r[   r\   rH  rÕ  rá  r�  ro   r‹   Úall_input_nodes)rä   Útag_nameÚ	tag_valueÚinput_stopsÚqueueÚvisitedr±   s          r9   Úpercolate_tagszBReplacementPatternEntry.replace_with_graph.<locals>.percolate_tagsT  sy   € ð �FˆEÜ ¤§¡§¡Ñ/Ó1ˆGáØ—i‘i“k�à˜wÑ&Ø ;Ñ.Ü  VÔ,à—K‘K Ô$Ø)2�C—H‘H˜XÑ&Ø—L‘L ×!4Ñ!4Ô5ô r<   c                ó°   — | j                   dk7  ry | j                  t        j                  k7  ry t	        | j
                  «      dk(  sJ ‚| j
                  d   S )Nr›  r"   r+   )r7  r  r;  Úgetitemr¾   r7   ©rä   s    r9   Úmaybe_getitemzAReplacementPatternEntry.replace_with_graph.<locals>.maybe_getitemn  sJ   € Ø—7‘7˜oÒ-ØØ—;‘;¤(×"2Ñ"2Ò2ØÜ˜4Ÿ9™9“~¨Ò*Ð*Ð*Ø—y‘y ‘|Ð#r<   c           	     óÄ  •— | €|�J ‚y t        | t        j                  j                  «      sJ ‚|€#| j	                  d «       ‰j                  | «       y t        |t        j                  j                  «      r�d|j                  vr%|j                  j                  | j                  «       dD ]2  }|| j                  v sŒ ‰	||| j                  |   t        ‰«      «       Œ4 | j	                  |«       ‰j                  | «       y t        | j                  j                  «       «      }|D ]#  } ‰|«      }|€t        d«      ‚ ‰
|||   «       Œ% ‰j                  | «       y )Nr¯   )Ú	recomputeÚac_graph_idzcan't handle)r¶   r[   r\   rH  r  rš   ro   rn   r!   r„   r™   r‰   ÚAssertionError)ÚoldÚnewr%  Úold_usesÚuserÚidxr7   r‡   r.  r*  rê  s         €€€€€r9   rê  z;ReplacementPatternEntry.replace_with_graph.<locals>.replacev  sA  ø€ ð �;Ø˜;Ð&˜;ØÜ! #¤u§x¡x§}¡}Ô5Ð5Ð5Ø�;Ø×-Ñ-¨dÔ3Ø×$Ñ$ SÔ)ØÜ˜c¤5§8¡8§=¡=Ô1Ø C§H¡HÑ,ØŸ™Ÿ™¨¯©Ô1ð %Aò ˜Ø# s§x¡xÒ/Ù*Ø # X¨s¯x©x¸Ñ/AÄ:ÈdÓCSõðð ×-Ñ-¨cÔ2Ø×$Ñ$ SÔ)Øô:   §	¡	§¡Ó 0Ó1�Ø$ò ,�DÙ'¨Ó-�CØ�{Ü,¨^Ó<Ð<Ù˜D # c¡(Õ+ð	,ð
 × Ñ  Õ%r<   )
rä   rÅ   r%  r0   r&  r0   r'  rþ   r>   rT   r   )r3  zUnion[torch.fx.Node, None]r4  z3Union[torch.fx.Node, Sequence[torch.fx.Node], None]r>   rT   )r[   r\   ÚInterpreterr¡   r¾   r„   r‡   r}   r¶   rH  ÚindexÚminr;  Ú
itemgetterr  ÚGraphModulerå  r€  rœ   )rå   r‡   r�   r7   r"  r¡   Ú	last_noder}   r›   ÚindicesrÂ   r3  r4  r.  r*  rê  s    ` `         @@@r9   r¨   z*ReplacementPatternEntry.replace_with_graph%  s	  ü€ ö	?”u—x‘x×+Ñ+ô 	?ð4 ×)Ñ)Ó+ˆäˆ|Ó Ò!Ø$ Q™‰Ià ’?Ð"�?Ü˜ a™×.Ñ.×4Ñ4Ó5ˆEð &öàÜ˜a¤§¡§¡Ô/ð —‘˜Q“ Ò#ðˆGð ô
 ˜G¬×)<Ñ)<¸QÓ)?Ô@ÀÑCˆIð	6Øð	6àð	6ð ð	6ð 3ð		6ð
 ó	6ð( ×#Ñ# IÓ.ñ X	6ÜÐ/´·±×1EÑ1EÔFÐFÐFØ9™(Ð#4Ó5×9Ñ9¸4Ð@ˆKÜ˜+¤u§x¡x§}¡}Ô5Ø*˜m�ó$ðC&Ø/ðC&àHðC&ð ÷C&ñ C&ôJ �<Ó ¤C¨Ó$4Ò4Ü # L°+Ó >ò &‘H�C˜Ù˜C Õ%ñ&ô ˜<Ó(¨AÒ-Ð-Ð-Ù˜ Q™¨Ô5÷qX	6ðt 	×ÑÕùòk÷6X	6ð X	6ús   Á<>GÃ>CG$Ç$G-c           
     ó¤   — |j                   €J ‚| j                  |||j                    | j                  |j                  i |j                  ¤Ž«       y r3   )r�   r¨   r  r7   r8   rü  s       r9   rý  zReplacementPatternEntry.applyÄ  sN   € Ø×&Ñ&Ð2Ð2Ð2Ø×ÑØØØ×#Ñ#ØˆD×Ñ §¡Ð<¨u¯|©|Ñ<õ		
r<   N)
rå   rw   r‡   rÃ   r�   z+Union[torch.fx.Graph, torch.fx.GraphModule]r7   zSequence[torch.fx.Node]r>   rT   r  )r1   r?   r@   rA   r˜  r¨   rý  r4   r<   r9   r§   r§   !  sV   … à,Ó,àð\Øð\àð\ð Gð\ð &ð	\ð
 
ò\ó ð\ô|
r<   r§   c                 ó   — yrÇ   r4   )rå   s    r9   Ú_return_truerA  Î  s   € Ør<   c                óF   — t         j                  d| j                  |«       y )Nz@Replacement pattern %s failed to apply due to shape mismatch: %s)ÚlogÚinfor1   )Ú	search_fnrò   s     r9   Úlog_trace_failurerF  Ò  s   € Ü‡H�HØJØ×ÑØ	õr<   Fc                óp  ‡‡— t         j                  | «      Š|j                  ‰«      }|s'|‰   j                  |rt	        |«      «       yd«       y|€|ryt        j                  dˆfd„«       t	        |«      }|D ]&  Š|‰k(  sŒ	|r yt        j                  dˆˆfd„«       Œ( |j                  |«       y)aB  
    Check if a pattern is a duplicate. Because we ignore certain types in searching, but not
    in matching, use the graph to distinguish equivalent search patterns.

    Returns True if a duplicate is found and `skip_duplicates=True` is passed in. Errors if
    `skip_duplicates` is False and a duplicate is found.
    NFTc                 ó   •— d‰ › d�S )NúDuplicate pattern: z with no graphr4   )Úpattern_reprs   €r9   r²   z1check_and_add_duplicate_pattern.<locals>.<lambda>ó  s   ø€ Ð)¨,¨°~ÐF€ r<   c                 ó   •— d‰› d‰ › d�S )NrI  z with duplicated match graph ú r4   )Ú	graph_strrJ  s   €€r9   r²   z1check_and_add_duplicate_pattern.<locals>.<lambda>þ  s   ø€ Ð)¨,¨Ð7TÐU^ÐT_Ð_`Ða€ r<   )r  rå  rj   rl   r0   r[   Ú_check)ry   r‡   Úseen_patternsÚskip_duplicatesÚequiv_pattern_reprsÚnew_graph_strrM  rJ  s         @@r9   Úcheck_and_add_duplicate_patternrS  Ú  s¿   ù€ ô (×+Ñ+¨GÓ4€LØ'×+Ñ+¨LÓ9ÐÙØ�lÑ#×*Ñ*¹¬3¨u«:ÔIØð EIÔIØà€}ÙØÜ�‰ØÛFô	
ô
 ˜“J€MØ(ò 
ˆ	Ø 	Ò)ØÙÙÜ�‰ØÜaõ	
ð
ð ×Ñ˜}Ô-Ør<   r4   c
           
     óâ  ‡ ‡‡‡‡‡‡‡‡— g t        j                  ‰ «      j                  j                  «       ¢Šdˆˆˆˆˆˆˆ ˆˆf	d„}
d	ˆfd„}‰t        u rt        j                  «       ryt        j                  d¬«      5  |D �cg c]*  }t        |t
        j                  «      xr |j                  ‘Œ, c}Š‰€t        ‰ |‰‰‰«      \  }}n‰}d}t        |t        «      r|n|gD ]D  }t        |t        «      sŒt        ||r|j                   nd|j"                  |	¬«      sŒ< ddd«       y t%        ||
|¬«      }|j'                  |«       |j(                  cddd«       S c c}w # 1 sw Y   yxY w)
a  
    Create a replacement rule based on example functions that get traced
    to create patterns.  This supports both training and inference when
    run on a joint forward+backward graph.

    Args:
        search_fn: traced to give original pattern
        replace_fn: traced to give replacement graph
        example_inputs: example inputs for initial trace
        trace_fn: fwd_only or joint_fwd_bwd
        pass_dict: dict of passes to register to
        extra_check: additional check to run on match(using real shapes)
    c           
     ó†  •	‡‡— t        ‰«      }|D ]+  }|| j                  vsŒt        d|› d| j                  › �«      ‚ t        t        j                  j                  |D �cg c]  }| j                  |   ‘Œ c}d„ «      «      Šg }t        j                  j                  j                  ‰«      5  t        ‰«      D �]  \  }}t        ‰|   t        j                  «      sŒ%|r"t        ‰|   j                  «      r
 ddd«       yt        j                  ‰|   j                  «       ‰|   j!                  «       ‰|   j                  ‰|   j"                  |¬«      ‰|<   t%        j&                  ‰|   j(                  ‰|   j!                  «       «      D ]C  Št        ‰t        j*                  «      sŒt-        ˆfd„|D «       «      sŒ3|j/                  ‰«       ŒE �Œ ‰}|�s3|�rdˆˆfd„}	  ‰||‰z   «      }g }
t3        t5        t7        |«      t7        ‰«      z   «      |j8                  j:                  «      D ]º  \  }}|t7        |«      k  r|
j/                  |j<                  «       Œ0|j8                  j?                  |«      5  |j8                  jA                  ||t7        |«      z
     «      }|jB                  |_        |jE                  |«       |j8                  jG                  |«       ddd«       Œ¼ |
|z   }n
	  ‰‰‰«      }tI        ||‰‰¬	«      }| jK                  «       d
   }|€J ‚|jM                  |«      }tO        |«      r‚ ‰|«      rz ‰‰‰«      | _(        t7        | j:                  «      dk(  rJ| jP                  j8                  j:                  D ]'  }tS        |jT                  | j:                  d
   d¬«       Œ) 	 ddd«       y	 ddd«       yc c}w # t        $ r}	t1        ‰|	«       Y d}	~	ddd«       yd}	~	ww xY w# 1 sw Y   �ŒÔxY w# t        $ r}	t1        ‰|	«       Y d}	~	ddd«       yd}	~	ww xY w# 1 sw Y   yxY w)z°
        Often shapes get burned into the pattern, so our initial match ran with
        `ignore_types=(int, ...)`.

        Recheck the match with the correct shapes.
        z_Not all inputs to pattern found in match.kwargs. Perhaps one of the inputs is unused? argnames=z, match.kwargs=c                ó    — | j                   d   S r®   r°   )r›   s    r9   r²   z8register_replacement.<locals>.check_fn.<locals>.<lambda>0  s   € ÀQÇVÁVÈEÁ]€ r<   NF)ÚdtypeÚdeviceÚrequires_gradc              3  ó:   •K  — | ]  }t        ‰|k7  «      –— Œ y ­wr3   r   )r`   r“  rb   s     €r9   rc   z9register_replacement.<locals>.check_fn.<locals>.<genexpr>C  s    øè ø€ ò ?Ø>?Ô1°!°q±&×9ñ?ùs   ƒc                 ó>   •—  ‰| t        | «      t        ‰«      z
  d  Ž S r3   )r¾   )Úargs_newr7   rE  s    €€r9   Úsearch_fn_newz=register_replacement.<locals>.check_fn.<locals>.search_fn_newV  s#   ø€ Ù(¨(´3°x³=Ä3ÀtÃ9Ñ3LÐ3NÐ*OÐPÐPr<   )ÚargnamesÚexclusive_arg_namesÚscalar_workaroundr   r+   rÂ   r´   T)r\  r   r>   r   )+r„   r8   rÑ   r[   r\   r½   Ú_dynamoÚutilsÚdetect_fake_moder¹  r¶   r  r   rW  Úempty_stridedÚsizeÚstriderX  rW  rX  ÚshapeÚSymIntr—  rl   rF  r€  Úranger¾   r‡   r}   r  Úinserting_afterr  r  r  rš   Úfx_to_patternr¡   rå   rÜ   r�   ru   ro   )rå   r^  r  Úsym_argsr…  ÚgradÚspecific_patternr]  Úspecific_graphrò   Úsym_arg_namesr  Únew_noderä   Úspecific_pattern_matchr›   r7   rb   Úargnames_staticr_  rú  Ú
replace_fnrY  r`  rE  Úsearch_fn_patternrÀ   s                   @@€€€€€€€€€r9   Úcheck_fnz&register_replacement.<locals>.check_fn  s,  ú€ ô ˜Ó(ˆØò 	ˆDØ˜5Ÿ<™<Ò'Ü"ð9Ø9A¸
À/ÐRW×R^ÑR^ÐQ_ðaóð ð	ô Ü�H‰H×ÑØ08Ö9¨�—‘˜dÓ#Ò9Ñ;Róó
ˆð (*ˆÜ�]‰]× Ñ ×1Ñ1°$Ó7ñ Z	Ü$ ]Ó3ó /‘��4Ü˜d 1™g¤u§|¡|Õ4ÙÔ 0°°a±·±Ô ?Ø$÷	Z	ð Z	ô $×1Ñ1Ø˜Q™Ÿ™›Ø˜Q™Ÿ™Ó(Ø" 1™gŸm™mØ# A™wŸ~™~Ø&*ô�D˜‘Gô 'Ÿ_™_¨T°!©W¯]©]¸DÀ¹G¿N¹NÓ<LÓMò /˜Ü% a¬¯©Õ6¼3ó ?ØCKô?õ <ð %ŸO™O¨AÕ.ò	/ð/ð*  1Ðâ#ÚöQð%Ù)1°-ÀÈDÁÓ)Q˜ð %'�MÜ*-Üœc (›m¬c°$«iÑ7Ó8Ø&×,Ñ,×2Ñ2ó+ò I™˜˜;ð œs 8›}Ò,Ø)×0Ñ0°×1CÑ1CÔDØ$à+×1Ñ1×AÑAÀ+ÓNñ IØ'5×';Ñ';×'GÑ'GØ (¨¬S°«]Ñ):Ñ ;ó(˜Hð /7¯m©m˜HœOØ'×=Ñ=¸hÔGØ*×0Ñ0×;Ñ;¸KÔH÷Ið IðIð   -¨xÑ7‘Hð%Ù)1°)¸TÓ)B˜ô
 $1Ø"Ø%Ø(;Ø&7ô	$Ð ð ×%Ñ%Ó'¨Ñ*ˆDØÐ#Ð#Ð#Ø%5×%;Ñ%;¸DÓ%AÐ"äÐ.Ô/±KÐ@VÔ4Wá*2°:¸tÓ*D�Ô'Ü�u—{‘{Ó# qÒ(Ø"×4Ñ4×:Ñ:×@Ñ@ò ˜Ü&Ø%&§V¡VØ%*§[¡[°¡^Ø&3öðð ÷sZ	ð Z	ðt ÷uZ	ð Z	ùò :øôV (ò %Ü)¨)°QÔ7Û$÷QZ	ð Z	ûðL%ú÷Iñ Iûô (ò %Ü)¨)°QÔ7Û$÷EZ	ð Z	ûð@%ú÷AZ	ð Z	ús    Á!OÂ/0P7Ã P7ÄB*P7Æ/P7Ç%P7Ç*OÇ6BP7ÊA(P Ë)P7Ë:	PÌB;P7ÏP7Ï	O=ÏO8Ï+P7Ï8O=Ï=P7Ð P
ÐP7Ð	P4ÐP/Ð"P7Ð/P4Ð4P7Ð7Q c                 óø   •— ‰D �cg c]  }| j                  |«      ‘Œ }}t        dt        | «      dz   «      D ].  }d|› �| vr n%|j                  | j                  d|› �«      «       Œ0 | r
J d| ›�«       ‚|S c c}w )Nr+   Ú	tangents_zleftover kwargs: )rÕ  ri  r¾   rl   )r8   r  r7   r…  rs  s       €r9   r  z,register_replacement.<locals>.normalize_args‘  sŠ   ø€ Ø-<Ö= T�—
‘
˜4Õ Ð=ˆÐ=Ü�qœ#˜f›+¨™/Ó*ò 	5ˆAØ˜1˜#ˆ fÑ,ÙØ�K‰K˜Ÿ
™
 Y¨q¨c ?Ó3Õ4ð	5ñ Ð9Ð.¨v¨jÐ9Ó9ˆzØˆùò >s   †A7F©Úfunctionalize_rng_opsN)rP  )ry   rú  r  ©rå   rw   r>   rÈ   )r8   r   r>   rz   )ÚinspectÚ	signatureÚ
parametersr‰   Újoint_fwd_bwdr[   Úis_inference_mode_enabledÚfunctorch_configÚpatchr¶   r  rY  Úgen_pattern_and_search_gmr   r  rS  r‡   rO  r§   r  ry   )rE  rt  Úexample_inputsrÀ   r  rú  r`  r_  ru  rP  rv  r  rU  ry   ÚgmÚpattern_matcher_passrs  rY  s   `` ` ````       @@r9   Úregister_replacementr‡    so  ÿø€ ð2 Hœ×)Ñ)¨)Ó4×?Ñ?×DÑDÓFÐG€O÷põ põdð ”=Ñ ô ×*Ñ*Ô,Øô 
×	Ñ	°eÔ	<ñ "àESö%
Ø@AŒJ�qœ%Ÿ,™,Ó'Ò;¨A¯O©OÑ;ò%
ˆð Ð$Ü3ØØØØ!Ø#ó‰KˆG‘Rð (ˆGØˆBô % Z´Ô:‰JÀÀò
	!Ð ô Ð.Ô0BÕCÜ2ØÙ "�B—H’H¨Ø(×6Ñ6Ø$3ö	ð !÷5"ð "ð 
	!ô *ØØ Ø)ô
ˆð
 	×Ñ˜Ô$Ø�‰÷E"ñ "ùò%
÷"ð "ús1   Â E%Â/E Â4AE%Ã9'E%Ä!E%Ä++E%Å E%Å%E.c                óV  — dd„}t         j                  «       st        dt         › �«      ‚|j                  }ddlm}  |j                  d¬«      5  t        ||||«      }d d d «       t        j                  | ¬«      }	|t        vrd}
t        j                  |«       nd	}
 |«       }t        t         |› d
�z  |
«      5 }|
dk(  r|j                  |«       n|j                  d«       |j                  |	«       |j                  d«       d d d «       |S # 1 sw Y   Œ´xY w# 1 sw Y   |S xY w)Nc                 ó¾  — t        j                  d«      } t        j                  d«      j                  | ¬«      }g }t        t        j
                  j                  «      D ]_  }t        t        j
                  j                  |«      }t        |t        «      sŒ8t        |t        t        f«      sŒO|j                  |«       Œa dj                  |«      }d|› d�}|› |› �S )NzÁ            # This is an auto-generated file. Please do not modify it by hand.
            # To re-generate, run:
            # cd ~/pytorch && python torchgen/fuse/gen_patterns.py
            a               # mypy: ignore-errors

            # noqa: F401, E501
            {msg}
            import torch
            import torch._inductor
            import operator

            aten = torch.ops.aten
            prims = torch.ops.prims

            )Úmsgz,
   z1from torch._inductor.pattern_matcher import (
   z,
)
)ÚtextwrapÚdedentrÓ   Údirr[   Ú	_inductorÚpattern_matcherr0  r¶   rd  Ú
issubclassrx   r+  rl   rx  )Úauto_generated_msgÚfile_templateÚpattern_matcher_importsr  ÚattrÚformatted_importss         r9   Úget_file_templatez-_serialize_pattern.<locals>.get_file_templateÐ  sÔ   € Ü%Ÿ_™_ðó
Ðô !Ÿ™ðó
÷ ‰&Ð'ˆ&Ó
(ð 	ð  #%ÐÜœŸ™×7Ñ7Ó8ò 	5ˆDÜœ5Ÿ?™?×:Ñ:¸DÓAˆDÜ˜$¤Õ%¬*°T¼KÌÐ;UÕ*VØ'×.Ñ.¨tÕ4ð	5ð
 %ŸM™MÐ*AÓBÐØPÐQbÐPcÐciÐjÐØ�Ð!2Ð 3Ð4Ð4r<   z0Could not find serialized patterns directory at r   r#   Fry  )rã  Úwr“  z.pyz

rà  rÄ   )ÚSERIALIZED_PATTERN_PATHÚis_dirrÑ   r1   Útorch._functorchr$   r‚  Úgen_patternr  rå  Ú_serialized_patternsr�  ÚopenÚwrite)Úunique_namerE  r„  rÀ   r`  r–  Úpattern_namer�  ry   Úserialized_patternÚ
write_moder’  Úfs                r9   Ú_serialize_patternr¤  É  s)  € ó!5ôF #×)Ñ)Ô+ÜØ>Ô?VÐ>WÐXó
ð 	
ð ×%Ñ%€Lå;à	Ð	×	Ñ	°eÔ	<ñ VÜ˜i¨¸ÐCTÓUˆ÷Vô .×1Ñ1°'À{Ð1ÓSÐØÔ/Ñ/Øˆ
Ü× Ñ  Õ.àˆ
á%Ó'€Mä	Ô%¨<¨.¸Ð(<Ñ<¸jÓ	Ið ÈQØ˜ÒØ�G‰G�MÕ"à�G‰G�FŒOØ	�‰Ð"Ô#Ø	�‰�Œ÷ð €N÷)Vð Vú÷ð €Nús   ÁDÂ=ADÄDÄD(Ú	fx_passesÚserialized_patternszvlist[tuple[Any, Iterable[Any], Callable[[Callable[..., Any], Iterable[Any]], torch.fx.GraphModule], Any, PatternExpr]]Ú_known_precompiled_patternsc
                óâ  — t        |«      }dt        j                  v rt        | ||||«      }
nT|j                  }t        j                  d|› �«      }|rt        || «      st        j                  d| «       t        || «      }
t        j                  |«      D ]'  }t        |t        «      sŒ|j                  €Œ!d |_        Œ) t         j#                  |||||
f«       t%        |||||||||
|	¬«
       y )NÚPYTORCH_GEN_PATTERNSz.torch._inductor.fx_passes.serialized_patterns.zDPrecompiled pattern %r not found. Run torchgen/fuse/gen_patterns.py.)ru  rP  )r�   ÚosÚenvironr¤  r1   Ú	importlibÚimport_modulerá  rC  Úwarningr0  ri  Ú	tree_iterr¶   r(   Úconstantr§  rl   r‡  )rŸ  rE  rt  r„  rÀ   r  rú  r`  r_  rP  Úpatr   rÛ   r±   s                 r9   Úgen_register_replacementr²  #  s  € ô ˜>Ó*€Nà¤§¡Ñ+Ü Ø˜ N°HÐ>Oó
‰ð !×)Ñ)ˆÜ×#Ñ#Ø<¸\¸NÐKó
ˆñ œ  ;Ô/Ü�K‰KØVØôô �a˜Ó%ˆä×Ñ Ó/ò  ˆÜ�cœ:Õ&¨3¯<©<Ñ+Cð
  ˆC�Lð ô  ×&Ñ&Ø	�N HÐ.?ÀÐEôô ØØØØØØØØØØ'ör<   ry  c                ór  — g t        j                  | «      j                  j                  «       ¢}|€i }g }d}|D ]4  }||v r|j	                  ||   «       Œ|j	                  ||   «       |dz  }Œ6  || |«      }	t        |	t        t        t        t        j                  t        j                  f|||¬«      |	fS )Nr   r+   )Úignore_typesr^  r`  r_  )r|  r}  r~  r‰   rl   rk  ÚintÚfloatr„   r[   rX  rW  )
rE  r„  rÀ   r`  r_  r^  Úflat_inputsÚ	input_idxÚargnameÚ	search_gms
             r9   rƒ  rƒ  [  sÎ   € ð A”×"Ñ" 9Ó-×8Ñ8×=Ñ=Ó?Ð@€HàÐ ØÐØ€KØ€Iàò ˆØÐ'Ñ'Ø×ÑÐ0°Ñ9Õ:à×Ñ˜~¨iÑ8Ô9Ø˜‰N‰Iðñ ˜ KÓ0€IäØÜœu¤d¬E¯L©L¼%¿+¹+ÐFØØ/Ø 3ô	
ð 	ð	ð 	r<   c                ó&   — t        | ||||«      d   S rÃ  )rƒ  )rE  r„  rÀ   r`  r_  s        r9   r›  r›  ~  s&   € ô %Ø�> 8Ð->Ð@Sóàñ	ð 	r<   rÿ  c               ó    ‡ ‡‡‡— dˆˆˆ ˆfd„}|S )zº
    Register an aten to inductor IR replacement pattern.  The decorated
    function is saved and then called a lowering time allowing direct
    pattern to inductor IR conversion.
    c                ón   •— t        | «      sJ ‚t        ‰‰| ¬«      j                  ‰‰¬«       d| _        | S )N©ry   rú  r
  rÿ  T)r2  r  r  Ú_inductor_lowering_function©r
  rú  Ú	pass_dictry   r   s    €€€€r9   Ú	decoratorz,register_lowering_pattern.<locals>.decorator—  s;   ø€ Ü˜Ô Ð Ð ÜØ¨¸gô	
ç
‰(�9 gˆ(Ô
.Ø.2ˆÔ+Øˆr<   ©r
  r	  r>   r	  r4   ©ry   rú  rÁ  r   rÂ  s   ```` r9   Úregister_lowering_patternrÅ  Š  s   û€ ÷ð ð Ðr<   c               ó    ‡ ‡‡‡— dˆˆˆ ˆfd„}|S )zk
    Register a pattern that runs a function on the FX graph, allowing
    custom transformation code.
    c                ó`   •— t        | «      sJ ‚t        ‰‰| ¬«      j                  ‰‰¬«       | S )Nr¾  rÿ  )r2  r  r  rÀ  s    €€€€r9   rÂ  z)register_graph_pattern.<locals>.decorator®  s3   ø€ Ü˜Ô Ð Ð ÜØ¨¸gô	
ç
‰(�9 gˆ(Ô
.Øˆr<   rÃ  r4   rÄ  s   ```` r9   Úregister_graph_patternrÈ  ¢  s   û€ ÷ð ð Ðr<   c                óB   — |t        t        | j                  «      «      u S r3   )r¤   Úiterr}   )r‡   rä   s     r9   Úis_start_of_fx_graphrË  ¸  s   € à”4œ˜UŸ[™[Ó)Ó*Ð*Ð*r<   z6(?<!_)(_$|_[.]|(\b|_)(set|enter|exit|seed)(\b|_))(?!_)c                óÞ   — | j                   dk7  ry| t        j                  j                  j                  j
                  t        j                  j                  j                  j
                  fv S )NÚinductorF)rÜ  r[   ÚopsrÍ  Úaccumulate_grad_ÚdefaultÚresize_storage_bytes_)r7  s    r9   Ú"fixme_incorrect_inductor_schema_oprÒ  Â  sW   € Ø	‡|�|�zÒ!Øð Ü�	‰	×Ñ×+Ñ+×3Ñ3Ü�	‰	×Ñ×0Ñ0×8Ñ8ðð ð r<   c                óª  — t        | j                  t        j                  j                  «      r5t        | j                  «      s | j                  j                  j                  S t        | j                  t        j                  j                  j                  «      ry| j                  dk(  rAt        | j                  «      sJ ‚t        j                  | j                  j                  «      rLy| j                  dk(  r<t        | j                  t         «      sJ ‚t        j                  | j                  «      ry| j"                  j%                  d«      d uS )NFr›  TrŸ  Úout)r¶   r  r[   r3  r<  rÒ  Ú_schemaÚ
is_mutableÚ_higher_order_opsÚauto_functionalizeÚAutoFunctionalizedr7  r2  Ú_mutation_op_reÚsearchr1   r0   r8   rj   r-  s    r9   Úis_mutation_oprÜ  Î  sí   € ÜØ�‰”U—Z‘Z×*Ñ*ôä0°·±Ô=Ø�{‰{×"Ñ"×-Ñ-Ð-Ü	Ø�‰”U×,Ñ,×?Ñ?×RÑRô
ð Ø‡w�w�/Ò!Ü˜Ÿ™Ô$Ð$Ð$Ü×!Ñ! $§+¡+×"6Ñ"6Ô7ØØ	�‰�MÒ	!Ü˜$Ÿ+™+¤sÔ+Ð+Ð+Ü×!Ñ! $§+¡+Ô.ØØ�;‰;�?‰?˜5Ó!¨Ð-Ð-r<   c                ó€   — d| j                   v sJ ‚d|j                   v sJ ‚| j                   d   |j                   d   k(  S ©NÚmutation_region_idr°   )r“  r”  s     r9   Úsame_mutation_regionsrà  â  sE   € Ø 1§6¡6Ñ)Ð)Ð)Ø 1§6¡6Ñ)Ð)Ð)Ø�6‰6Ð&Ñ'¨1¯6©6Ð2FÑ+GÑGÐGr<   c                ó,  — |}d|j                   vr3t        | |«      s'|j                  }d|j                   vrt        | |«      sŒ'|j                   j                  dd«      }||ur0|j                  }t        |«      r|dz  }||j                   d<   ||urŒ0|S )Nrß  r   r+   )ro   rË  Úprevrj   r¤   rÜ  )r‡   rä   r›   rß  s       r9   Úget_mutation_region_idrã  è  s™   € Ø€AØ
 a§f¡fÑ
,Ô5IÈ%ÐQRÔ5SØ�F‰Fˆð  a§f¡fÑ
,Ô5IÈ%ÐQRÕ5SàŸ™Ÿ™Ð$8¸!Ó<ÐØ
�4‰-Ø�F‰FˆÜ˜!ÔØ !Ñ#ÐØ'9ˆ�‰Ð#Ñ$ð	 �4Š-ð
 Ðr<   c                óV   — dt        t        | j                  «      «      j                  vS rÞ  )r¤   rÊ  r}   ro   rð   s    r9   Ú"should_compute_mutation_region_idsrå  õ  s!   € Ø¤t¬D°·±Ó,=Ó'>×'CÑ'CÐCÐCr<   c                óh   — d}| j                   D ]!  }t        |«      r|dz  }||j                  d<   Œ# y )Nr   r+   rß  )r}   rÜ  ro   )r‡   rß  Únds      r9   Úcompute_mutation_region_idsrè  ù  s=   € ØÐØ�k‰kò ;ˆÜ˜"ÔØ !Ñ#ÐØ(:ˆ�‰Ð$Ò%ñ;r<   c                  óB   ‡ — e Zd Z	 d	 	 	 dˆ fd„Zdd„Zdd„Zd	d„Zˆ xZS )
r  c                ó€   •— t         ‰| �  «        t        t        «      | _        || _        t        t        «      | _        y r3   )rƒ   rR   r   r„   Úpatternsrs   rO  )r6   rs   r…   s     €r9   rR   zPatternMatcherPass.__init__  s:   ø€ ô 	‰ÑÔô œÓð 	Œð #ˆŒô >IÌÓ=NˆÕr<   c                ó    — | j                   |   S r3   )rë  )r6   Úitems     r9   rô  zPatternMatcherPass.__getitem__  s   € Ø�}‰}˜TÑ"Ð"r<   c                óŽ  — | j                   syt        |t        j                  j                  «      r|j
                  }nJt        |t        j                  j                  «      r|}|j                  }nt        dt        |«      › �«      ‚t        |«      rt        |«       t        j                  t        |«      }d}g }d}| j                   D ]0  \  }}|dk(  rd}Œ|j                  |j!                  ||d¬«      «       Œ2 |r"|j                  |j!                  dd¬«      «       | j"                  �| j"                  nd}	t        |t        j                  j                  «      sJ ‚t%        ||	«      5  t'        t(        j*                  j-                  |«      d¬	«      D �]’  }
t/        |
«      }|
j0                  dk(  r|
j0                  |f| j                   vrŒ9t3        |
d¬
«      rŒG| j                   |
j0                  |f   D �]-  }|
j4                  r Œt|j6                  j9                  |
«      }t;        |«      r,t=        t?        tA        ||jB                  «      «      «      dk7  rŒdtD        jF                  jI                  d«      |
jJ                  k(  r-tL        jO                  d|
|
jP                  ||j6                  «       t;        |«      sŒÉ|jS                  |«      sŒÛ|dz  }|jU                  |||
«       tV        d   dxx   dz  cc<   tV        d   dxx   t=        |jB                  «      z  cc<   �Œ0 �Œ• 	 d d d «       |S # 1 sw Y   |S xY w)Nr   zJThe input to PatternMatcherPass must be a GraphModule or a Graph, but got Fr£  T)r7  r  Úsort)r7  rï  r�  )Úreverse)Úallow_cpu_inputsr+   Ú!TORCHINDUCTOR_PATTERN_MATCH_DEBUGz
%s%s %s %srÍ  Úpattern_matcher_countÚpattern_matcher_nodes),rë  r¶   r[   r\   r<  r‡   ÚGraphÚowning_modulerÑ   rd  rå  rè  rº   r»   rã  rl   Ú
find_nodesrs   r    ÚsortedrW  rX  Úfrom_iterablerI  r7  r-   r˜   ry   rå   rÜ   r¾   r!   rv  r}   rª  r«  rj   r  rC  r®  r7   rú  rý  r   )r6   r…  r‡   Úget_mutation_region_id_partialr�  r}   Úhas_call_moduler7  r  rs   rä   ÚentryrÛ   s                r9   rý  zPatternMatcherPass.apply  sÖ  € Ø�}Š}ØÜ�bœ%Ÿ(™(×.Ñ.Ô/Ø—H‘H‰EÜ˜œEŸH™HŸN™NÔ+ØˆEØ×$Ñ$‰BäØ\Ô]aÐbdÓ]eÐ\fÐgóð ô .¨eÔ4Ü'¨Ô.Ü)2×):Ñ):Ü" Eó*
Ð&ð ˆØˆØˆØŸ-™-ò 	Q‰JˆB�Ø�]Ò"Ø"&‘à—‘˜U×-Ñ-°¸FÈÐ-ÓOÕPð		Qñ
 Ø�L‰L˜×)Ñ)¨]ÀÐ)ÓGÔHØ&*§n¡nÐ&@�D—N’NÐFWˆ	Ü˜"œeŸh™h×2Ñ2Ô3Ð3Ð3Ü# B¨	Ó2ñ  	VÜœyŸ™×<Ñ<¸UÓCÈTÔRó V�Ü'¨Ó-�Ø—7‘7˜mÒ+ØŸ™ Ð(°·±Ñ=Ø ô
 9¸ÐPUÕVØà!Ÿ]™]¨D¯G©G°VÐ+<Ñ=ó V�EØ—|’|ÙØŸ™×+Ñ+¨DÓ1�Aô ! œÜÜ&¤sÐ+IÈ1Ï7É7Ó'SÓTóð òð
 !Ü—z‘z—~‘~Ð&IÓJÈdÏiÉiÒWÜŸ™ L°$¸¿	¹	À1ÀeÇmÁmÔTÜ •{ u×'8Ñ'8¸Õ';Ø ™
˜ØŸ™ A u¨dÔ3Ü  Ñ,Ð-DÓEÈÑJÓEÜ  Ñ,Ð-DÓEÌÈQÏWÉWËÑUÕEò'VñV÷ 	VðB ˆ÷C 	VðB ˆús   Å.EL:ËL:ËAL:Ì:Mc                ó8   — | j                   j                  «        y r3   )rë  ÚclearrQ   s    r9   rþ  zPatternMatcherPass.clearU  s   € Ø�‰×ÑÕr<   r3   )rs   úOptional[str]r>   rT   )rí  rõ  r>   rö  )r…  ú+Union[torch.fx.GraphModule, torch.fx.Graph]r>   rµ  rS   )r1   r?   r@   rR   rô  rý  rþ  rË   rÌ   s   @r9   r  r    s2   ø„ ð $(ðOà ðOð 
õOó #ó>÷@r<   r  c                 ó   — t         ‚r3   rE  r”   s     r9   Ú_not_implementedr  Y  s   € Ü
Ðr<   c                ó  ‡‡‡‡	‡
‡— |xs i }|j                  «       D ��ci c]  \  }}||“Œ
 c}}Š
t        ‰
«      t        |«      k(  sJ ‚	 d	 	 	 	 	 dˆˆ
fd„Št        j                  «       Š	 G ˆˆ	ˆˆˆfd„dt        j
                  j                  «      }t        | t        j
                  j                  «      sJ ‚ || «      j                  «       }t        |t        «      st        t        j                  |«      «      S |S c c}}w )z–
    Convert an FX graph into a PatternExpr.  This is useful for simple
    patterns that can only match single functions and fixed-length lists.
    c                óî   •— |�|n‰}t        | t        t        f«      r| ‰v rt        ‰|    «      S t	        | «      |v r
t        «       S t        | t        «      rt        d„ | D «       «      r| r
t        «       S | S )Nc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr3   )r¶   r  )r`   Úys     r9   rc   z5fx_to_pattern.<locals>.process_arg.<locals>.<genexpr>x  s   è ø€ Ò&IÀ!¤z°!´W×'=Ñ&Iùs   ‚)r¶   r¶  rµ  r  rd  r  r„   r—  )rU  Úignore_types_overrideÚcurrent_ignore_typesr´  Úinv_scalar_workarounds      €€r9   Úprocess_argz"fx_to_pattern.<locals>.process_argn  sy   ø€ ð &;Ð%FÑ!ÈLð 	ô �aœ%¤˜Ô&¨1Ð0EÑ+EÜÐ3°AÑ6Ó7Ð7Ü�‹7Ð*Ñ*Ü“9ÐÜ�aœÔ¤3Ñ&IÀqÔ&IÔ#IÉaÜ“9ÐØˆr<   c                  ól   •‡ — e Zd ZeZeZeZ	 	 	 	 	 	 	 	 dˆˆˆfd„Z	 	 	 	 	 	 	 	 dˆˆfd„Zdˆ fd„Z	ˆ xZ
S )ú fx_to_pattern.<locals>.Converterc                óØ   •— t        ‰«      }|t        ‰«      k  r‰|   }n1‰r|j                  d«      sJ ‚|}nt        j                  dd|«      }|}|‰v rt        |«      S t        |«      S )NÚtangentz_\d+$r@  )r¤   r¾   Ú
startswithÚreÚsubr%  r  )	r6   r  r7   r8   r›   r  r^  Úargnumr_  s	         €€€r9   r  z,fx_to_pattern.<locals>.Converter.placeholderƒ  su   ø€ ô �V“ˆAØ”3�x“=Ò Ø ‘{‘ÙØ×(Ñ(¨Ô3Ð3Ð3Ø‘äŸ™ ¨"¨fÓ5�Ø�ØÐ*Ñ*Ü*¨4Ó0Ð0ä! $Ó'Ð'r<   c                ób  •— ‰	}|t         j                  k(  rt        d„ ‰D «       «      f	 	 	 	 	 dˆ	fd„}|}t        j                  |||f«      \  }}t
        ‰v r>|D �cg c]
  } ||«      ‘Œ }}|j                  «       D ��ci c]  \  }}| ||«      “Œ }}}t        |g|¢­i |¤ŽS c c}w c c}}w )Nc              3  ó2   K  — | ]  }|t         usŒ|–— Œ y ­wr3   )rµ  )r`   Úts     r9   rc   zAfx_to_pattern.<locals>.Converter.call_function.<locals>.<genexpr>£  s   è ø€ ò QØ°1¼C²<œñQùs   ‚�c                ó   •—  ‰| |«      S r3   r4   )rU  r  r
  s     €r9   Úprocess_arg_fn_implzKfx_to_pattern.<locals>.Converter.call_function.<locals>.process_arg_fn_impl¡  s   ø€ ñ ' qÐ*?Ó@Ð@r<   ©rU  rK   r  zOptional[Sequence[type[Any]]]r>   zUnion[T, KeywordArg, Ignored])r;  r,  r�   ri  rj  r„   rp   rš  )
r6   r  r7   r8   Úprocess_arg_fnr  r“  ra   r´  r
  s
           €€r9   r›  z.fx_to_pattern.<locals>.Converter.call_function—  sÚ   ø€ ð )ˆNàœ×)Ñ)Ò)ô LQñ QØ#/ôQó LðAØðAà+HðAð
 3õAð "5�ä!Ÿ?™?¨>¸DÀ&¸>ÓJ‰LˆD�&Ü�|Ñ#à37Ö8¨a™ qÕ)Ð8�Ð8Ø;A¿<¹<»>×J±4°1°a˜!™^¨AÓ.Ñ.ÐJ�ÑJÜ Ð8¨Ò8°Ñ8Ð8ùò 9ùÛJs   ÁB&ÂB+c                ól  •— t         ‰| �  |«      }|j                  dk(  rzt        |t        «      rj|j
                  d   }t        |t        «      sJ ‚t        |«      t        |«      k(  sJ ‚t        ||«      D ]  \  }}t        |j                  «      |_	        Œ! |S t        |j                  «      |_	        |S )NrÄ  r   )
rƒ   r  r7  r¶   r�   r7   r   r¾   r€  r™   )r6   r›   Úrvr7   Úrr±   r…   s         €r9   r  z)fx_to_pattern.<locals>.Converter.run_node²  sŸ   ø€ Ü‘Ñ! !Ó$ˆBØ�t‰t�xÒ¤J¨r´5Ô$9Ø—v‘v˜a‘y�Ü! $¬
Ô3Ð3Ð3Ü˜2“w¤# d£)Ò+Ð+Ð+Ü! " d›mò -‘F�A�sÜ! #§)¡)›n�A•Gð-ð ˆIô ˜qŸw™w›<�”ØˆIr<   )r  r0   r7   rÆ   r8   úMapping[str, Any]r>   z&Union[ExclusiveKeywordArg, KeywordArg])r  r0   r7   rÆ   r8   r  r>   rx   )r›   rÅ   r>   r   )r1   r?   r@   r  rŸ  r£  r!  r  r›  r  rË   )r…   r^  r  r_  r´  r
  s   @€€€€€r9   Ú	Converterr  ~  sr   ù„ Ø&ˆØ&ˆØ#ˆð	(àð	(ð  ð	(ð &ð		(ð
 4÷	(ð(	9àð	9ð  ð	9ð &ð		9ð
 ö	9÷6
	ñ 
	r<   r  r3   r  )rp   r¾   rW  r�  r[   r\   r8  r¶   r<  rå  rx   r¿  ri  Útree_leaves)r…  r´  r^  r`  r_  ra   rb   r  ry   r  r	  r
  s    `` `    @@@r9   rk  rk  ]  sô   ý€ ð *Ò/¨RÐØ.?×.EÑ.EÓ.G×H¡d a¨˜Q ™TÓHÐÜÐ$Ó%¬Ð->Ó)?Ò?Ð?Ð?ð FJðØðØ%Bðà	&öô �_‰_Ó€F÷>ò >”E—H‘H×(Ñ(ô >ô@ �bœ%Ÿ(™(×.Ñ.Ô/Ð/Ð/Ù˜‹m×ÑÓ!€GÜ�gœ{Ô+Ü!¤&×"4Ñ"4°WÓ"=Ó>Ð>Ø€Nùóo Is    DT)r¬   Úget_decomp_fnc               ó  — t        «       5  |� |«       n	t        «       } t        | |d¬«      |Ž }ddd«       ddlm} |r, |j
                  «       |j
                  j                  «        j                  «        |S # 1 sw Y   ŒOxY w)z>Build a normalized inference graph, for use with fx_to_patternNÚreal)Útracing_moder+   ©Úremove_noop_ops)r   r,   r   Úfx_passes.post_gradr%  r‡   Úeliminate_dead_codeÚ	recompile)rI   r7   r¬   r   Údecompositionsr…  r%  s          r9   r¼   r¼   Å  s�   € ô 
"Ó	#ñ Eà,Ð8‰MŒOÔ>QÓ>Sð 	ð >ŒW�R˜°fÔ=¸tÐDˆ÷	Eõ 5áÙ˜Ÿ™Ô!Ø
�‰×$Ñ$Ô&à‡L�L„NØ€I÷Eð Eús   ‹%A>Á>Bc           
     ó  ‡— dŠ	 	 	 	 	 	 	 	 dˆfd„}t         j                  j                  d«      5   t        | d„ |t	        «       dd¬«      |Ž  ddd«       ‰sJ ‚ddlm}  |‰j                  «       dd	lm	} t        «       }t        t         j                  j                  j                  j                  t!        d
«      t!        d«      «      }t#        ||t$        ¬«      j'                  |j(                  «       |j+                  ‰j                  «       t         j,                  j                  j/                  «       ‰j                  _        ‰j                  j3                  «        ‰j5                  «        ‰S # 1 sw Y   �Œ*xY w)z=Build a normalized training graph, for use with fx_to_patternNc                ó<   •— ‰rJ ‚t        | «      Št        | |fi |¤ŽS r3   )Úclone_graphr'   )Újoint_graphÚinputsr8   r…  s      €r9   Úrecord_joint_graphz)joint_fwd_bwd.<locals>.record_joint_graphä  s(   ø€ ñ ˆˆvÜ˜Ó%ˆÜ  ¨fÑ?¸Ñ?Ð?r<   c                ó   — t        | «      S r3   )r&   )Úgr…  s     r9   r²   zjoint_fwd_bwd.<locals>.<lambda>ï  s   € œ¨Ó+€ r<   TF)Úpartition_fnr)  Úkeep_inference_input_mutationsÚ
enable_logr+   r$  )Úpointless_viewr±   re  )ry   r
  rú  )r-  rJ   r.  rÆ   r8   r   r>   z1tuple[torch.fx.GraphModule, torch.fx.GraphModule])r[   Ú_guardsÚtracingr%   r,   r&  r%  r‡   Úfx_passes.joint_graphr5  r  rš  rÎ  ÚatenÚviewrÐ  r  r  rA  r  rë  rý  r\   ÚCodeGenÚ_codegenr'  r(  )rI   r7   r/  r%  r5  Úmatcher_passry   r…  s          @r9   r  r  ß  sJ  ø€ ð *.€Bð@Ø)ð@Ø3@ð@ØLOð@à	:õ@ô 
�‰×	Ñ	˜tÓ	$ñ ð	
ŒØÙ+Ø+Ü.Ó0Ø+/Øô	
ð ñ	÷ñ €Iˆ2å4á�B—H‘HÔå5ä%Ó'€LäÜ�	‰	�‰×Ñ×#Ñ#¤Z°Ó%6¼
À6Ó8Jó€Gô Ø ¼\ôç�hˆ|×$Ñ$Ô%Ø×Ñ�r—x‘xÔ ô Ÿ™Ÿ™×.Ñ.Ó0€B‡H�HÔØ‡H�H× Ñ Ô"Ø‡L�L„NØ€I÷?ñ ús   ±E7Å7Fc                óŠ   — g }t         j                  j                  | j                  | j                  f|j
                  «       |S r3   )r[   r\   r½   r7   r8   rl   )r›   r7   s     r9   r‚  r‚    s1   € Ø)+€DÜ	‡H�H×Ñ�a—f‘f˜aŸh™hÐ'¨¯©Ô5Ø€Kr<   c                óT  — t        t        | j                  «      «      }t        t        j
                  j                     «       }t        t         «      }d }|r¨|j                  «       }t        |«      D �cg c]	  }||vsŒ|‘Œ }}|r||d      j                  |«       n^|j                  |«       |r|j                  |ur|j                  |«       |}|j                  t        |j                  |d«      «      «       |rŒ¨|s!t        |«      t        | j                  «      k(  sJ ‚y c c}w )Nr  r4   )r„   r—   r}   r!   r[   r\   rH  r   rÕ  r‚  rl   r�  r¤   r‹   r¾   )r‡   ÚpendingÚreadyÚwaitingÚcursorrä   rU  Úwaiting_fors           r9   Ústable_topological_sortrE    sý   € ô ”8˜EŸK™KÓ(Ó)€Gô ”u—x‘x—}‘}Ñ%Ó'€Eô œ$Ó€Gð €FÙ
Ø�{‰{‹}ˆÜ"'¨£+Ö@˜Q°¸%²’qÐ@ˆÐ@Ùð �K ‘OÑ$×+Ñ+¨DÕ1à�I‰I�dŒOÙ˜&Ÿ+™+¨TÑ1Ø—‘˜dÔ#ØˆFð �N‰Nœ8 G§K¡K°°bÓ$9Ó:Ô;ò ñ  œ3˜u›:¬¨U¯[©[Ó)9Ò9Ð9Ð9Ð9ùò As   Á4	D%Á>D%c                ót   ‡ — t        j                  d«      t        j                  ‰ «      dˆ fd„«       «       }|S )z0Wrapper around lazy init functions in fx_passes/Nc                 ó:  •— t         d   j                  «       } t        j                  j	                  d «      5  t        «       5  t        «       5   ‰«       }d d d «       d d d «       d d d «       | t         d<   S # 1 sw Y   Œ$xY w# 1 sw Y   Œ(xY w# 1 sw Y   Œ,xY w)NrÍ  )r   rk   r[   r6  r7  r   r)   )Úcounters_refr  rI   s     €r9   Ú	lazy_initz%init_once_fakemode.<locals>.lazy_init;  sŒ   ø€ ô   
Ñ+×0Ñ0Ó2ˆä�]‰]×"Ñ" 4Ó(ñ 	Ô*@Ó*Bñ 	ÄNÓDTñ 	Ù“TˆF÷	÷ 	÷ 	ð  ,Œ�Ñàˆ÷	ð 	ú÷ 	ð 	ú÷ 	ð 	ús;   ¸BÁBÁA9ÁBÁBÁ9BÁ>BÂB	Â
BÂB)r>   r   )rº   rð  r  )rI   rI  s   ` r9   Úinit_once_fakemoderJ  8  s;   ø€ ô ×Ñ˜ÓÜ‡_�_�RÓô	ó ó ð	ð Ðr<   c                ó   ‡ — dˆ fd„}|S )z2Function for extra_check to put pass behind a flagc                ó$   •— t        t        ‰«      S r3   )r0  r$   )rå   r  s    €r9   Ú
flag_checkzconfig_flag.<locals>.flag_checkN  s   ø€ Ü”v˜tÓ$Ð$r<   )rå   rw   r>   r   r4   )r  rM  s   ` r9   Úconfig_flagrN  K  s   ø€ õ%ð Ðr<   c                óL   —  G d„ dt         «      } || «      j                  «       S )Nc                  ó    ‡ — e Zd Zdˆ fd„Zˆ xZS )úclone_graph.<locals>.CopyGraphc                óJ  •— t         ‰| �  |«      }t        |t        j                  j
                  «      rn|j                  j                  j                  |j                  «       | j                  j                  j                  |j                  d «      |j                  _        |S r3   )rƒ   r  r¶   r[   r\   ÚProxyrä   ro   rn   Ú	new_graphÚ_graph_namespacerë  r  )r6   rr   rq  r…   s      €r9   r  z'clone_graph.<locals>.CopyGraph.run_nodeV  sq   ø€ Ü‘wÑ'¨Ó1ˆHÜ˜(¤E§H¡H§N¡NÔ3Ø—‘×"Ñ"×)Ñ)¨(¯-©-Ô8Ø%)§^¡^×%DÑ%D×%PÑ%PØ—M‘M 4ó&�—‘Ô"ð ˆOr<   )rr   rÅ   r>   rÅ   )r1   r?   r@   r  rË   rÌ   s   @r9   Ú	CopyGraphrQ  U  s   ø„ ÷	ñ 	r<   rV  )r*   Ú	transform)Úinput_graphrV  s     r9   r,  r,  T  s$   € ô”Kô ñ �[Ó!×+Ñ+Ó-Ð-r<   c                óŒ   — t        | j                  «      |kD  r| j                  |   S |€y | j                  j                  |«      S r3   )r¾   r7   r8   rj   )rä   Ú
arg_numberÚ
kwarg_names      r9   Úget_arg_valuer\  f  s?   € ô ˆ4�9‰9ƒ~˜
Ò"Ø�y‰y˜Ñ$Ð$Ø	Ð	Øà�{‰{�‰˜zÓ*Ð*r<   c           	     ó  — |g}t        |t        j                  j                  «      r7|j	                  |j                  «       D �cg c]  }t        ||«      ‘Œ c}«       | D �cg c]  }|j                  |v sŒ|‘Œ c}S c c}w c c}w r3   )r¶   r[   r3  r4  r‹   r5  r0  r  )r}   rI   r,  r1  rä   s        r9   Úfilter_nodesr^  q  sf   € Øˆ$€CÜ�"”e—j‘j×1Ñ1Ô2Ø�
‰
¸"¿,¹,».ÖI¨h”G˜B Õ)ÒIÔJà"Ö9�T d§k¡k°SÒ&8ŠDÒ9Ð9ùò Jùâ9s   ÁA>Á#BÁ7Bc                óØ   — | j                   dk(  rPt        | j                  t        «      sJ ‚t	        | j
                  j                  | j                  «      j                  S | j                  S )z©For call_function and call_method, we directly use the target function;
    For call_module, the target is string, and we treat the module class
     as a function.
    r£  )r7  r¶   r  r0   r   r‡   rö  r…   r-  s    r9   rI  rI  y  sO   € ð
 ‡w�w�-ÒÜ˜$Ÿ+™+¤sÔ+Ð+Ð+Ü˜Ÿ™×1Ñ1°4·;±;Ó?×IÑIÐIØ�;‰;Ðr<   )r@  )rq   r{   rr   rÅ   rs   r0   r>   rT   )rÛ   rê   r>   zTypeIs[Match]r{  )rE  r	  rò   rÑ   r>   rT   r½  )
ry   rx   r‡   zOptional[torch.fx.Graph]rO  zdict[str, list[Optional[str]]]rP  rÈ   r>   rÈ   )rE  r/   rt  rC   r„  úIterable[Any]rÀ   rG   r  r  rú  rù  r`  ú)Union[dict[str, Union[float, int]], None]r_  úSequence[str]ru  zUnion[PatternExpr, None]rP  rÈ   r>   rÈ   )rŸ  r0   rE  r/   r„  rÆ   rÀ   rG   r`  ra  r>   rx   )rŸ  r0   rE  r/   rt  rC   r„  r`  rÀ   rG   r  r  rú  rù  r`  ra  r_  rb  rP  rÈ   r>   rT   )Nr4   )rE  r/   r„  rÆ   rÀ   rG   r`  ra  r_  rb  r>   z(tuple[PatternExpr, torch.fx.GraphModule])rE  r/   r„  rÆ   rÀ   rG   r`  ra  r_  rb  r>   rx   )
ry   rx   rú  rù  rÁ  rò  r   rÈ   r>   z2Callable[[Callable[..., Any]], Callable[..., Any]])r‡   rÃ   rä   rÅ   r>   rÈ   )r7  ztorch._ops.OpOverloadr>   rÈ   rN  )r“  rÅ   r”  rÅ   r>   rÈ   )r‡   rÃ   rä   rÅ   r>   rµ  )r‡   rÃ   r>   rÈ   )r‡   rÃ   r>   rT   )r7   r   r8   r   r>   r   )r4   r4   Nr4   )r…  r   r´  zSequence[type[Any]]r^  rb  r`  ra  r_  rb  r>   rx   )
rI   r	  r7   rÆ   r¬   rÈ   r   zOptional[Callable[..., Any]]r>   rJ   )rI   r	  r7   rÆ   r>   rJ   )r›   rÅ   r>   zlist[torch.fx.node.Argument])rI   r	  r>   zCallable[[], Any])r  r0   r>   zCallable[[Match], Any])rX  rJ   r>   rJ   r3   )rä   rÅ   rZ  rµ  r[  rÿ  r>   r   )r}   zIterable[torch.fx.Node]rI   r   r>   r|   )rä   rÅ   r>   ztorch.fx.node.Target)²rÉ   Ú
__future__r   r¸   Údataclassesrº   r¬  r|  rW  Úloggingr;  rª  r  r‹  r  Úabcr   r   Úcollectionsr   Úcollections.abcr   r   r	   r
   r   Úpathlibr   r   r   r   r   r   r   r   Útyping_extensionsr   r   r[   Útorch._guardsÚtorch.fxÚtorch.utils._pytreerb  Ú_pytreeri  Útorch._dispatch.pythonr   Útorch._dynamo.utilsr   Útorch._prims_commonr   Útorch._subclasses.fake_tensorr   Ú"torch.fx.experimental.proxy_tensorr   Ú%torch.fx.experimental.symbolic_shapesr   Útorch.fx.graph_moduler   Útorch.fx.immutable_collectionsr   r   Ú(torch.fx.passes.graph_transform_observerr    Útorch.utils._ordered_setr!   Ú
_functorchr$   r�  Ú_functorch.aot_autogradr%   r&   Ú_functorch.partitionersr'   Ú_subclassesr(   r)   r\   r*   r@  Údecompositionr,   Úloweringr-   Ú	getLoggerr1   rC  rÎ  r9  ÚprimsÚConstantrH  ré   r/   rC   rG   rK   rä   ÚTargetr0   ÚFnsTyperM   rO   ru   rw   rÑ   rŠ   rê   rÜ   r   rx   r  r  r  r%  r+  r�   Ú_SimpleSpecrP  rš  rž  r¢  r¥  rª  r­  r°  r²  r¿  rÐ  r  rò  Ú	dataclassrø  r  r  r§   rA  rF  rS  r‡  rœ  r¤  Ú__file__Úparentr˜  r§  rA   r²  r‚  rƒ  r›  rÅ  rÈ  rË  ÚcompilerÚ  rÒ  rÜ  rà  rã  rå  rè  r  r  rk  Úno_gradr¼   Úenable_gradr  r‚  rE  rJ  rN  r,  Ú_seen_patternsr\  r^  rI  r4   r<   r9   ú<module>rŒ     s¬  ðò!õF #ã Û Û Û Û Û Û Û Û 	Û 	Û Û ß #Ý #ß NÕ NÝ ß N× NÑ Nß *ã Û Û ß $Ð $Ý ;Ý (Ý 0Ý @Ý 6Ý GÝ +ß IÝ KÝ /å 3ß CÝ 7ß 4Ý Ý Ý .Ý ;ð €g×Ñ˜Ó!€Ø‡y�y‡~�~€Ø�	‰	�‰€à€Ø�x §¡§¡Ð.Ñ/€ô>ˆxô >ô>�ô >ô#ˆhô #ñ ˆCƒL€ð �—‘—‘×$Ñ$ cÐ)Ñ
*€÷?ñ ?ñ ‹:€ð IKð
Øð
Ø(5ð
ØBEð
à	ó
÷4ñ ôD�,ô ð8 �E˜;Ð&Ñ'€ó÷'
ñ '
ôT 1�#ô  1ôF-ˆ+ô -ôˆkô ôE�ô Eô(E˜+ô Eô4O
�+ô O
ðd �C˜�H‰o€ôl
�kô l
ô^�?ô ô�ô ô�ô ô˜ô ô(Ð,ô ôÐ*ô ôÐ*ô ô,
ˆ[ô ,
ô^F
˜ô F
ôR#
�;ô #
÷L4ñ 4ôn!�Xô !ð ×Ò÷:ð :ó ð:ð: ×Òô
˜<ó 
ó ð
ð ×Òô	=˜ó 	=ó ð	=ð ×Òôi
˜ló i
ó ði
óXóð "ð	'Øð'à#ð'ð 2ð'ð ð	'ð
 
ó'ð` ,8ØCGØ)+Ø26Ø!ðØðàðð "ðð ð	ð
 @ðð )ðð Aðð 'ðð 0ðð ðð 
óðD '�z #‘Ó(Ð ðGØðGàðGð "ðGð ð	Gð
 AðGð óGñT ˜x›.×/Ò/°+Ñ=Ð@UÑUÐ ð ð ð ó ð$ ,8ØCGØ)+Ø!ð5Øð5àð5ð ð5ð "ð	5ð
 ð5ð @ð5ð )ð5ð Að5ð 'ð5ð ð5ð 
ó5ðp Ð×Ò¨eÔ4ð
 DHØ)+ðØðà!ðð ðð Að	ð
 'ðð .òó 5ððL DHØ)+ð		Øð		à!ð		ð ð		ð Að			ð
 'ð		ð ó		ð ,8ðð
 ñØðà(ðð ð	ð
 ðð 8óð4 ,8ðð
 ñØðà(ðð ð	ð
 ðð 8óó,+ð �"—*’*ÐVÓW€ó	ó.ó(Hó
óDó;÷Uñ Uópð )+Ø ØCGØ)+ðeØ3ðeà%ðeð ðeð Að	eð
 'ðeð óeðP €‡‚ƒð
 #'Ø26ñØðà
ðð  ð	ð
 0ðð òó ðð2 €×ÒÓò+ó ð+ó\ó!:óHó&ó.ð !�˜C‘Ó"€ð GKð+Ø
ð+Ø%(ð+Ø6Cð+àó+ó:ôr<   