
     TiC                       % S SK Jr  / SQrS SKrS SKrS SKrS SKrS SKJrJrJ	r	J
r
Jr  S SKrS SKrS SKrS SKrS SKJs  Jr  S SKJr  / SQrSrSrS	r\" 1 S
k5      r\" S15      r\R:                  " \5      rSVS jr SVS jr!SWS jr"SXS jr#SYS jr$ " S S5      r%\%" 5       r&\RN                   " S S5      5       r(\\RR                  \*\RR                     \RV                  4   r, " S S5      r-\R\                  r/\\(\
\RR                     \RR                  S4   r0\\Rb                  \/\-/\04   r2\RN                   " S S5      5       r3 " S S5      r4\4" 5       r5S\6S'   \5Rn                  r7SZS jr8 S[       S\S jjr9S]S jr:S^S jr;S^S  jr<S_S! jr=S`SaS" jjr>\7" S#5      SbS$ j5       r?\7" S%5      SbS& j5       r@\7" S'5      SbS( j5       rASbS) jrB\7" S*5      SbS+ j5       rC\7" S,5      SbS- j5       rD\7" S.5      SbS/ j5       rE\7" S05      SbS1 j5       rF\7" S25      SbS3 j5       rG\7" S45      SbS5 j5       rH\7" S65      SbS7 j5       rI\7" S85      SbS9 j5       rJ\7" S:5      SbS; j5       rK\7" S<5      SbS= j5       rL\7" S>S?S@9SbSA j5       rM\7" SB5      SbSC j5       rN\7" SD5      SbSE j5       rO\7" SF5      SbSG j5       rP\7" SH5      SbSI j5       rQ      ScSJ jrRSdSK jrS " SL SM\R                  R                  5      rV        SeSN jrWSfSO jrX\RN                   " SP SQ\R                  R                  5      5       rZSR\\SS ST.           SgSU jjr[g)h    )annotations)basic_constant_propagationfold_constantsFoldConstantsPassFOLDED_FROM_KEYN)AnyCallableIterableSequenceUnion)_tape)ConstantOfShapeQuantizeLinearDequantizeLineari    i   z$pkg.onnxscript.optimizer.folded_from>   MultinomialRandomNormalRandomUniformRandomNormalLikeRandomUniformLike) 	Transposec                   ^ [         R                  R                  [         R                  R                  1m[	        U4S jU R
                  R                  5        5       5      $ )Nc              3  @   >#    U  H  oR                   T;   v   M     g 7fN)type).0attrgraph_typess     e/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/onnxscript/optimizer/_constant_folding.py	<genexpr>&_is_control_flow_op.<locals>.<genexpr>D   s     M4LDyyK'4Ls   )irAttributeTypeGRAPHGRAPHSany
attributesvalues)noder   s    @r   _is_control_flow_opr*   B   sC    ##))2+;+;+B+BCKMDOO4J4J4LMMM    c                v    U R                   [        ;   =(       a     [        R                  " U R                  5      $ r   )op_type_NON_DETERMINISTIC_OPSutilsis_onnx_domaindomainr)   s    r   _is_non_deterministic_opr3   G   s&    <<11We6J6J4;;6WWr+   c                n    U R                   U:H  =(       a     [        R                  " U R                  5      $ r   )r-   r/   r0   r1   )r)   r-   s     r   _is_onnx_opr5   K   s%    <<7"Hu';';DKK'HHr+   c                   [        U S5      (       d  g[        U R                  5      S:w  a  g[        [	        U R                  R                  5       5      5      u  p[        U R                  5      S:w  a  gU R                  S   nUb  [        U[        R                  5      (       d  gUR                  c  gUS;   aK  [        R                  " [        R                  " UR                  [        R                  S9UR                  S9nOUS;   aK  [        R                  " [        R                  " UR                  [        R                   S9UR                  S9nOUS	;   aK  [        R"                  " [        R                  " UR                  [        R$                  S9UR                  S9nO7US
:X  a0  [&        R(                  " [        R*                  UR                  5      nOgXCl        UR.                  Ul        UR0                  Ul        g)z7Sets const_value of output value of a Constant op node.ConstantN   r   >   value_floatvalue_floats)dtype)name>   	value_int
value_ints>   value_stringvalue_stringsvalue)r5   lenr'   nextiteritemsoutputs
isinstancer"   AttrrA   Tensornparrayfloat32r<   int64StringTensorbytes_typingcastTensorProtocolconst_valueshaper;   )r)   	attr_name
attr_valueir_valuerS   s        r   _process_constant_noderX   U   s|   tZ((
4??q  doo&;&;&=!>?I
4<<A||AHJ!@!@  33iiHHZ%%RZZ8x}}
 
1	1ii)9)9 JQYQ^Q^_	7	7ooHHZ%%RYY7hmm
 
g	kk""3"3Z5E5EF& &&HN &&HNr+   c                ,    U  H  n[        U5        M     g)zPerforms basic constant propagation for a sequence of nodes.

Just marks the output values of Constant op nodes with their const_value.
N)rX   )nodesr)   s     r   r   r   ~   s    
 t$ r+   c                  (    \ rS rSrSS jrSS jrSrg)ReferenceEvaluator   c                     [         R                  R                  R                  XU5      nUR                  $ ! [
         a     g f = fr   )onnx	referenceopsload_opeval	Exception)selfr1   opversionop_impl_classs        r   get_evaluator ReferenceEvaluator.get_evaluator   sA    	 NN..66v7KM %%% 		s   58 
