Ti^%SrSSKJr SSKrSSKrSSKrSSKrSSKJr SSK J r J r J r J r JrJrJrJr SSKJs Jr SSKJr \"S5r"SS \\5r"S S \R2\\5r"S S \5r"SS\5r"SS\\R<5r"SS\5r \\!\"\\\!\\"\\4r#"SS\5r$S6Sjr%"SS5r&\&"S5r'\&"\"S55r("SS5r)S7Sjr*\'q+S\,S'\RZS8Sj5r."S S!5r/"S"S#5r0"S$S%\/5r1"S&S'\/5r2"S(S)\/5r3\3"5r4"S*S+\/5r5"S,S-\/5r6"S.S/\/5r7S9S:S0jjr8S;S1jr9SzDThe Pattern IR: used to describe (source) patterns of rewrite rules.) annotationsN)Mapping)AnyCallableIterableIteratorProtocolSequenceTypeVarUnion)irTc"\rSrSrSrSSjrSrg)Patternz_This is essentially a Predicate[T], that is, a Callable[[T], bool] bound to the name "matches".cgNselfitems ^/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/rewriter/_pattern_ir.pymatchesPattern.matches srN)rrreturnbool)__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__rrrrrsi+rrch\rSrSrSr\R SSj5r\R SSj5rSr g) StringPattern#z(Abstract base class for string patterns.cgrrrs rrStringPattern.matches& rcgrrrs r__str__StringPattern.__str__*r)rrNrstrrrrr/) rrr r!r"abcabstractmethodrr,r#rrrr%r%#s72     rr%c@\rSrSrSrS SjrS SjrS SjrS SjrSr g) StringConstantPattern/z!Matches strings with given value.cXlgr_valuervalues r__init__StringConstantPattern.__init__2 rcXR:H$rr7rs rrStringConstantPattern.matches5s{{""rcUR$rr7r+s rr,StringConstantPattern.__str__8 {{rcUR$rr7r+s rr:StringConstantPattern.value;rBrr7N)r:r/r.r0) rrr r!r"r;rr,r:r#rrrr4r4/s+#rr4c6\rSrSrSrSSjrS SjrS SjrSrg) PrefixPattern?z$Matches strings with a given prefix.cXlgrr7r9s rr;PrefixPattern.__init__Br=rc8URUR5$r) startswithr8r9s rrPrefixPattern.matchesEs ,,rc URS3$)N*r7r+s rr,PrefixPattern.__str__Hs++a  rr7N)r:r/rNone)r:r/rrr0) rrr r!r"r;rr,r#rrrrFrF?s.-!rrFcf\rSrSrSrSS.S Sjjr\S Sj5r\SSj5rSSjr SS jr S r g ) AttrPatternLzLBase class for an attribute pattern. Matches any attribute value by default.Fcan_match_nonecXlX lgr)_name_can_match_none)rnamerUs rr;AttrPattern.__init__Os  -rcUR$rrWr+s rrYAttrPattern.nameS zzrcUR$)z:Indicates whether this pattern can match a None attribute.rXr+s rrUAttrPattern.can_match_noneW###rcg)NTrrattrs rrAttrPattern.matches\rcbURb UR$S[[U55-$Nz anonymous:rWr/idr+s rr,AttrPattern.__str___'!ZZ3tzzUBtH 9UUr)rXrWNrY str | NonerUrrrorrrezir.Attrrrr0) rrr r!r"r;propertyrYrUrr,r#rrrrRrRLs@VCH.$$VrrRc8^\rSrSrSrSS.SU4SjjjrSrU=r$)AttrVarczERepresents a pattern variable used to match against attribute values.FrTc >[TU]XS9 g)NrTsuperr;)rrYrU __class__s rr;AttrVar.__init__fs =rrrn)rrr r!r"r;r# __classcell__rzs@rrurucsOCH>>>rrucD^\rSrSrSrSU4SjjrSSjrS SjrSrU=r $) AttrConstantPatternuzMatches attributes with given value. Uses standard equality for matching. For list-valued attributes, the order of elements matters. If order is immaterial, we need to define a separate pattern for that. c0>[TU]S5 Xlgr)ryr;r8)rr:rzs rr;AttrConstantPattern.__init__|s  rc@UR[RR[RR[RR 1;a+[ UR5[ UR5:H$URUR:H$r) typer AttributeTypeINTSFLOATSSTRINGStupler:r8rds rrAttrConstantPattern.matchessr 99    ! !    # #    $ $  $dkk(:: :zzT[[((rc,[UR5$rr/r8r+s rr,AttrConstantPattern.__str__4;;rr7)r:SupportedAttrTypesrrr0) rrr r!r"r;rr,r#r|r}s@rrrus )  rrc[U[5(aU$[U[5(a6URb [ S5e[ UR URS9$[U[[[45(a [U5$[U[5(aO[SU55(a [U5$[SU55(a [U5$[ S5e[S[U5S35e)zhRepresents promotion of values allowed as keyword-arguments in a pattern-builder call to an AttrPattern.zDPattern variables used in attributes must not have check_method set.rTc3N# UHn[U[[45v M g7fr isinstanceintfloat.0is r #_to_attr_pattern..s:Eqz!c5\**E#%c3B# UHn[U[5v M g7fr)rr/rs rrrs15az!S!!5sz9Only lists of int/float/str can be used as an AttrPatternCannot convert z to AttrPattern)rrRVar check_method ValueErrorrurYrUrrr/rr all TypeErrorr)r:s r_to_attr_patternrs%%% %    )V uzz%2F2FGG%#uc*++"5))%"" :E: : :&u- - 151 1 1&u- -TUU od5k]/B CCrcb\rSrSrSrS S SjjrSSjrSSjrSSjrSSjr SSjr SS jr S r g )OpsetPatternBuilderaRepresents an opset pattern and a pattern builder. (i) It is used to create a NodePattern (via OpPatternBuilder). Example usage: :: z = op.Matmul(x, y) Here, `op` is an instance of OpsetPatternBuilder and `op.Matmul` is an instance of OpPatternBuilder, and `op.Matmul(x, y)` is an instance of NodePattern. (ii) It contains a domain pattern matched against the actual opset domain used in the input model. c|[U[5(a [U5nXlU(a/UlgSUlgr)rr/r4_domain_pattern_nodes)rdomainrecords rr;OpsetPatternBuilder.__init__s0 fc " "*62F% 46DKDKrcUR$r)rr+s rdomain_pattern"OpsetPatternBuilder.domain_patterns###rc[X5$r)OpPatternBuilder)rop_names r __getattr__OpsetPatternBuilder.__getattr__s ..rc,[U[U55$)z?This method is used to match against submodule ops with prefix.)rrF)rrYs r submoduleOpsetPatternBuilder.submodulesmD&9::rc,[UR5$r)r/rr+s rr,OpsetPatternBuilder.__str__s4''((rcVURbURRU5 ggr)rappend)rnodes radd_nodeOpsetPatternBuilder.add_nodes# ;; " KK  t $ #rcJURc [S5eUR$)NzNodes were not recorded.)rrr+s rnodesOpsetPatternBuilder.nodess" ;; 78 8{{r)rrN)F)rzStringPattern | strrrrrP)rr%)rr/rr)rYr/rrr0)r NodePatternrrP)rSequence[NodePattern]) rrr r!r"r;rrrr,rrr#rrrrrs* $/;)%rrz pkg.torchc`\rSrSrSrS SjrSSSSSSS.S SjjrSrg) raA utility class to build a NodePattern. It is used primarily to create a NodePattern. Example usage: :: z = op.Matmul(x, y) Here, `op` is an instance of OpsetPatternBuilder and `op.Matmul` is an instance of OpPatternBuilder, and `op.Matmul(x, y)` is an instance of NodePattern. cXlX lgr)pattern_builderr)rrrs rr;OpPatternBuilder.__init__s / rN)_domain_version_outputs_allow_other_attributes_allow_other_inputs_checkc Ub [S5eUcURR5n O,[U[5(a [ U5n O [ S5e[U[5(a[U5V s/sHn SPM nn O7[U[5(a[SU55(d [S5eUV s/sHn [U 5PM n n UR5V Vs0sHupU [U5_M nn n[U URU UUUUUS9nURR!U5 UR"n[%U5S:XaUS$U$s sn fs sn fs snn f)NzzThe pattern builder does not support '_version' keyword argument. Version restrictions should be handled by rewrite rules.z_domain must be a string.c3X# UH n[U[[S545v M" g7fr)rr/r)rxs rr,OpPatternBuilder.__call__.. s&; 6>Jq3T + , ,hs(*z,_outputs must be an int or a list[str|None].allow_other_attributesallow_other_inputscheckrr)rrrrr/r4rrranger r_to_value_patternitemsrrrroutputslen)rrrrrrrargskwargs opset_pattern_rinputsrYr: attributes node_pattern output_valuess r__call__OpPatternBuilder.__call__sk  K  ? 00??AM  % %1':M78 8 h $ $&+Ho6ooH6HHh//s; 6>; 8 8 KL L0451#A&5IOX d,U33 X"  LL   #:2   %%l3$,, }  " # # /7 6Xs; E!E&/E+)rr)rrrstr | Pattern[str]rrP) rrorz int | Nonerzint | list[str | None]r bool | NonerrrCallable | None)rrr r!r"r;rr#rrrrrs ,$  ##+,/3+/"&0!0! 0! ) 0! "- 0!)0! 0!0!rrcjUb[U[5(aU$[U[[45(a [ U5$[U[ 5(a-[ SU55(a [ U5$[S5e[U5(a [SUS9$[S[U5S35e)a/Promotes an input-value used to construct a NodePattern to a ValuePattern. Example usage: :: x = op.MatMul(a, b) z = op.Add(x, 0) In this example, `a, `b`, and `x` are ValuePatterns used to construct a NodePattern. `0` is a constant (int) value, and is automatically promoted to a ValuePattern. Note that this is a shorthand for creating a Constant pattern. The user can more explicitly write this as: :: z = op.Add(x, op.Constant(0)) If a callable is provided, it will be converted to a ValuePattern with the callable as the check attribute. Nc3N# UHn[U[[45v M g7frrrs rr$_to_value_pattern..?s6Aqz!c5\**Arz5Only lists of int/float can be used as a ValuePatternrrz to ValuePattern) r ValuePatternrrConstantr rrcallablerr)rs rrr&s( yJq,//!c5\""{!X 6A6 6 6A; PQQ{{D** od1gY.>? @@r_pattern_builderc#(# [nUqSv Uqg7fr)r)builder prev_builders rrrKs$L #sc\rSrSrSrSSS.SSjjrSSjr\SSj5r\SS j5r \SS j5r SS jr S S jr S!S jr S"SjrSrSrSrSrSrSrSrSrSrS"SjrSrg)#riTzBase class for all patterns that match against IR values. This is used primarily to provide operator overloadings for arithmetic operations, so that we can write patterns like `x + 1` and `1 + x`. NFrrUc6XlX lX0l/Ulgr)rWrrX_uses)rrYrrUs rr;ValuePattern.__init__[s  -46 rc@A[URURS9$)Nr)rrWrrnode_maps rcloneValuePattern.cloneds DJJdkk::rcUR$rr\r+s rrYValuePattern.namehr^rcUR$rrr+s rrValuePattern.check_methodl {{rcUR$)z7Indicates whether this variable can match a None input.r`r+s rrUValuePattern.can_match_noneprbrcgrrr+s rproducerValuePattern.producerurgrcUR$r)rr+s rusesValuePattern.usesxs zzrc<URRX45 gr)rr)rrindexs r append_useValuePattern.append_use{s 4-(rc$SUR<S3$)Nz ValuePattern()r\r+s r__repr__ValuePattern.__repr__~stzznA..rc,[RX5$rrAddrothers r__add__ValuePattern.__add__##D00rc,[RX5$rrrs r__radd__ValuePattern.__radd__##E00rc,[RX5$rrSubrs r__sub__ValuePattern.__sub__rrc,[RX5$rr#rs r__rsub__ValuePattern.__rsub__r!rc,[RX5$rrMulrs r__mul__ValuePattern.__mul__rrc,[RX5$rr+rs r__rmul__ValuePattern.__rmul__r!rc,[RX5$rrDivrs r __truediv__ValuePattern.__truediv__rrc,[RX5$rr3rs r __rtruediv__ValuePattern.__rtruediv__r!rc,[RX5$r)rPowrs r__pow__ValuePattern.__pow__rrcbURb UR$S[[U55-$rirjr+s rr,ValuePattern.__str__rmr)rXrrWrrYrorrrUrrrP)rdict[NodePattern, NodePattern]rrrprrrq)rzNodePattern | None)rz!Sequence[tuple[NodePattern, int]])rrrrr0)rrr r!r"r;rrsrYrrUr r rrrrr%r(r-r0r5r8r<r,r#rrrrrTs=AY^77*97RV7 7;$$)/111111111Vrrc\rSrSrSrSS.S SjjrSSjrSSjr\SSj5r \SS j5r SS jr SS jr S r g)riaRepresents a pattern that matches against a Node. This differs from a NodeOutputPattern in that it matches against a node (which may produce 1 or more outputs), whereas a NodeOutputPattern matches against a specific output of a node. Args: domain: pattern to match against the domain of the node. op: pattern or string constant to match against the op_type of the node. inputs: sequence of ValuePatterns (or constants) to match against the inputs of the node. attributes: dictionary of attribute patterns to match against the attributes of the node. outputs: specifies pattern-variable-name for outputs (or None) allow_other_attributes: specifies whether other attributes (not mentioned in `attributes`) are allowed in the node. Nrc XUcSnUcSnXl[U[5(a [U5OUUlUV s/sHn [ U 5PM sn UlX@lX`lXpl Xl [U[5(a0[U[5(aSn UR5UU 4Ul OSUl [U5V V s/sHup[X U 5PM sn n Ul[UR 5HupUcM UR!X 5 M gs sn fs sn n f)NTFr)rrr/r4oprrrrrrr:_op_identifier enumerateNodeOutputPatternrr)rrrErrrrrrroverloadrrYrr:s rr;NodePattern.__init__s " )%) "  %!&  /9"c/B/B'+5;.s7;a3q66;c38# UHn[U5v M g7frrNrOs rrrQs9LqCFFLrRc34# UHupUSU3v M g7f)=Nr)rkrPs rrrQsN6Mda!AaSz6Ms.z = z (r)joinrrrrr/rEr)rrrrrEr qualified_opinputs_and_attributess rr,NodePattern.__str__s74;;77))9DLL99YYNdoo6K6K6MNN \T[[!+1&2$'r =G6("ZL 9V#l^2.C-DAFFrcUR$r)rFr+s r op_identifierNodePattern.op_identifiers"""rc,[UR5$r)r/rEr+s rop_typeNodePattern.op_types477|rcUR$rrr+s rrNodePattern.check_methodrrc URRUR5(d-URSURSURS3U5$URRUR5(d-URSURSURS3U5$UR R 5Hup4UR RU5nUc*UR(dURSUS3U5s $O4URU5(dURSUSUSUS3U5s $URcMURURU5(aMUs $ UR(d:UR H*nX0R ;dMURSUS3U5s $ U$) zMatches the pattern represented by self against a node. This is purely a local node-level match, and does not consider the subgraph rooted at the node. We check the domain, op_type, and attributes of the node, but not the inputs. zOpType mismatch: expected z, got rWzDomain mismatch: expected z Attribute z not found in node.z mismatch: expected z not expected in node.) rErr`failrrrgetrUrYbindr)rrmatchrY attr_pattern attr_values rrNodePattern.matchesswwt||,,::,TWWIVDLL>KT {{""4;;//::,T[[M }ANPT #'//"7"7"9 D,,T2J!#22 :: 4&8K&LdSS3!))*55zz &:<.zlZ[\  ,zz,"3"3Z@@ L#:**. :: 4&8N&OQUVV(  rc URVs/sHo3bURU5OSPM nnU(a [U5S:XdS5eUSUS/nURVs/sHoURPM nn[ UR URUURUURURURS9nXqU'U$s snfs snf)Nz#>#66++    %W 9s C%C) rrFrrrrrrEr)rr%rErrz+Sequence[int | float | ValuePattern | None]rzdict[str, AttrPattern]rzSequence[str | None]rrrrrrr0)rzir.OperatorIdentifier | NonerB)rzir.Noderh_basics.MatchResultrrq)rrArnrrr)rrr r!r"r;r,r]rsr`rrrr#rrrrrs4"&).). ).< ). + ). & ).!,).().).VG#$Lrrcl^\rSrSrSrSS U4SjjjrS Sjr\S Sj5rS Sjr Sr U=r $) rHi-zRepresents a pattern that matches against a specific output of a Node. This is the primary pattern used to match against computed values, that is values computed using a specific op. c<>[TU]U5 XlX lgr)ryr; _producer _output_index)rr  output_indexrYrzs rr;NodeOutputPattern.__init__4s !)rcLXRRUR$r)rtrrurs rrNodeOutputPattern.clone;s '//0B0BCCrcUR$r)rur+s rrvNodeOutputPattern.output_index?s!!!rcUR$r)rtr+s rr NodeOutputPattern.producerCs ~~r)rurtr)r rrvrrYrorrP)rrArrHrrrr) rrr r!r"r;rrsrvr r#r|r}s@rrHrH-s]LP*#*36*>H* **D""rrHcR^\rSrSrSrSSS.S U4SjjjrS SjrSrU=r$) riGzRepresents a pattern-variable.NFrc">[TU]XUS9 g)Nrrx)rrYrrUrzs rr; Var.__init__Js >JrcT[URURURS9$)zBClones the pattern-variable, preserving its name and check method.r)rrYrrUrs rr Var.cloneOs!499D$5$5dFYFYZZrrr@)rrArr rrr r!r"r;rr#r|r}s@rrrGsK(=AY^KK*9KRVK KK [[rrc:^\rSrSrSrSU4SjjrSSjrSrU=r$)AnyValueiTz4Represents a pattern that matches against any value.c$>[TU]S5 grrx)rrzs rr;AnyValue.__init__Ws rcU$rrrs rrAnyValue.cloneZs rr)rrP)rrArrrr}s@rrrTs>rrcn^\rSrSrSrSS U4SjjjrS Sjr\S Sj5rS Sjr Sr U=r $) ribzBRepresents a pattern that matches against a scalar constant value.c>[TU]S5 [U[5(a [ U5OUUlX lX0lgr)ryr;rr listr8_rel_tol_abs_tol)rr:rel_tolabs_tolrzs rr;Constant.__init__es5 %/x%@%@d5ke   rcZA[URURUR5$r)rr8rrrs rrConstant.cloneps  T]]DMMBBrcUR$rr7r+s rr:Constant.valuetrrc,[UR5$rrr+s rr,Constant.__str__xrr)rrr8)gh㈵>g:0yE>)r:z-int | float | Sequence[int] | Sequence[float]rrrrrrP)rrArr)rz%int | float | list[int] | list[float]r0) rrr r!r"r;rrsr:r,r#r|r}s@rrrbsbL   <         C  rrcn^\rSrSrSrSS U4Sjjjr\S Sj5rS SjrS Sjr Sr U=r $) OpIdDispatchOri|z`Represents a (restricted) form of value pattern disjunction that enables deterministic matching.c<>[TU]U5 XlX0lg)aM Initialize an OpIdDispatchOr pattern. Args: op_to_pattern: A dictionary mapping operator identifiers to tuples of tag values and patterns. The keys are operator identifiers, and the values are tuples containing a tag value and a pattern to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value indicating which alternative was matched. N)ryr;_op_to_pattern_tag_var)r op_to_patternrYtag_varrzs rr;OpIdDispatchOr.__init__s$ + rcUR$z=Returns the tag variable associated with the OrValue pattern.rr+s rrOpIdDispatchOr.tag_var}}rc [URR5VVs0sHup#X#SUSRU54_M snnURUR 5$s snnf)Nrr)rrrrrYr)rrrVrPs rrOpIdDispatchOr.clones^9=9L9L9R9R9T U9TQ1qtzz(+, ,9T U II MM  Us%A& cUR5nUb1UR5nUbX0R;aURU$g)z=Returns the pattern that should be tried for the given value.N)r r]r)rr:r rks r get_patternOpIdDispatchOr.get_patternsF>>#  '')B~"(;(;";**2..r)rr)NN)rz8Mapping[ir.OperatorIdentifier, tuple[Any, ValuePattern]]rYrorrorrPrp)rrArr)r:zir.Valuerztuple[Any, ValuePattern] | None) rrr r!r"r;rsrrrr#r|r}s@rrr|saj  "  O       , rrcj^\rSrSrSrSSU4Sjjjr\S Sj5rS SjrSr U=r $) BacktrackingOrizMRepresents an unrestricted form of OR pattern implemented using backtracking.c>[TU]U5 Ub2Uc [S5e[U5[U5:wa [S5eO[ [ [U555nX0lX@lXlg)a- Initialize a BacktrackingOr pattern. Args: values: A sequence of value patterns to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value (from tag_values) indicating which alternative was matched. tag_values: An optional sequence of values to bind to the tag_var. Defaults to None. If present, the length of tag_values must match the number of alternatives in values. In a successful match, tag-var will be bound to the i-th value in tag_values if the i-th alternative pattern matched. If omitted, the default value of (0, 1, 2, ...) will be used. N4tag_var must be specified if tag_values is provided.Ctag_values must have the same length as the number of alternatives.) ryr;rrrrr _tag_values_values)rvaluesrYr tag_valuesrzs rr;BacktrackingOr.__init__ss*   ! !WXX:#f+- Y. uS[12J % rcUR$rrr+s rrBacktrackingOr.tag_varrrc[URVs/sHo"RU5PM snURURUR 5$s snfr)rrrrYrr)rrrPs rrBacktrackingOr.clonesF(, 5 1WWX  5 II MM      5sA)rrrNNN) rSequence[ValuePattern]rYrorrorSequence[Any] | NonerrPrp)rrArr) rrr r!r"r;rsrrr#r|r}s@rrrsjW  "+/ !&!! ! ) !  !!F  rrc^^^^Tb2Tc [S5e[T5[T5:wa [S5eO[[[T555mSUUUU4SjjnU"5nU=(d [ TTTT(aTOS5$)a Creates an OR pattern. Args: values: A sequence of value patterns to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value (from tag_values) indicating which alternative was matched. tag_values: An optional sequence of values to bind to the tag_var. Defaults to None. If present, the length of tag_values must match the number of alternatives in values. In a successful match, tag-var will be bound to the i-th value in tag_values if the i-th alternative pattern matched. If omitted, the default value of (0, 1, 2, ...) will be used. Nrrc>0n[T5HOup[U[5(d gUR5nUR 5nUbX@;a gTUU4X'MQ [ UTT5$r)rGrrHr r]r) mappingr alternativer rkrYrrrs rmake_op_id_or_pattern&OrValue..make_op_id_or_patternssNP'/NAk+<=="++-H'')BzR]%a=+6GK0gtW55r)rzOpIdDispatchOr | None)rrrrr)rrYrrroptimized_patterns```` rOrValuers( ?ST T z?c&k )U  * 5V-.  6 6./  gWz$!rcP^^/mSUU4SjjmT"U5 TR5 T$)zFReturns all nodes used in a pattern, given the outputs of the pattern.c>UHUn[U[5(dMUR5nUT;dM2TRU5 T"UR5 MW gr)rrHr rr)value_patterns value_patternr node_patternsvisits rr _nodes_in_pattern..visitsM+M-):;;,557 }4!((6,--. ,r)rzSequence[ValuePattern | None]rrP)reverse)rrrs @@r_nodes_in_patternrs-')M// 'N rcX;agURU5 URHbn[U[5(a[ UR 5X5 M4[U[ [45(dMQURU5 Md g)zAdds all nodes in the backward slice of given node to the set `backward_slice`. The backward slice of a node is the set of all nodes that are reachable from the node in a backward traversal from the given node. N)addrrrH_add_backward_slicer rr)rbackward_slicebackward_slice_valuesrs rrr so t m%6 7 7 &&(.  'G H H ! % %m 4 %rc\rSrSrSrSSjr\SSj5rSSjrSSjr SSjr \SSj5r \SS j5r SS jr SS jr\SS j5r\SS j5rSSjrSSjrSrg) GraphPatterni6z.commute_nodes<!!#6$:L:L:NS; t}$7Nrc~>[U5(dT$0nTRVs/sHo"RU5PM nn[TRU5VVs/sHupEURX5PM nnnTR Vs/sHo"RU5PM nn[ X7U5$s snfs snnfs snfr)anyrrziprrr) swap_listrrP new_inputsrrn new_nodes new_outputsrs r copy_graph(GraphPattern.commute..copy_graphsy>> 79H59\\B\''(+\JB=@i=X=Xzt 8*=X 7;mmDm778,mKD C C CEsB/B4B:)rrrIterable[bool])rr rr)r itertoolsproduct)rrriteration_spacerrs` rcommuteGraphPattern.commutesc ;?++F+$<-+F D8A7H7H/7Z[7Z) 9%7Z[[G\s AAcSRSUR55nSRSUR55nSRSUR55nSUSUSUS 3$) NrLc38# UHn[U5v M g7frrNrOs rr'GraphPattern.__str__..s8r.sJK" #   .- CL,hqk,  CGGWS\   M  !M !V'"''"V.>k>  SM UO SM  + 2D4--` R %mK&@AF!F!RA3AAD)/%. $$IVIVXJJZ 4 [, [| J  | 4,\,^1 \1 l'+ - "- --% -  -`"5 5$5-5 5,pMpMfJr