AAc                    [         R                  SX5        U R                  XU5      nUc  g  U" U0 UD6$ ! [         a   n[         R	                  SU5         S nAg S nAff = f)NzEvaluating %s::%szEvaluation failed: %s)loggerdebugri   rd   warning)re   r1   rf   rg   argskwargs	evaluatores           r   evaluateReferenceEvaluator.evaluate   sc    (&5&&v7;		d-f-- 	NN2A6	s   6 
A  AA  N)r1   strrf   rv   rg   intreturnzCallable | None)r1   rv   rf   rv   rg   rw   rx   r   )__name__
__module____qualname____firstlineno__ri   rs   __static_attributes__ru   r+   r   r\   r\      s    	r+   r\   c                  .    \ rS rSr% SrS\S'   S\S'   Srg)	Replacement   z&A replacement for a node in the graph.Sequence[ir.Value]new_outputszSequence[ir.Node]	new_nodesru   N)ry   rz   r{   r|   __doc____annotations__r}   ru   r+   r   r   r      s    0##  r+   r   c                  L    \ rS rSrS r\S	S j5       rS
S jrSS jrSS jr	Sr
g)OptimizerState   c                     0 U l         / U l        g r   )_sym_value_map_initializer_inputsre   s    r   __init__OptimizerState.__init__   s    =?8: r+   c                    U R                   $ r   r   r   s    r   symbolic_value_map!OptimizerState.symbolic_value_map   s    """r+   c                @    Uc  g U R                   R                  U5      $ r   )r   get)re   rA   s     r   get_sym_valueOptimizerState.get_sym_value   s!    =""&&u--r+   c                     X R                   U'   g r   r   )re   rA   	sym_values      r   set_sym_valueOptimizerState.set_sym_value   s    %.E"r+   c                   [        U[        R                  R                  SS9nUb5  UR                  S:X  a$  [        R
                  " UR                  5       5      $ g U R                  U5      n[        U[        R
                  5      (       a  U$ g )N
   
size_limitr8   )	_get_numpy_valuer"   DataTypeINT64ndimShapetolistr   rG   )re   rA   rS   r   s       r   get_shape_valueOptimizerState.get_shape_value   ss    &ubkk.?.?BO"1$xx 2 2 455&&u-	i**r+   )r   r   N)rx   dict[ir.Value, SymbolicValue])rA   ir.Value | Nonerx   zSymbolicValue | None)rA   ir.Valuer   SymbolicValuerx   None)rA   r   rx   ir.Shape | None)ry   rz   r{   r|   r   propertyr   r   r   r   r}   ru   r+   r   r   r      s*    ; # #.
/
r+   r   c                  B    \ rS rSr% SrS\S'   S\S'   S\S'   SS jrS	rg
)PartialEvaluator   a  A class that represents a partial-evaluator for a particular op.

It is applicable for a specific version range (min_version, max_version) of the op.
The min_version and max_version can be None, indicating that there is no version
constraint in that direction.

int | Nonemin_versionmax_versionPartialEvaluatorFunctionfunctionc                    U R                   SL =(       d    XR                   :  =(       a#    U R                  SL =(       d    XR                  :*  $ )zCReturns True if this evaluator is applicable for the given version.N)r   r   )re   rg   s     r   	valid_forPartialEvaluator.valid_for   sD      D(GG7G7G,G 
$C3C3C(C	
r+   ru   N)rg   rw   rx   bool)ry   rz   r{   r|   r   r   r   r}   ru   r+   r   r   r      s      &&
r+   r   c                  B    \ rS rSrSrS rSS jr S	     S
S jjrSrg)PartialEvaluatorRegistry   z8A class that maintains a registry of evaluators for ops.c                    0 U l         g r   op_evaluatorsr   s    r   r   !PartialEvaluatorRegistry.__init__   s
    LNr+   c                    U R                   R                  X4/ 5      nU Vs/ s H&  oUR                  U5      (       d  M  UR                  PM(     sn$ s  snf r   )r   r   r   r   )re   r1   opnamerg   evaluator_listrq   s         r   lookup_evaluators*PartialEvaluatorRegistry.lookup_evaluators   sS    ++//0@"E0>
0>9BUBUV]B^I
 	
 
s
   AANc                   ^^^ X!4U R                   ;   a  U R                   X!4   mO/ mTU R                   X!4'   Uc  S mS mO4[        U[        5      (       a  UmUmO[        U[        5      (       a  Uu  mmSUUU4S jjnU$ )Nc                @   > TR                  [        TTU 5      5        U $ r   )appendr   )r   r   r   r   s    r   	decorator4PartialEvaluatorRegistry.register.<locals>.decorator  s     !!"2;X"VWOr+   )r   r   rx   r   )r   rG   rw   tuple)re   r   r1   rg   r   r   r   r   s        @@@r   register!PartialEvaluatorRegistry.register   s     t111!//0@ANN3AD/0?KK%%!K!K'''.$K	 	 r+   r   )r1   rv   r   rv   rg   rw   )r   N)r   rv   r1   rv   rx   z>Callable[[PartialEvaluatorFunction], PartialEvaluatorFunction])	ry   rz   r{   r|   r   r   r   r   r}   ru   r+   r   r   r      s7    BO
 6:#&	G r+   r   registryc                d    [        S U  5       5      (       a  gU R                  UR                  :H  $ )Nc              3     #    U  H4  n[        U[        R                  5      =(       a    UR                  S L v   M6     g 7fr   rG   r"   SymbolicDimrA   )r   dims     r   r    _same_shape.<locals>.<genexpr>!  s,     
SFS:c2>>*@syyD/@@Fs   <>F)r&   dims)shape1shape2s     r   _same_shaper     s+    
 
SF
SSS;;&++%%r+   c                   U c  gU R                   nUb  Ub  UR                  U:w  a  gUb  UR                  U:  a  g UR                  5       nUR                  [        R
                  R                  :w  a)  UR                  UR                  R                  5       5      n[        U[        R                  5      (       d   eU$ g! [         a#    [        R                  SU R                  5         gf = f)zReturns the numpy value of a constant value, if available.

It returns None if the value is not a constant value, or if the value is not of
the specified element dtype, or if the size of the value exceeds the specified
size_limit.
Nz[External data for value '%s' is not available. This may lead to incorrect constant folding.)rS   r;   sizenumpyr"   r   STRINGviewFileNotFoundErrorrl   rn   r<   rG   rJ   ndarray)valr;   r   rS   rK   s        r   r   r   &  s     {//K!2!2e!;!k&6&6&C	  %%'E
   BKK$6$66 

;#4#4#:#:#<= %,,,, ! 	NN?
 	s   A!C *C/.C/c                    U c  g [        U 5      nUc  g UR                  S:X  a%  UR                  [        :X  a  UR	                  S5      $ g Nr8   r   )r   r   r;   r   item)r   rA   s     r   _get_bool_valuer   Q  sC    
{S!E}zzQ5;;$.zz!}r+   c                T    U[        U R                  5      :  a  U R                  U   $ g r   )rB   inputsr)   indexs     r   
_get_inputr   \  s%    s4;;{{5!!r+   c                T    U[        U R                  5      :  a  U R                  U   $ g r   )rB   rF   r   s     r   _get_outputr   b  s%    s4<<  ||E""r+   c                    [        X5      nUb-  UR                  b   UR                  R                  R                  $ [        R
                  R                  R                  $ r   )r   r   r;   rA   r"   r   	UNDEFINED)r)   r   inputs      r   _get_input_element_typer   h  sG    t#EUZZ3zz%%%;;  &&&r+   c                    XR                   ;   aS  U R                   U   n[        U[        R                  5      (       d  g UR                  n[        U[
        5      (       a  U$ g U$ r   )r'   rG   r"   rH   rA   rw   )r)   r<   defaultr   attr_vals        r   _get_int_attributer   o  sS    t$$((::h$$O Nr+   Addc                F  ^ ^ U U4S jnU" S5      nU" S5      nUb  Uc  g[        U[        5      (       a  [        U[        5      (       a  XE-   nO[        R                  " U SU 35      n[	        T S5      nUb(  TR                  U[        R                  " U/5      5        gg)zPropagate symbolic dim values.c                   > [        TU 5      nUc  g TR                  U5      nUb  [        U5      S:w  a  g US   n[        U[        5      (       a  U$ UR
                  $ r   )r   r   rB   rG   rw   rA   )input_indexr   shape_valuer   r)   states       r   get_dim_valueadd.<locals>.get_dim_value  s`    4-=','<'<U'C#k"2a"7$/N c**s9		9r+   r   r8   N+)rG   rw   r"   r   r   r   r   )r)   rf   r   r   dim0dim1result_dim_valueoutputs   ` `     r   addr  }  s    : DD|t|$D#!6!615>>TF!D6*:;q!FFBHH.>-?$@A r+   Absc                    [        U S5      nUR                  U5      nUc  g[        S U 5       5      (       a  gUR                  U5      $ )zgReplace an Abs node by Identity when applicable.

Currently, addresses Abs applied to symbolic shapes.
r   Nc              3  Z   #    U  H!  n[        U[        5      =(       a    US :  v   M#     g7f)r   NrG   rw   r   ds     r   r    abs.<locals>.<genexpr>  s#     
AA:a'!a%'s   )+)r   r   r&   Identity)r)   rf   r   r   input_sym_values        r   absr    sN     tQE++E2O

A
AAA ;;ur+   Gatherc                   [        U S5      n[        U S5      nUb  Uc  gUR                  U5      nUc  g[        U SS5      nUS:w  a  g[        U5      nUc  gUR                  S:w  a  gU Vs/ s H  oU   PM	     n	n[        U S5      n
U
b&  UR                  U
[        R                  " U	5      5        [        S U	 5       5      (       a$  UR                  [        R                  " SU	5      S9$ gs  snf )ztReplace a Gather node by a constant when applicable.

Currently, handles the case of Gathering from a shape tensor.
r   r8   Naxisc              3  B   #    U  H  n[        U[        5      v   M     g 7fr   r  r  s     r   r    gather.<locals>.<genexpr>  s     
0x!:ax   r>   r>   )r   r   r   r   r   r   r   r"   r   allr7   
AttrInt64s)r)   rf   r   r   indicesr
  r  indices_numpy_valueigatheredr   s              r   gatherr    s     tQEq!G}++E2OdFD1Dqy*73"1$,?@,?q",?H@q!FFBHHX$67

0x
000{{bmmL(&K{LL As   -C.c                    [        U S5      nUR                  U5      n[        U S5      nUb  Ub  UR                  XT5        g)zPropagates symbolic shape value of input 0 to output 0.

Applies to ops like Reshape/Squeeze/Unsqueeze where the shape of the tensor may change
but the values in the tensor remain the same.
r   N)r   r   r   r   )r)   rf   r   r   input_shape_valuer   s         r   _propagate_shape_valuer    sJ     tQE--e4q!F/;F6r+   Reshapec                    [        U S5      n[        U S5      nUb  Uc  gUR                  nUR                  U5      nUb  Uc  [        XU5      $ [	        XV5      (       a  UR                  U5      $ [        XU5      $ )z[Replace a Reshape node by Identity when applicable.

Also propagate symbolic shape values.
r   r8   N)r   rT   r   r  r   r	  )r)   rf   r   r   rT   input_shaper   s          r   reshaper     s     tQEtQE}++K''.Kk1%d66 ;,,{{5!!!$E22r+   Squeezec                    [        XU5      $ )z Propagate symbolic shape values.)r  )r)   rf   r   s      r   squeezer#    s     "$E22r+   Castc                   [        U S5      n[        U S5      nUb  Uc  g [        U S5      n[        U SS 5      nUbE  XV:X  a  UR	                  U5      $ [
        R                  " [
        R                  " U5      5      Ul        g )Nr   to)	r   r   r   r   r	  r"   
TensorTyper   r   )r)   rf   r   r   r   input_dtypeoutput_dtypes          r   rQ   rQ     sw    tQEq!F})$2K%dD$7L&;;u%%mmBKK$=>r+   CastLikec                    U R                   S   n[        U S5      n[        U S5      nU[        R                  R                  :X  a  g XE:X  a  UR                  U5      $ UR                  X5S9$ )Nr   r8   )r&  )r   r   r"   r   r   r	  r$  )r)   rf   r   input0source_element_typetarget_element_types         r   	cast_liker/    sd    [[^F1$:1$:bkk3331{{6""776722r+   r   c                x   U R                   S   nUc  g UR                  nUc  g [        U SS5      n[        U SS 5      nXEU n[        U S5      nUb&  UR	                  U[
        R                  " U5      5        [        S U 5       5      (       a-  UR                  [
        R                  " S[        U5      5      S9$ g )Nr   startendc              3  B   #    U  H  n[        U[        5      v   M     g 7fr   r  r  s     r   r    shape.<locals>.<genexpr>  s     
3{!:a{r  r>   r  )r   rT   r   r   r   r"   r   r  r7   r  list)	r)   rf   r   r   rT   r1  r2  shape_slicer   s	            r   rT   rT     s    KKNE}KKE}tWa0E
T5$
/Cc"Kq!FFBHH[$9:

3{
333{{bmmL${BS&T{UUr+   Sizec                    [        U S5      nUc  g UR                  nUc  g SnU H  n[        U[        5      (       d    g XV-  nM      UR	                  US9$ )Nr   r8   r=   )r   rT   rG   rw   r7   )r)   rf   r   r   rT   r   r  s          r   r   r   $  s`    tQE}KKE}D!S!!	  ;;;&&r+   Ifc                :  ^ [        U S5      n[        U5      nUGby  U(       a  SOSnU R                  R                  U5      nUc  g UR                  [
        R                  R                  :w  a  g [        U[
        R                  5      (       d   eUR                  5       n[        UR                  5      nUR                  R                  5         U R                  n	[        X5       V
Vs0 s H!  u  pUc  M
  U
R                  UR                  _M#     snn
mU4S jn[        U5      nUR!                  U5        U HM  nUR                   H  nU" UR                  5      Ul        M     U R                   SUR                   3Ul        MO     [#        X5      $ g s  snn
f )Nr   then_branchelse_branchc                &   > TR                  X 5      $ r   )r   )r<   	renamingss    r   renameif_op.<locals>.renameM  s    ==,,r+   _)r   r   r'   r   r   r"   r#   r$   rG   rH   as_graphr5  rF   clearzipr<   remover   )r)   rf   r   
cond_inputcondbranch
graph_attrgraphformal_outsactual_outsformalactualr@  graph_nodessub_nodevr?  s                   @r   if_oprS  4  sZ   D!$J:&D"&M__((0
??b..444*bgg....##%5==)ll #&k"?
"? %FKK$"?
		- 5k[!#H%% &  $yyk8==/:HM $ ;44+
s   *	F7Fr	  c           
        AU R                   S   nU R                  S   nUbX  UbU   [        UR                  UR                  5      Ul        UR                  c  UR                  Ul        UR                  XC5        g ! [         aR  n[
        R                  SU R                  UR                  R                  [        [        5       5      U5         S nANS nAff = f)Nr   zb[Constant folder] Cannot merge shapes on Identity node '%s' (folded from: %s) because of error: %s)r   rF   _merge_shapesrT   rd   rl   rn   r<   metar   r   setr   r   )r)   rf   r   r   r   rr   s         r   identityrX  ^  s    
KKNE\\!_FV/		'V\\BEK ::EJF*  	NN9		

6 	s   %A< <
CACCSequenceConstructc                t    AU R                   S   nUb%  UR                  U[        U R                  5      5        g )Nr   )rF   r   r5  r   )r)   rf   r   r   s       r   sequence_constructr[  u  s4    
\\!_FFD$56r+   Concatc                  ^ U R                   n[        U5      S:X  a  UR                  US   5      $ [        U SS5      mTc  gS
U4S jjnU Vs/ s H  oT" U5      (       a  M  UPM     nn[        U5      [        U5      :w  aa  U(       a(  [        R                  SX65        UR                  " UST06$ U(       a*  [        R                  SU5        UR                  US   5      $ gTS:w  a  gU Vs/ s H  orR                  U5      PM     nn[        S U 5       5      (       a  g[        R                  " S	 U 5       5      n	U R                  S   n
U
c  gUR                  X5        gs  snf s  snf )z5Replace a Concat node with a single input by Identityr8   r   r  Nc                b   > U c  gU R                   =nc  g UT   nUS:H  $ ! [         a     gf = f)NFr   )rT   
IndexError)operandrT   dim_sizer  s      r   has_zero_sizeconcat.<locals>.has_zero_size  sK    ?]]"E+	T{H 1}  		s   ! 
..z0Concat: removing zero-length operand(s) %s => %sz,Concat: removing all zero-length operands %sc              3  (   #    U  H  oS L v   M
     g 7fr   ru   )r   rT   s     r   r    concat.<locals>.<genexpr>  s     
-fUD=f   c              3  J   #    U  H  oR                     H  o"v   M     M     g 7fr   )r   )r   rT   r   s      r   r    re    s     JVEzzCzCVs   !#)r`  r   rx   r   )r   rB   r	  r   rl   rm   r\  r   r&   r"   r   rF   r   )r)   rf   r   r   rb  x
new_inputsr   shapesconcatenatedr   r  s              @r   concatrl  ~  sM   
 [[F
6{a{{6!9%%dFD1D|
 $<V=+;!VJ<
:#f+%LLBF 99j4t44 LLGP;;vay))  qy8>?u##E*F?

-f
---88JVJJL\\!_F~	-? =. @s   E$"E$.E)Dropout)   N)rg   c                  ^ ^ U U4S jnT R                   n[        U5      S::  d  US   c  U" 5       $ [        US   5      SL a  U" 5       $ [        US   5      nUc  gUR                  S:w  a  gUR                  5       S:X  a  U" 5       $ g)z.Replace a Dropout by Identity when applicable.c                    > TR                   S   n TR                  U 5      n[        TR                  5      S:X  a  U$ [        R
                  " S/5      nTR                  U 5      nTR                  X2S9nX4$ )Nr   r8   T)rA   )r   r	  rB   rF   r"   tensorr   r   )r   r   true_tensorr  maskr)   rf   s        r   optimized_dropout"dropout.<locals>.optimized_dropout  sl    AU#t||!M))TF+K((5/K%%k%ED<r+      NFr8   r   )r   rB   r   r   r   r   )r)   rf   r   rt  r   ratios   ``    r   dropoutrx    s    	  [[FFqVAY. ""vay!U* ""VAY'E}zzQzz|q ""r+   Expandc                   [        U R                  5      S:w  a  gU R                  S   =nc  gUR                  =nc  g[        U R                  S   5      =ncC  UR	                  U R                  S   5      nUb  [        XF5      (       d  gUR                  U5      $ UR                  S:w  a  gUR                  [        UR                  5       5      :X  a  UR                  U5      $ g)z3Replace an Expand node by Identity when applicable.rv  Nr   r8   )rB   r   rT   r   r   r   r	  r   r   r   r   )r)   rf   r   r   r  expanded_shapeexpanded_sym_shapes          r   expandr}    s     4;;1Q({{"+*4;;q>::C"224;;q>B%[-Y-Y{{5!!a5!6!6!899{{5!!r+   ConcatFromSequencec                   U R                   S   nUR                  U5      nUb  [        S U 5       5      (       a  g [        U SS5      n[        U SS 5      nUc  g Ub  [	        U[
        5      (       a  US:X  aB  [        R                  SU Vs/ s H  owR                  PM     sn5        UR                  " USU06$ US:X  a  UR                  US9n/ n	U H2  n
UR                  XU
R                   S3/S	9nU	R                  U5        M4     [        R                  S
U	 Vs/ s H  owR                  PM     sn5        UR                  " U	SU06$ g s  snf s  snf )Nr   c              3  (   #    U  H  oS L v   M
     g 7fr   ru   r   rh  s     r   r    'concat_from_sequence.<locals>.<genexpr>  s     71$Yrf  new_axisr  z ConcatFromSequence => Concat: %sr8   r9  
_unsqueeze_outputszConcatFromSequence => Concat %s)r   r   r&   r   rG   r5  rl   rm   r<   r\  r7   	Unsqueezer   )r)   rf   r   r   r   r  r  rh  
axis_valueunsqueezed_inputs
node_inputunsqueezed_inputs               r   concat_from_sequencer    sU   KKNE  'F~7777!$
A6HdFD1D|Z55q=LL;f=Uffff=UV99f0400q=t4J "$
#%<<8I6T5U $0 $  "(()9:	 % LL1DU3VDUqFFDU3V 99/;d;;! >V 4Ws   E
E
SplitToSequencec                p   U R                   S   n[        U R                   5      S:X  a  gU R                   S   nU R                  S   nUb  Ub  Uc  g[        U SS5      nUc  gUR                  nUc  g[        U5      nUS:  a  Xh-   nUS:  d  Xh:  a  g[        U5      n	UR                  b9  UR                  R                  5       (       a  UR                  R                  5       OSn
U	c  U
c  g[        U
[        5      (       ag  [        U
5      S:X  aX  U
S   n[        U[        5      (       d   eUn[        U5       Vs/ s H  oR                   SU 3PM     nnUR                  X4XnS9nOU	R                  S:X  aF  U	R                  n[        U5       Vs/ s H  oR                   SU 3PM     nnUR                  X4XnS9nOU	R                  S:X  az  Xv   n[        U[        5      (       d  g[         R"                  " XR%                  5       -  5      n[        U5       Vs/ s H  oR                   SU 3PM     nnUR                  X6XS9nOg[        U[&        R(                  5      (       a  U/n[        U SS5      nUc  gUS:X  a_  UR+                  U/UR                   S	3/S
9n/ n[        U5       H-  nUR-                  X   UX    S3/S9nUR/                  U5        M/     Un[0        R3                  S5        [        U[&        R(                  5      (       a  U/nUR4                  " U6 $ s  snf s  snf s  snf )a  Rewriting pattern.

From

    splits = onnx::SplitToSequence(input, split, axis=axis)

to

    split_0, split_1, ..., split_n = onnx::Split(input, split, axis=axis)
    splits = onnx::SequenceConstruct(split_0, split_1, ..., split_n)

or

    split_0, split_1, ..., split_n = onnx::Split(input, axis=axis, num_outputs=n+1)
    splits = onnx::SequenceConstruct(split_0, split_1, ..., split_n)

where number of output tensors in `splits` is statically known.
onnx::SequenceConstruct will be further optimized away if possible, by its own designated evaluator.
This allows downstream `SequenceAt` users to be replaced by `split_x` accordingly.
r   r8   Nr  _split_)r  r  )r  num_outputsr  keepdims_axis)r>   r  _squeezer  z,SplitToSequence => Split + SequenceConstruct)r   rB   rF   r   rT   r   	is_staticr   rG   r   rw   ranger<   Splitr   r   mathceilr   r"   Valuer7   r!  r   rl   rm   rY  )r)   rf   r   r   splitr   r  rT   ranksplit_valuesplit_shapesplit_dimension_sizer  r  split_outputssplit_valuesr  axis_valsqueezed_valuessqueezeds                       r   split_to_sequencer    s2   , KKNE
4;;1KKNE\\!_F}dFA.D|KKE}u:Dax{ax4< #5)K${{65;;;P;P;R;RX\ 
 {2+u%%#k*:a*?*1~.4444*=B;=OP=OKK=s3=OPxx4xP			Q	!&&=B;=OP=OKK=s3=OPxx4xP			Q	${.44ii 47G7G7I IJ=B;=OP=OKK=s3=OPxx+   
  ,))$~!$
A6H1};;4&v{{m5<Q;R;S{#Azz8H7I5R4S " H ""8,	 $
 '
LL?@,))$~..U Q
 Q Qs   =L)L.L3
SequenceAtc                   U R                   S   nU R                   S   nU R                  S   nUb  Ub  UR                  U5      n[        U5      n[	        U[
        5      (       av  Ubs  UR                  S:w  a  g UR                  5       n Xg   nUR                  XX5        [        R                  SUR                  UR                  5        UR                  U5      $ g ! [         a     g f = f)Nr   r8   zSequenceAt %s => %s)r   rF   r   r   rG   r5  r   r   r_  r   rl   rm   r<   r	  )	r)   rf   r   r   positionr   
input_valsposition_valresults	            r   sequence_atr    s    KKNE{{1~H\\!_FX1((/
'1j$''L,D  A%',,.L#1 /LL.

FKKH;;v&&  s   
C 
C)(C)c           
         S nU c  U$ Uc  U $ [        U 5      [        U5      :w  a  [        SU  SU 35      e[        R                  " [	        X5       VVs/ s H  u  p4U" X45      PM     snn5      $ s  snnf )z>Merge two shapes, preferring dimensions from preferred_shapes.c                    X:X  a  U $ [        U [        R                  5      (       d  U $ [        U[        R                  5      (       d  U$ U R                  c  U$ U $ r   r   )r   dim2s     r   
merge_dims!_merge_shapes.<locals>.merge_dims  sL    <K$//K$//K::Kr+   z4Shapes must have the same rank, got preferred_shape=z, other_shape=)rB   
ValueErrorr"   r   rE  )preferred_shapeother_shaper  r   r  s        r   rU  rU    s    
	 
?s;//B?BSSabmano
 	
 8825o2ST2SJDD	2ST Ts   A1
c                   [        5       nU R                   Hi  nUc  M  UR                  UR                  R	                  [
        [        5       5      5        UR                  c   eUR                  UR                  5        Mk     UR                   H?  nUc  M  X$R                  [
        '   [        [        U5      5      UR                  [
        '   MA     g)zXRecord the set of original input values that contributed to the constant-folded outputs.N)rW  r   updaterV  r   r   r<   r  r   reprsortedmetadata_props)original_nodereplacementfolded_fromr   
new_outputs        r   _record_contributing_valuesr    s    EK%%=5::>>/35ABzz%%%

# & "--
+6(59&:M5N
!!/2 .r+   c                      \ rS rSrSrS S.         SS jjrSS jrSS jr        SS jrSS	 jr	SS
 jr
SS jr        SS jrSS jrSS jrSS jrSS jrS S jrSrg)!r   i  a  A pass that folds constant expressions in the model.

Attributes:
    shape_inference: Whether to perform shape inference.
    input_size_limit: Maximum size of input tensors to fold.
    output_size_limit: Maximum size of output tensors to fold.
    should_fold: An optional function that takes a node and returns True if
        the node should be considered for folding.
        The function should return True/False value to indicate if this particular
        node should be folded, or None to use the default folding rules.
c                    g r   ru   r2   s    r   <lambda>FoldConstantsPass.<lambda>  s    Tr+   )should_foldc                   Xl         X l        X0l        X@l        0 U l        0 U l        0 U l        SU l        [        5       U l	        U R                  5         g )NF)shape_inferenceinput_size_limitoutput_size_limitr  _opset_imports_counts_sizes	_modifiedr   _state_reset)re   r  r  r  r  s        r   r   FoldConstantsPass.__init__  sL      / 0!2&.0')&($$&r+   c                L    0 U l         0 U l        SU l        [        5       U l        g)z$Reset internal states for a new run.FN)r  r  r  r   r  r   s    r   r  FoldConstantsPass._reset  s!    $&r+   c                t   0 nSS jnSS jnUR                    Vs0 s H  oUc  M  UR                  U" U5      _M     nnUR                    Vs0 s H  oUc  M  UR                  U" U5      _M     nnUR                  5        VV	s0 s H  u  pU	c  M
  X_M     nnn	[        S UR	                  5        5       5      (       a!  [
        R                  SUR                  5        g  [        R                  R                  UR                  U R                  UR                     UR                  5      n
[        R                  R                  U
[        R                   R#                  U5      UU5      nUR$                   H  nUR                  U;   d  M  X+R                     n[        R                   R'                  U5      n[)        UR*                  U5      Ul        [        R                   R-                  U5      Ul        M     g s  snf s  snf s  sn	nf ! [0         a!  n[
        R                  SUU5         S nAg S nAff = f)Nc                    [        U SS9nUb8  U R                  c   e[        R                  R	                  U R                  5      $ g )N   r   )r   rS   r"   serdeserialize_tensor)rh  rA   s     r   get_constant_value;FoldConstantsPass._do_inference.<locals>.get_constant_value  s@    $Q26E }}000xx00??r+   c                    U R                   ba  [        R                  R                  U R                   5      nU R                  b)  [        R                  R                  XR                  5        U$ g r   )r   r"   r  serialize_typerT   serialize_shape_into)rA   
type_protos     r   get_type1FoldConstantsPass._do_inference.<locals>.get_type  sM    zz%XX44UZZ@
;;*HH11*kkJ!!r+   c              3  (   #    U  H  oS L v   M
     g 7fr   ru   )r   ts     r   r    2FoldConstantsPass._do_inference.<locals>.<genexpr>  s     7"6QDy"6rf  z?Skipping shape inference for node %r due to missing input type.z9Skipping shape inference for node %r due to exception: %s)rh  r   rx   zonnx.TensorProto | None)rA   r   rx   zonnx.TypeProto | None)r   r<   rE   r&   r(   rl   rm   r_   defs
get_schemar-   r  r1   r  infer_node_outputsr"   r  serialize_noderF    deserialize_type_proto_for_shaperU  rT   deserialize_type_proto_for_typer   rd   )re   r)   output_typesr  r  rh  input_types
input_datakrR  schemar   inferred_typeinferred_shaperr   s                  r   _do_inferenceFoldConstantsPass._do_inference  s   		 59KKQKq*qvvx{*KQ=A[[Z[3aff033[
Z'1'7'7'9K'9tqQdad'9
K7+"4"4"6777LLQ		--LL$"5"5dkk"BDKK  $33FFHH++D1	  #llF{{l2(4[[(A)+)R)R)* (5V\\>'R&(hh&N&N}&] +) RZK8  O sB   G<G<HH	HHB(H A0H 
H7H22H7c                   [        U[        R                  5      (       d!  [        R	                  SU[        U5      5        g[        R                  " U5      nX$l        UR                  U R                  :  a  SnUR                   HE  nUc  M  [        UR                  5       5      S:X  d  M'  [        U5      nUc  M7  XWR                  -  nMG     UR                  U-
  nUS:  a"  [        R	                  SUUR                  5        gU$ )a  
Shared helper for constant/init creation:
- Validates the folded Python value is a numpy ndarray.
- Wraps it in an ir.Tensor and names it.
- Applies output_size_limit logic with input-usage compensation.
Returns the ir.Tensor or None if it should be skipped.
zASkip storing constant folded value %s due to unsupported type %s.Nr   r8   z;Skip storing constant folded array %s due to large size %s.)rG   rJ   r   rl   infor   r"   rq  r<   r   r  r   rB   usesr   )	re   r)   output_nameoutput_arrayrq  removed_input_size	input_valinput_arrayincreased_sizes	            r   _prepare_folded_tensor(FoldConstantsPass._prepare_folded_tensor%  s     ,

33KKS\"
 <(! t555!"![[	)INN4D0E0J"29"=K".*.>.>>*	 )
 *..1CCN!Q %%
 r+   c           	     *   UR                   S   nU R                  XR                  U5      nUc  g[        R	                  SUR                  UR
                  UR                  5        [        R                  " SS/ [        R                  " SU5      4S9nU$ )z=Create a new Constant node with the given array as its value.r   Nz-New constant for value %s dtype: %s shape: %sr   r7   rA   )r   r'   )
rF   r  r<   rl   rm   r;   rT   r"   Node
AttrTensor)re   r)   rK   original_valuerq  s        r   new_constantFoldConstantsPass.new_constantM  s    a,,T3F3FN>;KKKK		
 wwr:bbmmGU[>\=^_r+   c                   UR                   S   nU R                  XR                  U5      nUc  g[        R                  " UR                  [        R
                  " [        R                  " UR                  5      5      UR                  US9n[        R                  SUR                  UR                  UR                  5        U$ )zACreate a new initializer value with the given array as its value.r   N)r<   r   rT   rS   z0New Initializer for value %s dtype: %s shape: %s)rF   r  r<   r"   r  r'  r   r;   rT   rl   rm   )re   r)   rK   r  rq  initializers         r   new_initializer!FoldConstantsPass.new_initializer_  s    a,,T3F3FN>hh$$r{{6<<89,,	
 	>KKKK		
 r+   c                   [        UR                  5       H  u  p4U R                  R                  U5      n[	        U[
        R                  5      (       d  MA  [        R                  SUR                  UR                  UR                  5        UR                  X55        SU l        M     [        US5      (       a  [        U5        O2U R                  (       a!  [        U5      (       d  U R!                  U5        UR"                  U R$                  ;  a,  [        R                  SUR                  UR"                  5        gU R$                  UR"                     n[&        R)                  UR"                  UR*                  U5      nU H  nU(       d   e[-        5       n	 U" XU R                  5      n
U
c  M/  [	        U
[2        5      (       a  U
s  $ [	        U
[
        R                  5      (       a  U
/n
[3        XR4                  5      s  $    [        US5      (       a!  [        R                  S
UR                  5        g[        U5      (       a7  [        R7                  SUR                  UR"                  UR*                  5        g[9        U5      (       a7  [        R7                  SUR                  UR"                  UR*                  5        g[;        S UR                   5       5      (       a!  [        R7                  SUR                  5        g[;        S UR                   5       5      (       a  gU R=                  U5      nUSL a!  [        R7                  SUR                  5        gUGc  [>         H6  n[        X5      (       d  M  [        R7                  SUR                  U5          g   UR                   Vs/ s H  ob  UR@                  OSPM     nnU Vs/ s H'  nUSL=(       a    URB                  U RD                  :  PM)     nn[;        U5      (       a  [G        UR                  5      [G        U5      :X  d   eUR"                  UR*                  4[H        ;   a,  [K        S [M        UR                  U5       5       5      (       a  O[        RO                  [P        RR                  5      (       a8  U Vs/ s H  nUc  M  URB                  PM     nn[        R7                  SUU5        gO [        R7                  SUR                  5        UR                   Vs/ s H  n[U        U5      PM     nnS nURV                  RY                  5        VVs0 s H  u  nnUU" U5      _M     nnn[Z        R\                  " UR"                  UR*                  U/UQ70 UD6nUc  g[G        UR^                  5      S:X  a  [	        U[`        [b        45      (       d  U(       a-  U Re                  UU5      nUc  g[3        UR^                  U/5      $ U Rg                  UU5      nUc  gURh                  c   eURh                  Rk                  U5        [3        U// 5      $ [        Rm                  SUR*                  5        g! [.         a:  n[1        SUR                  < SUR"                   SUR*                   S	35      UeSnAff = fs  snf s  snf s  snf s  snf s  snnf )zDProcess a node and return a Replacement if the node can be replaced.z%Node [%s]: Replacing input %s with %sTr7   zPSkipping constant folding for node %r due to missing opset import for domain %r.Nz'Error during constant folding for node z (z::)z.Skipping constant folding for Constant node %rzYSkipping constant folding for control flow op %r (%s::%s) because it is not supported yetz>Skipping constant folding for non-deterministic op %r (%s::%s)c              3  J   #    U  H  oc  M  UR                  5       v   M     g 7fr   )is_graph_inputr  s     r   r    1FoldConstantsPass.process_node.<locals>.<genexpr>  s     H;a!q!!;s   ##z[Skipping constant folding for node %r because it is graph input to preserve graph signaturec              3  F   #    U  H  oc  M  UR                   S L v   M     g 7fr   )rS   r  s     r   r    r    s     Kk$q}}$ks   !!FzHSkipping constant folding for node %r because should_fold returned FalsezHSkipping constant folding for node %r because %s is preserved by defaultc              3     #    U  H6  u  pUc  M
  [        UR                  5       5      S:H  =(       d    U(       + v   M8     g 7f)Nr8   )rB   	consumers)r   r   is_larges      r   r    r    s;      S+I BC)*a/ALA+Is
   	A 1A zBSkipping constant folding for node %r due to large input sizes: %sz:Constant folding node %r because should_fold returned Truec                    U R                   [        R                  R                  :X  a)  [        R                  R                  U R                  5      $ U R                  $ r   )r   r"   r#   TENSORr  r  rA   )avs    r   convert/FoldConstantsPass.process_node.<locals>.convert  s<    ww"**111xx00::88Or+   r8   z:Skipping constant folding for op %s with multiple outputs.)7	enumerater   r  r   rG   r"   r  rl   rm   r<   replace_input_withr  r5   rX   r  r*   r  r1   r  r   r   r-   RewriterContextrd   RuntimeErrorr   rZ   r  r3   r&   r  DEFAULT_CONSTANT_FOLD_BLACKLISTrS   r   r  rB   _DEFAULT_ALWAYS_FOLD_OPSr  rE  isEnabledForloggingINFOr   r'   rE   _reference_evaluatorrs   rF   r   r5  r  r  rK  register_initializerrn   )re   r)   is_functionr  rA   r   rg   op_optimizers	optimizercontextr   rr   r  r-   rh  input_tensorsrq  large_inputsinput_sizesinput_valuesr  r<   r   attr_valuesrF   r  new_initializer_values                              r   process_nodeFoldConstantsPass.process_nodew  s   !$++.HA11%8I)RXX..;IIJJNN	 ''5!% / tZ(("4(!!*=d*C*Ct$;;d111LLb		
 %%dkk2 224;;gV&I9%'G"4$++>
 !fk22!Mfbhh//$XF"6==99 '  tZ((LLI499Ut$$KKk			 #D))KKP			 H4;;HHHKKm		  KdkkKKK&&t,%KKZ		   ;t--KK5			   ; PT{{[{!mQ]]E{M[ ,+F d"Jv{{T5J5J'JJ+   <  4;;'3|+<<<<KK.2JJs S+.t{{L+IS P P  **7<<886C'6CFvKFKKm $ ' ` '
  - !0 KKL		
 6:[[A[(+[A	 >B__=R=R=TU=TztTtWT]*=TU&//KKw
1=
AL
 ?t||!*Wudm*L*L"//g>&";#6#6FF$($8$8w$G!$,::)))JJ++,AB 56;;NNLdll O  "=dii]"T[[MY[\`\h\h[iijkH \$' B Vs<   Y.4Z5.Z:0Z?;Z?[[	.
Z285Z--Z2c                   [         R                  SUR                  UR                  UR                  5        [        X5        UR                   Vs/ s H	  oDc  M  UPM     nn[        R                  R                  X1U/UR                  UR                  UR                  5        [        U[        R                  5      (       a  UR                  b   e[!        U5        SU l        g s  snf )NzReplacing node: %s::%s %sT)rl   rm   r1   r-   r<   r  r   r"   conveniencereplace_nodes_and_valuesr   rF   r   rG   GraphrK  _clear_unused_initializersr  )re   r)   r  rootrR  node_inputss         r   replace_nodeFoldConstantsPass.replace_node&  s     	0$++t||TYYW 	$D6 #'++?+Qq+?
// 5 5t||[E\E\	
 dBHH%%::%%%&{3 @s   C%C%c                b   UR                  5       (       a  g UR                  [        R                  R                  :X  a   U R                  UR                  5       5        g UR                  [        R                  R                  :X  a)  UR                  5        H  nU R                  U5        M     g g r   )	is_refr   r"   r#   r$   visit_graphrC  r%   	as_graphs)re   r   rK  s      r   visit_attribute!FoldConstantsPass.visit_attribute@  sx    ;;==99((...T]]_-YY"**111)  ' * 2r+   c                    [        U[        R                  5      nU R                  XS9nUc3  UR                  R                  5        H  nU R                  U5        M     g U R                  XU5        g )N)r  )rG   r"   Functionr'  r'   r(   r6  r0  )re   r)   r.  r  r  r   s         r   
visit_nodeFoldConstantsPass.visit_nodeI  sc     r{{3'''F..0$$T* 1d6r+   c                h   U H  nU R                  X!5        M     [        UR                  5       H  u  p4Uc  M
  U R                  R	                  U5      n[        U[        R                  5      (       d  MF  [        XU5      (       d  MY  UR                  Ul	        XQR                  U'   SU l
        M     g )NT)r:  r  rF   r  r   rG   r"   r  #_sym_value_can_replace_graph_outputr<   r  )re   rK  r)   r  r   r   s         r   r4  FoldConstantsPass.visit_graphT  s    DOOD( 
 #5==1IA~11&9Ii226uPP#[[IN(MM!!DN 2r+   c                8    U H  nU R                  X!5        M     g r   )r:  )re   r   r)   s      r   visit_function FoldConstantsPass.visit_functionh  s    DOOD+ r+   c                2   U R                  5         UR                  U l        U R                  UR                  5        UR
                  R                  5        H  nU R                  U5        M     [        XR                  U R                  R                  5      $ r   )r  opset_importsr  r4  rK  	functionsr(   r@  FoldConstantsResultr  r  r   )re   modelr   s      r   callFoldConstantsPass.calll  sm    #11%..0H) 1 #5..$++:X:XYYr+   )	r  r  r  r  r  r  r  r  r  N)
r  r   r  rw   r  rw   r   Callable[[ir.Node], bool | None]rx   r   )rx   r   r)   ir.Noderx   r   )r)   rK  r  rv   r  np.ndarray | Anyrx   zir.Tensor | None)r)   rK  rK   rL  rx   zir.Node | None)r)   rK  rK   rL  rx   r   )r)   rK  r  r   rx   zReplacement | None)r)   rK  r  r   r.  ir.Graph | ir.Functionrx   r   )r   zir.Attrrx   r   )r)   rK  r.  rM  rx   r   )rK  ir.Graphrx   r   )r   zir.Functionrx   r   )rF  ir.Modelrx   rE  )ry   rz   r{   r|   r   r   r  r  r  r  r  r'  r0  r6  r:  r4  r@  rG  r}   ru   r+   r   r   r     s    
$ 9J  	
  6 
('6p&&*-&=M&	&P$0m^*5=S	4(	7"(,Zr+   r   c                x    UR                  5       =nc  gUR                  U La  gUR                  5       (       a  gg)NFT)producerrK  is_graph_output)rK  r   r   rQ  s       r   r=  r=  v  sC     &&((1 ~~U"  "" r+   c                n   U  H  nUb  UR                  5       (       d  M  UR                  5       (       a  M4  UR                  5       (       a  MK  UR                  5       (       d   eUR                  c   eUR                  c   eUR                  R
                  R                  UR                  5        M     g r   )is_initializerr  rR  rK  r<   initializerspop)r(   rA   s     r   r-  r-    s    = 4 4 6 6

u'<'<'>'>''))));;***::)))KK$$((4 r+   c                  *    \ rS rSr% S\S'   SS jrSrg)rE  i  r   r   c                    U R                   $ r   )modifiedr   s    r   __bool__FoldConstantsResult.__bool__  s    }}r+   ru   N)rx   r   )ry   rz   r{   r|   r   rZ  r}   ru   r+   r   rE  rE    s    55r+   rE  Fc                    g r   ru   r2   s    r   r  r    s    r+   )onnx_shape_inferencer  r  r  c               *    [        UUUUS9nU" U 5      $ )a`  
Applies constant folding optimization to the model.

Args:
    model: The ONNX model to optimize.
    onnx_shape_inference: Whether to enable ONNX shape inference during
        constant folding. Defaults to False.
    input_size_limit: The maximum size of input tensors
        that can be considered for constant folding. Defaults to
        `DEFAULT_CONSTANT_FOLD_INPUT_SIZE_LIMIT`.
    output_size_limit: The maximum size of output tensors
        that can be stored after constant folding. Defaults to
        `DEFAULT_CONSTANT_FOLD_OUTPUT_SIZE_LIMIT`.
    should_fold: An optional function that takes a node and returns True if
        the node should be considered for folding, False if it should not be folded,
        or None to use the default rules. Defaults to a function that always returns None.

Returns:
    An instance of `FoldConstantsResult`.

)r  r  r  r  )r   )rF  r]  r  r  r  folder_passs         r   r   r     s'    : $,)+	K ur+   )r)   rK  rx   r   )r)   rK  r-   rv   rx   r   rJ  )rZ   zIterable[ir.Node]rx   r   )r   ir.Shaper   r`  rx   r   )NN)r   r   r;   zir.DataType | Noner   r   rx   znp.ndarray | None)r   r   rx   zbool | None)r)   rK  r   rw   rx   r   )r)   rK  r   rw   rx   rw   r   )r)   rK  r<   rv   r   r   rx   r   )r)   rK  r   r   rx   ReturnValue)r  r   r  r   rx   r   )r  rK  r  r   rx   r   )rK  rN  r   r   r   r   rx   r   )r(   r   rx   r   )rF  rO  r]  r   r  rw   r  rw   r  rI  rx   rE  )\
__future__r   __all__dataclassesr  r  rP   r   r	   r
   r   r   r   rJ   r_   onnx.reference.opsonnx_irr"   onnxscript.utils.utilsr/   onnxscript.irr   r  &DEFAULT_CONSTANT_FOLD_INPUT_SIZE_LIMIT'DEFAULT_CONSTANT_FOLD_OUTPUT_SIZE_LIMITr   	frozensetr.   r  	getLoggerry   rl   r*   r3   r5   rX   r   r\   r  	dataclassr   r  r5  r   r   r   Builderr  ra  r  r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r   r#  rQ   r/  rT   r   rS  rX  r[  rl  rx  r}  r  r  r  rU  r  passesInPlacePassr   r=  r-  
PassResultrE  r   ru   r+   r   <module>rr     s   #     ; ;     & & #  *. &*3 ' 9 #  %  
		8	$N
XI&'R% ( *+  ! ! !$ bhhRXX89 L --K"((!3RXXtCD#RWWo~$NP[$[\  
 
 
&! !H &>%?
" ?& VZ(	(!3(HR((V' 
%B B4 
% " 
( : 
)3 3, 
)3 3
 
&   
*	3 	3 
' $ 
&' ' 
$& &R 
* , 

  
(8 8v 
)Z( )@ 
( . 

  < 

j/ j/Z 
, *$3B:O$nZ		-- nZb (2:	$
5 "))..   "'BD4E## # 	#
 # 2# #r+   