
    -Ph|                       d dl Z  e j        eeeeeeeeeeeeeee           d dlZd dlZd dlZd dlZd dlmZ ddl	m
Z
 ddlmZmZ eefZddl	mZ ddl	mZ dd	l	mZ dd
l	mZ ddl	mZ ddl	mZ ddl	mZ ddlmZmZ ddlmZmZmZ ddlmZm Z  ddl!m"Z" ddl	m#Z# d dl$m%Z% d Z&ej'        ej(        ffdZ)d Z*d Z+d Z, G d dej-                  Z.d Z/d Z0 G d dej1                  Z2 G d  d!ej1                  Z3 G d" d#ej4        e"          Z5 G d$ d%ej4                  Z6 G d& d'ej1                  Z7 G d( d)ej8        ej1                  Z9 G d* d+ej8        ej:                  Z;d, Z< ej=        d-d.          Z> ej=        d/d.          Z? G d0 d1ej4        e"          Z@ G d2 d3ej1        ej8                  ZA G d4 d5ejB                  ZCdS )6    N)UtilityCodeEncodedStringbytes_literalencoded_stringNodes	ExprNodes
PyrexTypesBuiltin	UtilNodes_py_int_typesrecopycodecs	itertools
attrgetter)r      )	TypeSlots)UnicodeNodenot_a_constant)r   )r   )r	   )Visitor)r
   )r   )Options)r   TempitaUtilityCode)r   r   r   )errorwarning)SkipDeclarations   )Utils)reducec                 ,    t          j        | d          S )N
Optimize.c)r   load_cached)names    X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/Cython/Compiler/Optimize.pyload_c_utilityr$   %   s    "4666    c                 4    t          | |          r| j        S | S N)
isinstancearg)nodecoercion_nodess     r#   unwrap_coerced_noder,   )   s     $'' xKr%   c                 |    t          | t          j                  r!| j        } t          | t          j                  !| S r'   )r(   r   ResultRefNode
expressionr*   s    r#   unwrap_noder1   /   s:    
T92
3
3  T92
3
3 Kr%   c                    t          |           } t          |          }t          | t          j                  r*t          |t          j                  r| j        |j        k    S t          | t          j                  rLt          |t          j                  r2| j         o)t          | j        |j                  o| j	        |j	        k    S dS NF)
r1   r(   r   NameNoder"   AttributeNode
is_py_attris_common_valueobj	attribute)abs     r#   r7   r7   5   s    AAAA!Y'((  Z9;M-N-N  v!Y,-- a*Q	@W2X2X a<`OAE15$A$A`akUVU`F``5r%   c                     | 	| j         d S | S r'   )constant_resultr0   s    r#   filter_none_noder>   ?   s    D08tKr%   c                   N    e Zd ZdZd Zej        j        Zd Z	d Z
d Zd Zd ZdS )	_YieldNodeCollectorz9
    YieldExprNode finder for generator expressions.
    c                 `    t           j                            |            i | _        g | _        d S r'   )r   TreeVisitor__init__yield_stat_nodesyield_nodes)selfs    r#   rC   z_YieldNodeCollector.__init__I   s/    $$T*** "r%   c                 d    | j                             |           |                     |           d S r'   )rE   appendvisitchildrenrF   r*   s     r#   visit_YieldExprNodez'_YieldNodeCollector.visit_YieldExprNodeP   s3    %%%4     r%   c                 n    |                      |           |j        | j        v r|| j        |j        <   d S d S r'   )rI   exprrE   rD   rJ   s     r#   visit_ExprStatNodez&_YieldNodeCollector.visit_ExprStatNodeT   sC    4   9(((/3D!$),,, )(r%   c                     d S r'    rJ   s     r#   visit_GeneratorExpressionNodez1_YieldNodeCollector.visit_GeneratorExpressionNode[       r%   c                     d S r'   rP   rJ   s     r#   visit_LambdaNodez$_YieldNodeCollector.visit_LambdaNode^   rR   r%   c                     d S r'   rP   rJ   s     r#   visit_FuncDefNodez%_YieldNodeCollector.visit_FuncDefNodea   rR   r%   N)__name__
__module____qualname____doc__rC   r   rB   rI   
visit_NoderK   rN   rQ   rT   rV   rP   r%   r#   r@   r@   E   s           
 $2J! ! !4 4 4        r%   r@   c                 Z    t          |           }t          |          dk    rdS |d         S )Nr   )NNr   )_find_yield_statementslen)r*   yield_statementss     r#   _find_single_yield_expressionr`   e   s4    -d33
!!zAr%   c                     t                                          |            	 fdj        D             }n# t          $ r g }Y nw xY w|S )Nc                 8    g | ]}|j         j        |         fS rP   )r)   rD   ).0
yield_node	collectors     r#   
<listcomp>z*_find_yield_statements.<locals>.<listcomp>p   s8     
 
 
 ^Y7
CD
 
 
r%   )r@   rI   rE   KeyError)r*   r_   re   s     @r#   r]   r]   l   s    #%%ID!!!
 
 
 
'3
 
 
     s   : A	A	c                      e Zd ZdZd Zd Zd"dZd Zd"dZ e	j
        e	j         e	j        dej        d	          gd
          Z e	j
        e	j         e	j        dej        d	          gd          Zd"dZ e	j
        e	j         e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	          g          Z e	j
        e	j         e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	          gd          Zd"dZd"dZd Zd Zd"dZ d Z!d Z" e	j
        e	j         e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	          g          Z# e	j
        e	j         e	j        de	j        d	           e	j        de	j        d	           e	j        de	j        d	           e	j        d e	j        d	          g          Z$d! Z%d	S )#IterationTransforma   Transform some common for-in loop patterns into efficient C loops:

    - for-in-dict loop becomes a while loop calling PyDict_Next()
    - for-in-enumerate is replaced by an external counter variable
    - for-in-range loop becomes a plain C for loop
    c                 b   |                                 r|j        }t          j        |          }|j        j        r|j        j        j        j        }n|j        j        j        }t          j	        |          }|
                    |          }t          j        |d|j        |          }t          j        |t          j        ||t          j        |d                    t          j        |          g          }t          j        |t          j        |||          gd           }	t          j        ||gt          j        ||t          j        |j        j        |j        	          |	t          j        ||t          j        |d
                                        }
|
                    |                                           }
|                     |
          }
t          j        ||
          }|j        dk    rt          j        ||          }|S |                     |           |S )N==)operatoroperand1operand2r   valuelhsrhsstats	conditionbody)
if_clauseselse_clause)sequencer   )targetiteratorrx   rz   tempsrx   not_inoperand)is_ptr_containsposr   r.   rn   is_subscriptbasetype	base_type
TempHandlerefr   PrimaryCmpNoderm   r   StatListNodeSingleAssignmentNodeBoolNodeBreakStatNode
IfStatNodeIfClauseNodeTempsBlockNodeForInStatNodeIteratorNodeanalyse_expressionscurrent_envvisitTempResultFromStatNoderl   NotNoderI   )rF   r*   r   
result_refr   target_handler|   cmp_nodeif_bodyif_nodefor_loopnew_nodes               r#   visit_PrimaryCmpNodez'IterationTransform.visit_PrimaryCmpNode   s=   !! .	 (C"066J}) 9 M.3=		 M.8	%0;;M"&&s++F /dT]VM M MH(3CZYM_`cklMmMmMmnnn,S1134 4 4G &!.shWUUUV " " "G !/&*!&3DM4EPTP]^^^  % :3JT]TfgjrsTtTtTt u u uw w wx x xH  33D4D4D4F4FGGHzz(++H 7
HMMH}(($,S(CCCO t$$$Kr%   c                 l    |                      |           |                     ||j        j                  S r'   )rI   _optimise_for_loopr}   r{   rJ   s     r#   visit_ForInStatNodez&IterationTransform.visit_ForInStatNode   s1    4   &&tT]-CDDDr%   Fc                 	   d }|j         s|j        r2|j        r+|j        j        r|j        j        j        }|j        r|j        }t          j        |j	        |fv r|r|S | 
                    ||d dd          S t          j        |j	        |fv st          j        |j	        |fv r|r|S |                     ||          S |j	        j        s|j	        j        r|                     |||          S |j	        t          j        u r|                     |||          S |j	        t          j        u r|                     |||          S |j	        t          j        u r|                     ||d|          S t/          |t0          j                  r/|j        j	        j        r|                     ||j        d|          S t/          |t0          j                  s|S |j        #|j        rt?          |j        j                  pd}n"t?          |j                  }|r|j         |dz  }|j!        }|j        r|s|s|j         p|j"        }|j#        }	| $                                j%        j&        dk    }
|
sL|	d	v rHt/          |t0          j'                  r.|j!        }|j         r |j(        d
k    r|j        r|j        j)        rd}
dx}}|	dk    s|
r	|	dk    rd}n#|	dk    s|
r	|	dk    rd}n|	dk    s|
r
|	dk    rdx}}|s|r| 
                    |||	||          S |j         d|j         r]|j        rV|j        j)        rJ|j(        dk    r|r|S | *                    ||          S |j(        dk    r|r|S | +                    ||          S tX          j-        rd|cxk    rdk    rn n|j         |j         r|j(        dv r|j        r|j        j)        r|j.        j	        j/        s|j.        j	        j0        r| 1                    |||          S |j.        j	        j2        rz|j        |j        j        n|j        D ]G}t/          |t0          j3                  r*|4                                rd|j5        cxk    rdk     rn nF n| 1                    |||          S |S )NTF)dict_objmethodkeysvaluesreversed)
is_mutabler   r   r      )r   r   itemsdictiterkeysr   
itervaluesr   	iteritemsr   	enumerater   )rangexrange      @)6is_nameis_attributeentry
annotationrM   r   r   r
   	dict_typer   _transform_dict_iterationset_typefrozenset_type_transform_set_iterationis_ptris_array_transform_carray_iteration
bytes_type_transform_bytes_iterationunicode_type_transform_unicode_iterationbytearray_type_transform_indexable_iterationr(   r   CoerceToPyTypeNoder)   is_memoryviewsliceSimpleCallNodeargs	arg_tupler^   rF   functionr8   r9   global_scopecontextlanguage_levelCallNoder"   
is_builtin_transform_enumerate_iteration_transform_reversed_iterationr   convert_ranger|   is_intis_enum_transform_range_iterationis_pyobjectIntNodehas_constant_resultr=   )rF   r*   iterabler   annotation_typer   	arg_countr   base_objr   is_safe_iterinner_functionr   r   r)   s                  r#   r   z%IterationTransform._optimise_for_loop   s    	- 5 	-8> 	-hnNg 	-!27J& -'_
 @@@ 11x4 2 O O O  @@@&8=/*JJJ 00x@@@ = 	W8=#9 	W33D(X3VVV=G...224H2UUU=G00044T8h4WWW =G22266tXRVai6jjjh	 <== 	p(,BSBf 	p66tX\V[fn6ooo (I$<== 	K=  *Ks83E3J/K/KPqIIHM**I X]6Q	$  	: 	:) 	:}4H'F,,..6EJL ,F.I$I$Ih	(:;; ,%-%6N&. ,>3F&3P3P . 4 4Q . 4 ? 4Q (,!!D6###69I9I<''L'Vx=O=O;&&<&Fg<M<M $$v :v :55(FD&: : : = X%5 ~ !"*."; !}++  K::4JJJ*,,  K99$III   	^Q)%8%8%8%8q%8%8%8%8%8%  &%-]6I%I%I &J#+>#< &J{& Z$+*:*B Z66tXPX6YYY{+ ^7?}7LH.33RZR_ ^ ^C!#y'899 %2244 %3CV9^9^9^9^Y^9^9^9^9^9^$E::4T\:]]]r%   c                    |j         j        }t          |          dk    rt          |j        d           |S t          |          dk    rt          |j        d           |S |d         }|j        t          j        t          j        fv r-|	                    d          |j
        _        d|j
        _        |S |                     ||d          S )Nr   z(reversed() requires an iterable argumentr   z#reversed() takes exactly 1 argument!'NoneType' object is not iterableTr   )r   r   r^   r   r   r   r
   
tuple_type	list_typeas_none_safe_noder}   r{   r   r   )rF   r*   reversed_functionr   r)   s        r#   r   z0IterationTransform._transform_reversed_iteration$  s     */t99>>#'<> > >KYY]]#'79 9 9K1g 8*G,=>>>%(%:%:;^%_%_DM"%)DM"K&&tS4&@@@r%   c                    t          j        |                    d          dd          t          j        j        ddt          j                  }fd}t          j         |            t          j        d	          }|}|r
d
\  }	}
||}}nd\  }	}
t          j        j        t          j                  }t          j        |j        |          }t          j
        j        j        j        |          }|                                 }t          j        |j        dd          }t          j        |j        ||          }t          j        j        |g          }|r>t          j
        j        | |                      }|j                            |           t          j        j        ||	||
|d|j        d
  
        }t          j        t          j        |t          j        j        t          j        ||                                                            |          }|j                            dj                   |S )zWIn principle can handle any iterable that Cython has a len() for and knows how to index'NoneType' is not iterableFT)may_hold_noneis_temp0r   rp   r=   r   c                      t          j        j        dt          j                            d                    } t          j        j        | g          S )Nr^   )r"   r   r   r   )r   r4   r   r
   builtin_scopelookupr   )builtin_lenr*   unpack_temp_nodes    r#   make_length_callzKIterationTransform._transform_indexable_iteration.<locals>.make_length_callA  s_    #,TXE3:3H3O3OPU3V3VX X XK+DH-8*:);& & & &r%   )r   r   >>=<=<r   r   )r   indexr   rr   rs   )boundscheck
wraparound)
directivesrx   rt   rq   N	bound1	relation1r|   	relation2bound2steprx   rz   
from_rangerM   r   )r   
LetRefNoder   r   r   r   r	   c_py_ssize_t_type	IndexNoder   r   r|   r   r   copy_inherited_directivesr  CompilerDirectivesNoder   ru   rH   ForFromStatNoderz   LetNodeExprStatNoder   r   insertrx   )rF   r*   
slice_noder   r   
start_noder   length_tempend_noder  r  counter_reftarget_valuetarget_assignenvnew_directivesrx   loop_length_reassign	loop_noderetr   s    `                  @r#   r   z1IterationTransform._transform_indexable_iteration8  s   $/(()EFF  
 &HC9UW W W
	& 	& 	& 	& 	& 	&  *+;+;+=+=JD`jnooo 	-#, Iy#+ZJJ#, Iy*txj>Z[[[ *:>@P1<> > > 2+/+         :3>W\inooo4%
 
 
 !H"O% % %  	4
 $)#=dh>I>N>N>P>P$R $R $R  J2333)HD(  	 $%# *48!*!A$/$-" "     &%c** 	 	
!TY'''
r%   sNNULLexception_valuec                    |j         j        }|j        s|t          j        ur|S t          j        |                    d                    }t          j	        |j
        d| j        |gd          }t          j	        |j
        d| j        |gd          }t          j        ||                     |t          j        |j
        |d d ||j        d          |                    S )Nr   __Pyx_PyBytes_AsWritableStringr   r   r   __Pyx_PyBytes_GET_SIZE)r   startr  stopr   r   r   )r|   r   r   r
   r   r   r  r   r   PythonCapiCallNoder   PyBytes_AS_STRING_func_typePyBytes_GET_SIZE_func_typer  r   SliceIndexNode)rF   r*   r  r   target_typer   slice_base_nodelen_nodes           r#   r   z-IterationTransform._transform_bytes_iteration  s   k&! 	k9K&K&K K$/(()EFFH H $6N<,$%	   /N4+$%	    ,,(N* #*/   $ - % %& & 	&r%   kinddatar   lengthc                 b	   |j         r	 t          |j                            d          d          }t	          j        |j        t	          j        |j        ||t          j	                  
                    t          j        |                                           d t	          j        |j        t          t          |                    t          |          t          j                  t"          j                  }|                     |||          S # t(          $ r Y nw xY wt+          j        |                    d                    }t	          j        |j        ddt          j                  }t+          j        t          j                  }|                    |j                  }	|r
d\  }
}|	|}	}nd	\  }
}t+          j        t          j                  }t+          j        t          j                  }t+          j        t          j                  }t	          j        |j        d
| j        |                    |j                  |                    |j                  |                    |j        j                  gd          }|j        |j        j        k    r2|
                    |j        j        |                                           }tA          j!        |j        j        |j        |          }tA          j"        |j        ||j#        g          }tA          j$        |j        ||
|                    |j        j                  ||	d ||j%        d
  
        }tA          j&        |j        t	          j        |j        d| j'        |t	          j(        |j        |                    |j                  t          j)                  t	          j(        |j        |                    |j                  t          j*                  t	          j(        |j        |                    |j                  t          j+                  gddtY          j-        dd                              }t+          j.        |t+          j/        |j        ||||gtA          j"        |j        ||g                              S )Nlatin1z	iso8859-1r   )r   r)  r*  r   r   r   r   r   r   __Pyx_PyUnicode_READFr'  r   rt   Tr  __Pyx_init_unicode_iterationr   r   unicode_iterr    )r   r   result_is_usedutility_coder
  r~   )0
is_literalr   rp   encoder   r.  r   	BytesNoder	   c_const_char_ptr_type	coerce_toc_const_uchar_ptr_typer   r   strr^   r  r
   r   r   UnicodeEncodeErrorr   r  r   r   r   
c_int_typec_void_ptr_typer+  PyUnicode_READ_func_typer|   r   r   r   r   rx   r  rz   r   init_unicode_iteration_func_typeAmpersandNodec_py_ssize_t_ptr_typec_void_ptr_ptr_typec_int_ptr_typer   r!   r  r   )rF   r*   r  r   bytes_valuebytes_slicer   r  r  r  r  r  	kind_temp	data_tempcounter_tempr  r  rx   r  
setup_nodes                       r#   r   z/IterationTransform._transform_unicode_iteration  s     	UU+J,<,C,CH,M,M{[[ (6N","k(3'=? ? ? @Iy&=t?O?O?Q?Q@S @S"*"c#k2B2B.C.C(+K(8(8'9; ; ; !-   77k8TTT# &   & %/(()EFFH H &HC9UW W W
*:+GHH??48,, 	-#, Iy#+ZJJ#, Iy()>??	()CDD	 +J,HII 3N2)MM*.11MM*.11 $$T[_557     000'11$+2B262B2B2D2DF FL2+/+      !H"DI.0 0 0 )H##DKO44D(  	 'H/ >5(!/
XbXfHgHg5?5UW W W!/
	V`VdHeHe5?5SU U U!/
	V`VdHeHe5?5NP P P !&(4^\RR    
"  ${Iy Q'Y8OPPPR R RS S 	Ss   (D 
DDc                    d}t          |t          j                  rX|j        }t	          |j                  }t	          |j                  }d }|s#|j        j        st          |j
        d           |S n|j        r0t          |j        t          j                  sJ |j        }|j        }	t	          |	j                  }t	          |	j                  }t	          |	j                  }|rt          |j        t                     r%|j        dk    s|j        dk    r|r|j        dk     r%|s#|j        j        st          |j
        d           |S |j        }
|r|
 }
|
dk     }t          j        |j
        t$          j        t)          t+          |
                    t+          |
                    }n|j        j        rr|j        j        t          |j
        d           |S |}d }t          j        |j
        t)          |j        j                  t$          j        |j        j                  }d }n#|j        j        st          |j
        d           |S |r2|                    t$          j        |                                           }|r2|                    t$          j        |                                           }|A|r(t          j        |j
        dt$          j        d          }nt          |j
        d           |S |r-|s't          j        |j
        d	dt$          j        
          }||}}|j        }|j        r|                                }|                    |                                           }|r*|j        dk    rt          j        |j
        |d||          }n|}|ra|j        dk    rVt          j        |j
        t          j        |          d||                              |                                           }nt          j        |          }t=          j        |          }|                     |j!        j
                  }|j        j"        r|j!        j        j        r|j        tF          j$        u rut          j%        t          j&        |j!        j
        ||j'                  t$          j(                                      |j!        j        |                                           }nt          j        |j!        j
        t          j        |j!        j
        d	dt$          j)        
          t          j        |j!        j
        ddt$          j)        
          |tF          j*        d          }n|j!        j        j+        r'|j!        j        ,                    |j'                  s|}nQt          j-        |j!        j
        t          j        |j!        j
        d	dt$          j)        
          ||j'                  }|j        |j!        j        k    r2|                    |j!        j        |                                           }t]          j/        |j!        j
        |j!        |          }t]          j0        |j
        ||j1        g          }| 2                    ||          \  }}t]          j3        |j
        ||||||||j4        d
  
        }t=          j5        |j
        |g|          S )NFz*C array iteration requires known end indexr   z8C array iteration requires known step size and end indexr   rp   r=   rp   r   r=   -1r$  r   r   +rm   rl   rn   r   r9  1r   )r)  r*  r   r   r   )r   r   r   r   rt   Tr  r~   )6r(   r   r.  r   r>   r)  r*  r   r   r   r   r   r   	SliceNoder  r=   intr   r	   r  rC  absr   sizerA  r   element_ptr_typecoerce_to_simpleAddNode	CloneNoder   r   r   r|   	is_stringr
   r   CastNodeDereferenceNoder   c_py_ucs4_typerE  r   r   assignable_fromr  r   r   r   rx   _find_for_from_node_relationsr  rz   r   )rF   r*   r  r   neg_step
slice_baser)  r*  r  r   
step_valueptr_type
carray_ptrstart_ptr_nodestop_ptr_nodecounterrQ  r  r  rx   r  r  for_nodes                          r#   r   z.IterationTransform._transform_carray_iteration,  s&   j)":;; 1	#J$Z%566E#JO44DD !2 X*.*VWWW
 $ '	j.	0CDDDDD#J$E$U[11E#EJ//D#EJ//D N!$"6<< N.!33.2242.2252%?6 ddh(bcccK "&!5J 1&0[
)A~H$,TXJ<X36s:3G3G=@__N N ND _% 	#+jn&RSSS#JE$c*/*>&?&?1:?CWY Y YD DD ?. Tjn&RSSSK 	VOOJ$@$BRBRBTBTUUE 	T>>*">@P@P@R@RSSD<  (N$Z5Qceg g g jn&`aaa 	& M!)*.VW/9/KM M M 4E? 	30022H001A1A1C1CDD
 	(U*a//&.	#  NN (N 		<D(A--%-",Z88   #"4#3#3#5#566 M &/
;;M&x00{{4;?33?$ !	))9)E !	)'"666(1-%/1 1 1 -	 /  / 09y($*:*:*<*<0> 0>	   )7KO#+DKO3<=1;1FH H H #*4;?#;<0:0EG G G & +
  
  
  [$ 	)T[-=-M-MhN`-a-a 	)'LL %.'s89-7-BD D D "') ) )L  000'11$+2B262B2B2D2DF FL 2+/+     
 !H"DI.0 0 0  $AA(HUU	9(H!YD(   'HWI   	r%   c           
      <   |j         j        }t          |          dk    rt          |j        d           |S t          |          dk    rt          |j        d           |S |j        j        s|S |j        j        }t          |          dk    r|S |\  }}|j        }|j        s	|j	        s|S t          |          dk    r<t          |d                                       ||                                           }nt          j        |j        d|d          }t          j        |          }	t          j        |j        |	t          j        |j        d|d          d	||j        
          }
t%          j        |j        ||	          t%          j        |j        |	|
          g}t)          |j        t$          j                  r||j        j        z   |j        _        n?|                    |j                   t%          j        |j        j        |          |_        ||_        |j                            |j        |                                           |_        |d         |j        _        t          j        |	|                     ||j        j                            S )Nr   z)enumerate() requires an iterable argumentr   z%enumerate() takes at most 2 argumentsr   r   rU  rY  rW  )rm   rn   rl   r   r   r   rt   )r   r   r^   r   r   r|   is_sequence_constructorr   r   r   r,   rA  r   r   r   r   r  r`  r   r   r(   rx   r   ru   rH   itemr}   r{   r  r   )rF   r*   enumerate_functionr   targetsenumerate_targetiterable_targetcounter_typer)  tempinc_expression	loop_bodys               r#   r   z1IterationTransform._transform_enumerate_iteration  s   !+0t99>>$(=? ? ?KYY]]$(9; ; ;K{2 	K+"w<<1K,3)/',' 	0C 	Kt99>>'Q00::<IYIYI[I[\\EE%&8&<,/+7679 9 9E #E**"*" (.:9:< < < ".
 
 
 &&*&   &&*$& & &		 di!344 	#'$)/9DIOOTY'''*	!# # #DI &I''(<d>N>N>P>PQQ	!%a  t'>'>tT]E['\'\]]]r%   c                     |r|rdS dS |rdS dS )N)r   r   r   )r   r   r   rP   )rF   neg_step_valuer   s      r#   rg  z0IterationTransform._find_for_from_node_relations  s.     		! ! y y ! y yr%   c                    |j         j        }t          |          dk     r!|j        }d}t	          j        |dd          }n^|d         }|j        }t          |j        t                    s|S |j        }|dk    r|S t	          j        |t          |          |          }t          |          dk    rJt	          j        |j        dd          }|d         
                    |                                           }	nZ|d         
                    |                                           }|d         
                    |                                           }	|                     |dk     |          \  }
}d }|r|	|}	}t          |          }|dk    rt          |j        t                    rt          |	j        t                    r|dk     r#|	j        }|j        }||||z
  dz
  |z  z  z
  dz
  }n"|j        }|	j        }||||z
  dz
  |z  z  z   dz   }t	          j        |j        t          |          |t          j        |j        |	j                            }n,t#          j        |	          }|                     ||||          }|dk     r| }t          |          |_        ||_        |
                    |                                           }|	j        sd	}|pt#          j        |	          }	nd
}t-          j        |j        |j        ||
||	||j        |j        d	
  
        }|                    |                                            |rt#          j        |	|          }|S )Nr   r   rY  rp   r=   r   r   r   r   TF)	r|   r  r  r  r  r  rx   rz   r	  )r   r   r^   r   r   r   r(   r=   r[  rC  coerce_to_indexr   rg  r\  r	   spanning_typer   r   r  _build_range_step_calculationrp   r=  r   r  r|   rx   rz   set_up_loopr  )rF   r*   range_functionr   r   step_posrj  r  r  r  r  r  bound2_ref_nodeabs_stepbegin_value	end_valuebound1_valuebound2_is_temprp  s                      r#   r   z-IterationTransform._transform_range_iteration%  s   ',t99q==%)HJ$XS!LLLDD7DxHd2C88 -JQ$XS__5?A A AD t99>>&~'978: : :F!W,,T-=-=-?-?@@FF!W,,T-=-=-?-?@@F!W,,T-=-=-?-?@@F#AA*q.RZ[[	9 	C#VFF:H1}}v5s;; C"6#93??C "A~~&,&<$*$:	'2X+PYBY\]B]bjAj5k'kno'o&,&<$*$:	'08i@WZ[@[`h?h3i'ilm'm&.
#l*;*;\'5fk6;OOQ Q QFF
 '0&:6&B&BO!??zC CF >>$J__
)##D$4$4$6$677  	#!N$D	(<V(D(DFF"N(H;YDI(   	T--//000 	; (::Hr%   c                 |   t          |          }t          j        |j        |j                  }|j        j        r&|dk     r t          j        |t          j                  }nt          j        ||j                  }|dk     r|}|}	d}
n|}|}	d}
t          j        |j        t          j        |j        ||
t          j	        |j        t          j
        |j        t          |          ||          dt          j        |j        t          j        |j        t          j        |j        |d|	|          dt          j
        |j        dd	
          |          dt          j
        |j        t          |          ||          |          |          |          |
t          j
        |j        dd	
          |          }|S )Ni  r   -rW  r   *rX  rY  r   r  z//)r\  r	   r  r   r   rE  r   
binop_noder   MulNoder   rC  DivNodeSubNode)rF   r  r  r  rj  r  r  spanning_step_typer  r  final_opstep_calculation_nodes               r#   r  z0IterationTransform._build_range_step_calculationx  s   z??"0o>RSS9 	T6 1 1!+!9-I^!_!_!+!9-!S!S>>)KIHH K'IH ) 4J)
(!"*J&.
!(mm(0/	1 1 1
 !&.
!*!2"J%.%6 &
)4),)2%2&4 &4 &4 &)%.%6 &
&)01&3 &3 &3 "4"5 "5 "5 "&!*!2"J"%h--,4!3	"5 "5 "5
 0-1 1 1. ,?- - -@ (I$) $) $)J &
 !# # # Y,!  ,!  ,! Z %$r%   c                 v   g }t          j        t          j                  }|                    |           |                    |j                  }t          j        t          j                  }|                    |           |                    j                  }	d x}
x}}|rE|rCj        j	        r/t          j        j                  dk    rj        j        \  }
}nS j        }n|rj        }
nj        }t          j        t          j                  rj        }n&t          j        j        j        j        g          }t          j        t          j                  }|                    |           t!          j        j        |                    |j                  t          j        |j                            }t          j        t          j                  }|                    |           |                    j                  }t!          j        j        |t          j        |j                            }t          j        ||                    |j                  |	|
|||          }|                    |                                           }|g|j        dd<   |r]t!          j        |j        |          }|                    d                    t          |          dk    rdnd	          d
|g          }n.t!          j        |j                  }|                    d          }fd}t          j        j        |	t!          j        j        dd                    t          j        |j        |t!          j        |j        d| j         tC          j"        dd          | ||j        tF          j$        u           |||gd                    t          j%        j        d |j&                  g}t          j'        j        |t          j        j        |                    S )Nr   r   ru   r9  r   ro   )'NoneType' object has no attribute '%{}s'   .30 PyExc_AttributeErrorr   format_argsr   c                 b    | rdpd} t          j        j        t          |           |           S Nr   r   r  r   r   r   rC  rp   r*   s    r#   	flag_nodez?IterationTransform._transform_dict_iteration.<locals>.flag_node  2    Ka$1E$TXSZZQVWWWWr%   r   r  rq   __Pyx_dict_iterator	dict_iterr    Tr<  r   r   rw   rx   rz   rt   r~   )(r   r   r	   py_object_typerH   r   r   r  r|   rr  r^   r   r(   rx   r   r   r   rI  
c_ptr_typer   rE  DictIterationNextNoder   r   ru   IdentifierStringNoder   formatNullNoder   r   r+  PyDict_Iterator_func_typer   r!   r
   r   WhileStatNoderz   r   )rF   r*   r   r   r   r   r   ry  	dict_temppos_temp
key_targetvalue_targettuple_targetrx   dict_len_tempdict_len_temp_addris_dict_tempis_dict_temp_addriter_next_nodemethod_noder  result_codes    `                    r#   r   z,IterationTransform._transform_dict_iteration  sL   #J$=>>THHX\**	#J$@AAT88DH%%377
7\L 	'F 	'{2 +t{'((A--/3{/?,J  K#{ 	'JJ;Ldi!344 	;9DD%DIM/3yk; ; ;D ",Z-IJJ]###&4Hm//==&}'9::< < < #J$9::Txx))%3Hl&ty113 3 3 4}((66l  (;;D<L<L<N<NOO)*
1Q3 	W#8VTTTK11;BBCPVKK[]L]L]55ceff.%h 2 ( (HH
 $,X\::K112UVVH	X 	X 	X 	X 	X
 &'89; ; ;< < <
 &2L)2#.#:;#U#U$iiAR0R&S&S');=N !	 	 	    ".	  '6 'HE##     	r%   r   is_dictmethod_namep_orig_length	p_is_dictsetis_setp_is_setc                    g }t          j        t          j                  }|                    |           |                    |j                  }t          j        t          j                  }|                    |           |                    j                  }t          j	        t          j                  rj	        }n&t          j        j	        j        j	        g          }t          j        t          j                  }|                    |           t          j        j        |                    |j                  t          j        |j                            }	t          j        t          j                  }|                    |           |                    j                  }
t          j        j        |
t          j        |j                            }j        }t          j        ||                    |j                  |||
          }|                    |                                           }|g|j        dd<   fd}t          j        j        |t          j        j        dd                    t          j        |j        |t          j        |j        d| j        t5          j        d	d
          | ||j        t8          j        u           |	|gd                    t          j        j        d |j                  g}t          j         j        |t          j        j        |                    S )Nr  r9  r   c                 b    | rdpd} t          j        j        t          |           |           S r  r  r  s    r#   r  z>IterationTransform._transform_set_iteration.<locals>.flag_nodeM  r  r%   r   r  rq   __Pyx_set_iteratorset_iterr    Tr  r  rt   r~   )!r   r   r	   r  rH   r   r   r  r(   rx   r   r   r   rI  r  r   rE  r|   SetIterationNextNoder   r   ru   r   r   r+  PySet_Iterator_func_typer   r!   r
   r   r  rz   r   )rF   r*   set_objr   ry  set_tempr  rx   set_len_tempset_len_temp_addris_set_tempis_set_temp_addrr  r  r  r  s    `              r#   r   z+IterationTransform._transform_set_iteration+  s6   #J$=>>T88GK((#J$@AAT88DH%%di!344 	;9DD%DIM/3yk; ; ;D !+J,HII\"""%3Hl..w{;;&|'899; ; ; #J$9::Thhtx(($2Hk&ty113 3 3 {3l&&w{33X|[Z Z';;D<L<L<N<NOO)*
1Q3	X 	X 	X 	X 	X
 &%dhc1MMMO O O &0K(1!,!8\!R!R!99W\W=M-M#N#N+-= !	 	 	    ,	  %4 'HE##     	r%   F)&rW   rX   rY   rZ   r   r   r   r   r   r	   	CFuncTypec_char_ptr_typeCFuncTypeArgr
   r   r,  r  r-  r   re  rE  rF  rG  r  rJ  rK  rL  rH  r   r   r   rg  r   r  r   r  r  r   rP   r%   r#   ri   ri   z   s        / / /bE E El l l l\A A A(T T T Tl #7*"6"#J#C);TBB%%#' #' #'
 "6!5$#J#C);TBB'
 	" " "%& %& %& %&N  4z3!#J#FJ,A4HH#J#FJ,FMM#J#GZ-I4PP$
    (<z';#J#C)BDII#J#Hj.NPTUU#J#FJ,JDQQ#J#FJ,EtLL	 
 ( ( ($ZS ZS ZS ZSxb b b bHG^ G^ G^R
! 
! 
!Q Q Q Qf>% >% >%@` ` `D !5
 4!#J#FZ-FMM#J#I
0EtLL#J#MJ4MtTT#J#Oj6VX\]]#J#K*2KTRR$! !  4z3!#J#EJ,EtLL#J#Hz/DdKK#J#Oj6VX\]]#J#J1JDQQ	$   E E E E Er%   ri   c                   j    e Zd ZdZdZd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zej        j        ZdS )SwitchTransformz
    This transformation tries to turn long if statements into C switch statements.
    The requirement is that every clause be an (or of) var == value, where the var
    is common among all clauses and both var and value are ints.
    )NNNc                 l   	 t          |t          j        t          j        f          r|j        }nlt          |t          j                  r|j        j        }nEt          |t          j                  r|j        }n#t          |t          j	                  r|j
        }nnt          |t          j                  r|j        | j        S |                                rt          |j        t          j        t          j        f          rw|j        dk    }|r	|s| j        S t          |j        t          j                  r |j                                        r| j        S ||j        |                     |j                  fS |                                s|j        dk    rd}n|r|j        dk    rd}n| j        S t/          |j        |j                  rS|j        j        r||j        |j        gfS t3          |j        dd           r!|j        j        j        r||j        |j        gfS t/          |j        |j                  rS|j        j        r||j        |j        gfS t3          |j        dd           r!|j        j        j        r||j        |j        gfS nt          |t          j                  r|j        dk    s|rx|j        dk    rm|j        dk    }|                     |j        |          \  }}}|                     |j        |          \  }}}	|"||k    rt/          ||          r|r|r||||	z   fS | j        S )	NTr   rk   F!=r   orand)r(   r   CoerceToTempNodeCoerceToBooleanNoder)   BoolBinopResultNoder   EvalWithTempExprNodesubexpressionTypecastNoder   r   cascadeNO_MATCHis_c_string_containsrn   r   r?  rl   contains_surrogatesrm   extract_in_string_conditionsis_python_comparisonr7   r=  getattrr   is_constBoolBinopNodeextract_conditions)
rF   condallow_not_inr   not_in_1t1c1not_in_2t2c2s
             r#   r  z"SwitchTransform.extract_conditions{  sj   	$!;!*!>!@ A A xD)"?@@ x|D)"@AA )D)"899 |	 dI455 +	3|'}$**,,  Fdmi.CYEX-YZZ F(2 ), )=(dmY-BCC )}88::)
  =(t}d.O.OPTP].^.^^^..00 F=D(("FF! )dmt&;&;!FF=( #4=$-@@ F}/ F%t}t}oEE >> F!%!4!=F%t}t}oEE"4=$-@@ F}/ F%t}t}oEE >> F!%!4!=F%t}t}oEEi566 	3}$$$$-5:P:P $ 6#'#:#:4=,#W#W "b#'#:#:4=,#W#W "b>h(&:&:rSU?V?V&:$ 3 3'RU22}r%   c                    t          t          j                  rVt          t	          t
          t          j                                      }|                                 fd|D             S j        t          fdt          t                              D                                                        fdD             S )Nc                 b    g | ]+}t          j        j        t          |          |           ,S r  r  rc   charvalstring_literals     r#   rf   z@SwitchTransform.extract_in_string_conditions.<locals>.<listcomp>  sN     / / /  &~'9W7>@ @ @ / / /r%   c                 *    h | ]}||d z            S )r   rP   )rc   i
characterss     r#   	<setcomp>z?SwitchTransform.extract_in_string_conditions.<locals>.<setcomp>  s&    SSSa
1QqS5 1SSSr%   c                 H    g | ]}t          j        j        ||           S r  )r   CharNoder   r  s     r#   rf   z@SwitchTransform.extract_in_string_conditions.<locals>.<listcomp>  sH     1 1 1  '(:'8?A A A 1 1 1r%   )r(   r   r   listmapordr  rp   sortr   r^   )rF   r  charvalsr  s    ` @r#   r  z,SwitchTransform.extract_in_string_conditions  s    ni&;<< 	1CS)=%>%>??@@HMMOOO/ / / /$,/ / / / (-JSSSS5Z;Q;QSSSTTJOO1 1 1 1$.1 1 1 1r%   c                     |                      ||          \  }}}|| j        S |t          ||          s| j        S |j        j        s|j        j        rt          d |D                       r| j        S |||fS )Nc                 @    g | ]}|j         j        p|j         j         S rP   )r   r   r   )rc   r  s     r#   rf   z=SwitchTransform.extract_common_conditions.<locals>.<listcomp>  s*    TTTdi&;$)*;<TTTr%   )r  r  r7   r   r   r   any)rF   
common_varrw   r  r   var
conditionss          r#   extract_common_conditionsz)SwitchTransform.extract_common_conditions  s    "&"9"9)\"R"RZ;= #OC,L,L#= (/ 	!SX%5 	!#TTTTT;V ;V 	!= sJ&&r%   c                 l   t                      }|D ]}|                                r'|j        |v r dS |                    |j                   =	 |j        }|j        j        s|j        j        r|j        |j        }n|j	        }n# t          $ r Y  dS w xY w||v r dS |                    |           dS )NTF)r  r   r=   addr   r   r   is_cpp_enumenum_int_valuecnameAttributeError)rF   condition_valuesseenrp   value_entryvalue_for_seens         r#   has_duplicate_valuesz$SwitchTransform.has_duplicate_values  s    uu% 	) 	)E((** )(D0044.//// "'+K$)1 ;[5E5Q ; + : F)4)C)4):%      444 !T))44((((us   5B
BBc                    | j                             d          s|                     |           |S d }g }|j        D ]q}|                     ||j        d          \  }}}||                     |           |c S |                    t          j        |j	        ||j
                             rd |D             }t          |          dk     r|                     |           |S |                     |          r|                     |           |S |                     |d           |D ]}|                     |d           t          |          }t          j        |j	        |||j                  }	|	S )	Noptimize.use_switchFr   r  rx   c                 &    g | ]}|j         D ]}|S rP   )r  )rc   caser  s      r#   rf   z4SwitchTransform.visit_IfStatNode.<locals>.<listcomp>  sD     @ @ @t@ @'+D@ @ @ @r%   r   rz   rx   r   testcasesrz   )current_directivesgetrI   ry   r	  rw   rH   r   SwitchCaseNoder   rx   r^   r  r1   SwitchStatNoderz   )
rF   r*   r  r  	if_clause_r  r  r  switch_nodes
             r#   visit_IfStatNodez SwitchTransform.visit_IfStatNode  s   &**+@AA 	t$$$K
 	D 	DI(,(F(FI/)8 )8%Az:!""4(((LL-)-9C3<>C C C D D D D@ @"@ @ @  1$$t$$$K$$%566 	t$$$K 	4/// 	- 	-DtV,,,, ,,
*tx0:167;7GI I I r%   c                 n   | j                             d          s|                     |           |S |                     d |j        d          \  }}}|(t          |          dk     s|                     |          r|                     |           |S |                     |||||j        |j	                  S )Nr  Tr   )
r  r  rI   r	  r  r^   r  build_simple_switch_statementtrue_val	false_valrF   r*   r   r  r  s        r#   visit_CondExprNodez"SwitchTransform.visit_CondExprNode  s    &**+@AA 	t$$$K)-)G)G$)T*# *#&
Jz??Q&&,,Z88 't$$$K11*j&M4>+ + 	+r%   c                    | j                             d          s|                     |           |S |                     d |d          \  }}}|(t	          |          dk     s|                     |          r>|                     |           |                    |                                            |S |                     ||||t          j
        |j        dd          t          j
        |j        dd                    S Nr  Tr   r  F)r  r  rI   r	  r^   r  wrap_operandsr   r&  r   r   r   r)  s        r#   visit_BoolBinopNodez#SwitchTransform.visit_BoolBinopNode%  s   &**+@AA 	t$$$K)-)G)G$* *&
Jz??Q&&,,Z88 't$$$t//11222K11*j&txtTJJJtxueLLLN N 	Nr%   c                    | j                             d          s|                     |           |S |                     d |d          \  }}}|(t	          |          dk     s|                     |          r|                     |           |S |                     ||||t          j        |j	        dd          t          j        |j	        dd                    S r,  )
r  r  rI   r	  r^   r  r&  r   r   r   r)  s        r#   r   z$SwitchTransform.visit_PrimaryCmpNode8  s    &**+@AA 	t$$$K)-)G)G$* *&
Jz??Q&&,,Z88 't$$$K11*j&txtTJJJtxueLLLN N 	Nr%   c           	         t          j        |          }t          j        |j        ||                    |j        |                                           d          }t          j        |j        ||                    |j        |                                           d          }	|r|	|}	}t          j        |j        ||          g}
t          |          }t          j
        |j        ||
|	          }t          j        ||          }|S )NTrr   rs   firstr  r  )r   r.   r   r   r   rA  r   r   r  r1   r   r   )rF   r*   r  r  r   r'  r(  r   	true_body
false_bodyr  r#  replacements                r#   r&  z-SwitchTransform.build_simple_switch_statementJ  s#   ,T22
.H""49d.>.>.@.@AA	  	
 /H##DIt/?/?/A/ABB	  
  	:$.	zI%DH3=-68 8 8 9 !,,
*2<389CE E E  6z;OOr%   c                    | j                             d          s|                     |           |S |j        }|j        }|                     |           |j        |ur!t          j        |j        |          s|j        S |S )Nr  )r  r  rI   r  	lazy_tempr   tree_contains)rF   r*   	orig_exprtemp_refs       r#   visit_EvalWithTempExprNodez*SwitchTransform.visit_EvalWithTempExprNodeg  s    &**+@AA 	t$$$K &	>4   Y..();XFF *))r%   N)rW   rX   rY   rZ   r  r  r  r	  r  r$  r*  r.  r   r&  r;  r   VisitorTransformrecurse_to_childrenr[   rP   r%   r#   r  r  s  s         
 "H; ; ;z1 1 1$	' 	' 	'  2$ $ $L+ + +"N N N&N N N$  :   )=JJJr%   r  c                   0    e Zd ZdZd Zej        j        ZdS )FlattenInListTransformzj
    This transformation flattens "x in [val1, ..., valn]" into a sequential list
    of comparisons.
    c                    |                                 j        S j        dk    rdd}nj        dk    rdd}nS t          j        t
          j        t
          j        t
          j        f          sS j	        }j        j
        }t          |          dk    r=|                                r'j        dk    }t          j        j        ||          S S t          d	 |D                       rS t!          j        |          }g }g }|D ]}|                                s)t!          j        |          }|                    |           t          j        j        |||d 
          }	|                    t          j        j        |	t,          j                             fd}
t1          |
|          }t!          j        ||          }|d d d         D ]}t!          j        ||          }|S )Ninr  rk   r   r  r  r   r  c                     g | ]	}|j         
S rP   )
is_starredrc   r)   s     r#   rf   z?FlattenInListTransform.visit_PrimaryCmpNode.<locals>.<listcomp>  s    ///3///r%   )r   rm   rl   rn   r  )r   r   r   c                 >    t          j        j        | |          S )N)r   rl   rm   rn   )r   r  r   )leftrightconjunctionr*   s     r#   concatz;FlattenInListTransform.visit_PrimaryCmpNode.<locals>.concat  s+    *&*h+6+/+0	2 2 2 2r%   r$  )rI   r  rl   r(   rn   r   	TupleNodeListNodeSetNoderm   r   r^   try_is_simpler   r   r  r   r.   r  rH   r   r  r	   c_bint_typer   r  )rF   r*   	eq_or_neqrr   r   r=   condsr   r)   r  rI  rw   r   ry  rH  s    `            @r#   r   z+FlattenInListTransform.visit_PrimaryCmpNode  sU   4   <#K]d""KII]h&&KIIK$-)*=*3*<*3*;*= > > 	 Km}!t99>>  "" l"&-8"; )$(/[jkkkkK//$///00 	K%c** 	@ 	@C$$&& "*3//S!!!+&*h+.+4+.*.0 0 0D LL/&*h*.'1'=? ? ? @ @ @ @	2 	2 	2 	2 	2 	2 65))	1#yAA$$B$K 	F 	FD 5dHEEHHr%   N)	rW   rX   rY   rZ   r   r   r<  r=  r[   rP   r%   r#   r?  r?  y  s5         
> > >@ )=JJJr%   r?  c                   <    e Zd ZdZej        j        Zd Zd Z	d Z
dS )DropRefcountingTransformz&Drop ref-counting in safe places.
    c                    g g }}g g }}g }|j         D ]}t          |t          j                  rC|                     |j        |||          s|c S |                     |j        |||          s|c S _t          |t          j                  r|c S |c S |s|rid |D             }d |D             }	t          |          t          |	          k    r|S t          t          |                    t          |          k    r|S |s|rg }
|D ]2}| 
                    |          }|s|c S |
                    |           3g }|D ]2}| 
                    |          }|s|c S |                    |           3t          |
          t          |          k    r|S t          t          |
                    t          |          k    r|S |S d |D             }|D ]	}d|_        
||z   D ]\  }}||vrd|_        ||z   D ]	}d|_        
|S )zF
        Parallel swap assignments like 'a,b = b,a' are safe.
        c                     g | ]\  }}|S rP   rP   rc   pathns      r#   rf   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    777at777r%   c                     g | ]\  }}|S rP   rP   rU  s      r#   rf   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    888at888r%   c                     g | ]	}|j         
S rP   r)   )rc   ts     r#   rf   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    ***qQU***r%   F)ru   r(   r   r   _extract_operandrr   rs   CascadedAssignmentNoder  r^   _extract_index_idrH   use_managed_ref)rF   r*   
left_namesright_namesleft_indicesright_indicesr   statlnamesrnameslindiceslhs_nodeindex_idrindicesrhs_node	temp_argsry  r"  	name_node
index_nodes                       r#   visit_ParallelAssignmentNodez5DropRefcountingTransform.visit_ParallelAssignmentNode  s    #%bK
&("mJ 	 	D$ :;; ,,TXz-95B B  KKK,,TX{-:EC C  KKK  D%">??  	 	77:777F88;888F6{{c&kk))3v;;3{#3#333 	= 	 H( * *11(;;  KKK))))H) * *11(;;  KKK))))8}}H--3x==!!S%7%777 K**E***	 	) 	)D#(D  &4 	2 	2LAy	)),1	)&6 	/ 	/J).J&&r%   c                    t          |          }|j        j        sdS t          |t          j                  r|                    |           |j        }g }|}|j        r1|j	        rdS |                    |j
                   |j        }|j        1|j        rN|                    |j                   |                    d                    |d d d                   |f           n\|j        rS|j        j        t"          j        k    rdS |j        j        j        sdS |j        j        sdS |                    |           ndS dS )NF.r$  T)r1   r   r   r(   r   r  rH   r)   r   r6   memberr8   r   r"   joinr   r   r
   r   r   r   )rF   r*   namesindicesr   	name_pathobj_nodes          r#   r\  z)DropRefcountingTransform._extract_operand  sX   4  y$ 	5dI677 	LL8D	# 	$" uX_---|H	 # 	$
  	X]+++LL388IdddO44d;==== 		y~!222u:?) u9$ uNN4    5tr%   c                     |j         }|j        }t          |t          j                  r|j        }nt          |t          j                  rd S d S |j        |fS r'   )r   r   r(   r   r4   r"   	ConstNode)rF   rn  r   r   	index_vals        r#   r^  z*DropRefcountingTransform._extract_index_id)  s[     eY/00 	
IIy233 	44	9%%r%   N)rW   rX   rY   rZ   r   r<  r=  r[   ro  r\  r^  rP   r%   r#   rR  rR    sZ         )=JC C CJ  :
& 
& 
& 
& 
&r%   rR  c                      e Zd ZdZej        j        Zd Zd Z	d Z
ddZddZddZd	 Zd
 Zd Zd Zd Zd Z ej        ej         ej        dej        d          g          Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&dS )EarlyReplaceBuiltinCallsa  Optimize some common calls to builtin types *before* the type
    analysis phase and *after* the declarations analysis phase.

    This transform cannot make use of any argument types, but it can
    restructure the tree in a way that the type analysis phase can
    respond to.

    Introducing C function calls here may not be a good idea.  Move
    them to the OptimizeBuiltinCalls transform instead, which runs
    after type analysis.
    c                     |                      |           |j        }|                     |          s|S |                     |||j                  S r'   )rI   r   _function_is_builtin_name_dispatch_to_handlerr   )rF   r*   r   s      r#   visit_SimpleCallNodez-EarlyReplaceBuiltinCalls.visit_SimpleCallNodeE  sR    4   =--h77 	K((xCCCr%   c                     |                      |           |j        }|                     |          s|S |j        }t	          |t
          j                  s|S |j        }|                     ||||j	                  S r'   )
rI   r   r~  positional_argsr(   r   rJ  r   r  keyword_args)rF   r*   r   r   r   s        r#   visit_GeneralCallNodez.EarlyReplaceBuiltinCalls.visit_GeneralCallNodeL  s    4   =--h77 	K(	)Y%899 	K~(((D$"35 5 	5r%   c                     |j         sdS |                                 }|                    |j                  }||                                                    |j                  urdS dS )NFT)r   r   r   r"   r   lookup_here)rF   r   r  r   s       r#   r~  z2EarlyReplaceBuiltinCalls._function_is_builtin_nameX  sg     	5  

8=))))++77FFFF5tr%   Nc                     |d|j         z  }n
d|j         z  }t          | |d           }|| |||          S  ||||          S |S )Nz_handle_simple_function_%sz_handle_general_function_%s)r"   r  )rF   r*   r   r   kwargshandler_namehandle_calls          r#   r  z-EarlyReplaceBuiltinCalls._dispatch_to_handlerb  sh    >7(-GLL88=HLdL$77"~"{4..."{4v666r%   c                 j    t          j        |j        j        |j        j        |||          |_        d S )Nr<  )r   PythonCapiFunctionNoder   r   r"   )rF   r*   r  	func_typer<  s        r#   _inject_capi_functionz.EarlyReplaceBuiltinCalls._inject_capi_functiono  s5    !8Mt}15)') ) )r%   c           
          |sd}n)t          |t                    s|dk    rd}n|dk    rd}nd}|d|z  }nd}t          |j        d|||t	          |          fz             d S Nr  r   z...xzexpected %s, z3%s(%s) called with wrong number of args, %sfound %dr(   rC  r   r   r^   rF   function_namer*   r   expectedarg_strexpected_strs          r#   _error_wrong_arg_countz/EarlyReplaceBuiltinCalls._error_wrong_arg_countt       	GG#&& 	(Q,,GG]]GGG*X5LLLdhM7L#d))Q= = 	> 	> 	> 	> 	>r%   c                    |st          j        |j        d          S t          |          dk    r|                     d||d           t          |d         dd           }|t          j        t          j	        fv r|d         S |S )N0.0ro   r   floatr   r   )
r   	FloatNoder   r^   r  r  r	   c_double_typer
   
float_type)rF   r*   pos_argsarg_types       r#   _handle_simple_function_floatz6EarlyReplaceBuiltinCalls._handle_simple_function_float  s     	>&txu====x==1''xCCC8A;55
0'2DEEEA;r%   c                 @   t          |          }d x}}|dk    r|\  }n2|dk    r|\  }}n&|dk    r|\  }}}n|                     d||           |S t          j        |j        |pt          j        |j                  ||pt          j        |j                            S )Nr   r   r   slice)r)  r*  r  )r^   r  r   rZ  r   NoneNode)rF   r*   r  r   r)  r  r*  s          r#   _handle_simple_function_slicez6EarlyReplaceBuiltinCalls._handle_simple_function_slice  s    MM	>>EDD!^^"KE44!^^ (E4''x@@@K"H79-dh775+DH55	7 7 7 	7r%   c           	      l   t          |          dk    r|S |d         }t          |t          j        t          j        f          rpt          |j                  dk    rXt          j        |j        t          j	        t          t          |j                            t          |j                            S |S )zUnpack ord('X').
        r   r   rT  )r^   r(   r   r   r?  rp   r   r   r	   c_long_typerC  r   )rF   r*   r  r)   s       r#   _handle_simple_function_ordz4EarlyReplaceBuiltinCalls._handle_simple_function_ord  s     x==AKqkcI193FGHH 	39~~"" (G*"8c#)nn--$'	NN   
 r%   c                 0    |                      ||d          S )zTransform

        _result = all(p(x) for L in LL for x in L)

        into

        for L in LL:
            for x in L:
                if not p(x):
                    return False
        else:
            return True
        F_transform_any_allrF   r*   r  s      r#   _handle_simple_function_allz4EarlyReplaceBuiltinCalls._handle_simple_function_all  s     &&tXu===r%   c                 0    |                      ||d          S )zTransform

        _result = any(p(x) for L in LL for x in L)

        into

        for L in LL:
            for x in L:
                if p(x):
                    return True
        else:
            return False
        Tr  r  s      r#   _handle_simple_function_anyz4EarlyReplaceBuiltinCalls._handle_simple_function_any  s     &&tXt<<<r%   c                    t          |          dk    r|S t          |d         t          j                  s|S |d         }|j        j        }|j        }t          |          \  }}||S |r|}	nt          j        |j	        |          }	t          j        |j	        d t          j        |j	        |	t          j        |j	        t          j        |j	        ||                              g          }
t          j        |j	        t          j        |j	        | |                     |_        t!          j        |||
           t          j        |j	        ||rdnd	
          S )Nr   r   r   r  ro   rv   )rz   ry   r  all)gen	orig_func)r^   r(   r   GeneratorExpressionNodedef_nodegbodyrx   r`   r   r   r   r   r   ReturnStatNoder   rz   r   recursively_replace_nodeInlinedGeneratorExpressionNode)rF   r*   r  is_anygen_expr_nodegenerator_bodyr  yield_expressionyield_stat_noderw   	test_nodes              r#   r  z+EarlyReplaceBuiltinCalls._transform_any_all  s   x==AK(1+y'HII 	K &/5"'	,I),T,T)/#K 	Z(II!)*:*>HXYYYI$ d"$('-'01A1EVekllln n n  @	
 	
 	
	 !& 4H$%5%9Vag]ghhh!j !j !j	 	(SSS7=V<VEEQVX X X 	Xr%   itc                    t          |          dk    r|S |d         }t          |t          j                  r|j        t
          j        u r|}nt          |t          j                  r|}t          |j	                  }|s|S t          j
        |j        |dt
          j                  }|D ]<\  }}t          j        |j        ||j                  }	t          j        |||	           =nt|j        r|                                }nXt          j        |j        |                                r!|j        t(          j        t
          j        fv rdnd| j        |d	          }t          j        |j        |          S )
a  Transform sorted(genexpr) and sorted([listcomp]) into
        [listcomp].sort().  CPython just reads the iterable into a
        list and calls .sort() on it.  Expanding the iterable in a
        listcomp is still faster and the result can be sorted in
        place.
        r   r   sortedr  comprehension_typerM   r|   __Pyx_PySequence_ListKeepNewPySequence_ListTr'  )r^   r(   r   ComprehensionNoder   r
   r   r  r]   loopr  r   ComprehensionAppendNoder|   r   r  rr  as_listr+  result_in_tempr	   r  PySequence_List_func_typeSortedListNode)
rF   r*   r  r)   	list_noder  r_   r  r  append_nodes
             r#   _handle_simple_function_sortedz7EarlyReplaceBuiltinCalls._handle_simple_function_sorted  s    x==AKqkc9677 "	-CHHY<Y<YIIY>?? 	-M5m6HII# !@-8#*#46 6 6I 6F ^ ^1 /'?$()$+- - - 0Q\]]]]^ ( 	- II
 "4))+++03Z=VX_Xi<j0j0j /.*.t- - -I ')<<<r%   c           
         t          |          dvr|S t          |d         t          j        t          j        f          s|S |d         }|j        }t          |t          j                  rt          |          \  }}d}||S n7|j        }|j        }	 |j	        r|j
        j        s|S n# t          $ r |cY S w xY wt          |          dk    rt          j        |j        dd          }n|d         }t          j        |j        t"          j                  }t'          j        |j        |t          j        |j        d||          	          }	t-          j        |||	           t'          j        |j        t'          j        |j        t          j        |j        |
          |d          |g          }
t          j        |j        |
||j        d|j                  S )zLTransform sum(genexpr) into an equivalent inlined aggregation loop.
        r   r   r   Nr   r   r  r   rW  rq   )r   r/   Tr1  rt   sum)r  result_node
expr_scoper  has_local_scope)r^   r(   r   r  r  r  r`   rH   rM   r=  r   r   r  r   r   r   r.   r	   r  r   r   r  r   r  r   r  r  r  )rF   r*   r  r  r  r  r  r)  r   add_node	exec_codes              r#   __handle_simple_function_sumz5EarlyReplaceBuiltinCalls.__handle_simple_function_sum,  s&    x==%%K(1+	(I(1(C(E F F 	K !&	mY%FGG 	0Mi0X0X-o#' ( ,2O.3'2  :J:O:V  K !   
 x==A%dhc1MMMEEQKE,
@YZZZ
- &txjBRSS   	(RRR&H*I#1dh:VVV 	" " "
 	 	 		 7iz&1u+;= = = 	=s   B) )B87B8c                 0    |                      ||d          S )Nr   _optimise_min_maxr  s      r#   _handle_simple_function_minz4EarlyReplaceBuiltinCalls._handle_simple_function_minf      %%dHc:::r%   c                 0    |                      ||d          S )Nr   r  r  s      r#   _handle_simple_function_maxz4EarlyReplaceBuiltinCalls._handle_simple_function_maxi  r  r%   c                 0   t          |          dk    rBt          |          dk    r|d         j        r|d         j        }t          |          dk    r|S t          t	          t
          j        |dd                             }|d         }|D ]c}t          j        |          }t          j        |j	        ||t          j
        |j	        |||                    }t          j        ||          }d|ddd         D ]}t          j        ||          }|S )zKReplace min(a,b,...) and max(a,b,...) by explicit comparison code.
        r   r   N)rm   rl   rn   )r'  r(  r  r$  )r^   rr  r   r  r  r   r.   r   CondExprNoder   r   r  )	rF   r*   r   rl   cascaded_nodeslast_resultarg_noder   ref_nodes	            r#   r  z*EarlyReplaceBuiltinCalls._optimise_min_maxl  s)    t99>>4yyA~~$q'"A~Aw|4yyA~~c)"948DDEE1g& 	R 	RH"0==J#0#& /L'')	  	
 
 
K $8[QQKK&ttt, 	P 	PH#8;OOKKr%   c                     |st          j        |j        g d          S |                     ||t          j                  }||urt          j        |j        |          S |S )NrP   r   r=   rZ  )r   rJ  r   _transform_list_set_genexprr
   r   AsTupleNode)rF   r*   r  results       r#   &_DISABLED_handle_simple_function_tuplez?EarlyReplaceBuiltinCalls._DISABLED_handle_simple_function_tuple  si     	N&txb"MMMM 11$'BSTT(v>>>>r%   c                     t          |          dk    r|S |d         j        r|d         j        s|d= n=t          |d         t          j                  r|d                                         |d<   |S )zSReplace frozenset([...]) by frozenset((...)) as tuples are more efficient.
        r   r   )r^   rr  r   r(   r   rK  as_tupler  s      r#   !_handle_simple_function_frozensetz:EarlyReplaceBuiltinCalls._handle_simple_function_frozenset  sw     x==AKA;. 	1x{7G 	1Y%788 	1"1+..00HQKr%   c                     |st          j        |j        g g           S |                     ||t          j                  S Nr  )r   rK  r   r  r
   r   r  s      r#   _handle_simple_function_listz5EarlyReplaceBuiltinCalls._handle_simple_function_list  s@     	M%dhRLLLL//h@QRRRr%   c                     |s(t          j        |j        g t                                S |                     ||t
          j                  S r  )r   rL  r   r  r  r
   r   r  s      r#   _handle_simple_function_setz4EarlyReplaceBuiltinCalls._handle_simple_function_set  sD     	O$TXBNNNN//h@PQQQr%   c                    t          |          dk    r|S t          |d         t          j                  s|S |d         }|j        }t          |          }|s|S t          j        |j        ||t          j	        u rdnd|          }|D ]<\  }}	t          j
        |j        ||j                  }
t          j        ||	|
           =|S )zLReplace set(genexpr) and list(genexpr) by an inlined comprehension.
        r   r   r  r  r  r  )r^   r(   r   r  r  r]   r  r   r
   r   r  r|   r   r  )rF   r*   r  r/  r  r  r_   r  r  r  r  s              r#   r  z4EarlyReplaceBuiltinCalls._transform_list_set_genexpr  s     x==1K(1+y'HII 	K !&	1)<< 	K>Hm*g.>>>eeF*, , ,
 2B 	Z 	Z-o#; $%")+ + +K ,]O[YYYYr%   c                    t          |          dk    rt          j        |j        g i           S t          |          dk    r|S t	          |d         t          j                  s|S |d         }|j        }t          |          }|s|S |D ]?\  }}t	          |t          j                  s|c S t          |j	                  dk    r|c S @t          j
        |j        |dt          j                  }|D ]S\  }}	t          j        |j        |j	        d         |j	        d         |j                  }
t          j        ||	|
           T|S )zDReplace dict( (a,b) for ... ) by an inlined { a:b for ... }
        r   key_value_pairsr=   r   r   r   r  )key_expr
value_exprr|   )r^   r   DictNoder   r(   r  r  r]   rJ  r   r  r
   r   DictComprehensionAppendNoder|   r   r  )rF   r*   r  r  r  r_   r  r"  r  r  r  s              r#   _handle_simple_function_dictz5EarlyReplaceBuiltinCalls._handle_simple_function_dict  s    x==A%dhTVWWWWx==1K(1+y'HII 	K !&	1)<< 	K#3 	 	a.	0CDD #())Q.. /  >Hmv&02 2 2 2B 	Z 	Z-o#? $).q1+03")	+ + +K
 ,]O[YYYYr%   c                 h    t          |          dk    r|S t          |t          j                  s|S |S )zlReplace dict(a=b,c=d,...) by the underlying keyword dict
        construction which is done anyway.
        r   )r^   r(   r   r  )rF   r*   r  r  s       r#   _handle_general_function_dictz6EarlyReplaceBuiltinCalls._handle_general_function_dict  s9     x==1K&)"455 	Kr%   r'   )'rW   rX   rY   rZ   r   r<  r=  r[   r  r  r~  r  r  r  r  r  r  r  r  r  r	   r  r
   r   r  r  r  r  5_EarlyReplaceBuiltinCalls__handle_simple_function_sumr  r  r  r  r  r  r  r  r   r  rP   r%   r#   r|  r|  6  s       
 
 )=JD D D
5 
5 
5     ) ) ) )
> > > >$  7 7 7$  "> > > = = = "X "X "XH !5
 4	 	 z'@$	G	GH!J !J/= /= /=b8= 8= 8=t; ; ;; ; ;  F  	 	 	S S S
R R R
  8" " "L    r%   r|  c                   2    e Zd Zej        j        Zd Zd ZdS )InlineDefNodeCallsc                     |j         d S |j         j        rd S |                                                     |j                  }|r|j        rt          |j                  dk    rd S |j        d         j        S )Nr   r   )cf_state
cf_is_nullr   r   r"   cf_assignmentsr^   rs   )rF   rm  r   s      r#   get_constant_value_nodez*InlineDefNodeCalls.get_constant_value_node  s    %4( 	4  ""))).99 	U1 	 455::4#A&**r%   c                    |                      |           | j                            d          s|S |j        }|j        s|S |                     |          }t          |t          j                  s|S t          j	        |j
        |||j        |j                  }|                                r|                     ||          S |S )Nzoptimize.inline_defnode_calls)r  r   r   generator_arg_tag)rI   r  r  r   r   r
  r(   r   PyCFunctionNodeInlinedDefNodeCallNoder   r   r  can_be_inlinedreplace)rF   r*   r  r   inlineds        r#   r  z'InlineDefNodeCalls.visit_SimpleCallNode  s    4   &**+JKK 	K$ 	K//>>(I$=>> 	K2HMDI"46 6 6 !!## 	/<<g...r%   N)	rW   rX   rY   r   r<  r=  r[   r
  r  rP   r%   r#   r  r     s=        )=J
+ 
+ 
+    r%   r  c                   6   e Zd ZdZd Zd Zd Zd Z ej	        ej
         ej        dej
        d          g          Zd Zd	 Z ej	        ej         ej        d
ej        d           ej        dej        d           ej        dej        d          gdd          Zd Zd ej        ej        ej        fD             Zd Z ej	        ej         ej        dej        d          gd          Z ej	        ej         ej        dej        d          gd          Zd ZddZd Z d Z!d Z" ej	        ej#         ej        dej
        d          g          Z$d Z%e%Z&d Z' ej	        ej(         ej        dej(        d          g          Z)d  Z* ej	        ej+         ej        d!ej
        d          g          Z,d" Z- ej	        ej.         ej        d#ej+        d          g          Z/d$ Z0 ej	        ej1         ej        d!ej
        d          g          Z2d% Z3 ej	        ej4         ej        d!ej
        d          g          Z5d& Z6 ej	        ej         ej        dej
        d          gd'd          Z7d( Z8 ej	        ej9         ej        dej
        d          g          Z: ej	        ej9         ej        d)ej        d          g          Z;d* Z<d+ Z= ej	        ej>         ej        d)ej
        d          g          Z? ej	        ej>         ej        d)ej@        d          g          ZAd, ZB ej	        ej         ej        d
ejC        d          gd          ZD ej	        ej         ej        d-ejE        d          gd          ZF ej	        ej         ej        dej
        d          gd          ZGej#        d.ej        d/ejH        d0ej+        d1ej.        d2ej1        d3ej4        d3ej(        d4ijI        ZJd5hZKd6 ZL ej	        ejM         ej        d7ej
        d          g          ZNd8 ZO ej	        ejP         ej        dej
        d          g          ZQd9 ZRd: ZS ej	        ej
         ej        d;ej
        d           ej        d<ej.        d          g          ZT ej	        ej
         ej        d;ej
        d           ej        d<ej.        d           ej        d=ej(        d          g          ZU	 dd>ZV	 dd?ZW ej	        ejX         ej        d#ej
        d           ej        d@ej
        d          gd          ZYdA ZZdB Z[ ej	        ejX         ej        dCej
        d           ej        d)ej        d          gd          Z\ ej	        ejX         ej        dCej
        d           ej        d)ej
        d          gd          Z]dD Z^ ej	        ej
         ej        d#ej
        d          g          Z_ ej	        ej
         ej        d#ej
        d           ej        dEej
        d           ej        dFej        d           ej        dGej        d          gdH          Z`dI ZaddKZb ej	        ejX         ej        dej
        d          gd          ZcdL Zd ej	        ej
         ej        dej
        d           ej        dMej
        d           ej        dNej
        d          g          ZedO Zf ej	        ej
         ej        dej
        d           ej        dMej
        d           ej        dNej
        d           ej        dPej        d          g          ZgdQ Zh ej	        ej
         ej        dej
        d           ej        dMej
        d           ej        dNej
        d          g          Zi ej	        ej         ej        dej
        d           ej        dMej
        d           ej        dNej
        d          gej        jj                  ZkdR ZldS ejm        ej        fD             ZndT ZodU ZpdV ZqdW ZrdX ZsdY ZtdZ Zud[ Zvd\ Zwd] Zxd^ Zyd_ Zzd` Z{da Z|eoZ}epZ~eqZerZesZetZeuZevZewZexZeyZezZe{Zdb Zdc Zdd Zde Zdf Zdg Zdh Zdi Zdj Z ej	        ejP         ej        dkej        d          g          Zdl ZeZeZeZeZeZeZeZeZeZeZ ej	        ej         ej        dkej        d          g          Z	  ej	        ej+         ej        dmej#        d           ej        dnejP        d          g          Zdo Z ej	        ej+         ej        dmej#        d           ej        dpej
        d           ej        dqej        d          g          Zdr Z ej	        ej#         ej        dmej#        d           ej        dsej
        d          g          Zdt Z ej	        ejP         ej        dmej
        d           ej        duej
        d           ej        dvej        d           ej        dwej        d           ej        dxej        d          gd          Zdy Zdz Zd{ Z ej	        ej         ej        dmej#        d           ej        duej
        d           ej        dvej        d           ej        dwej        d           ej        dxej        d          gd|          Zd} Zd~ Zd Z ej	        ej         ej        dmej#        d           ej        duej
        d           ej        dvej        d           ej        dwej        d          gd          Zd Z ej	        ej#         ej        dmej#        d           ej        duej
        d           ej        dej
        d           ej        dej        d          g          Zd Z ej	        ej         ej        dej#        d           ej        dejC        d           ej        dejC        d          g          Z ej	        ej         ej        dej#        d          g          Zg dZd eD             Zd Z ej         ej	        ej#         ej        dejC        d           ej        dej        d           ej        dejC        d          g                    Z ej	        ej#         ej        dejC        d           ej        dvej        d           ej        dej        d           ej        dejC        d           ej        dejC        d           ej        ded          g          Z ej	        ej#         ej        dej
        d           ej        dvej        d           ej        dej        d           ej        dejC        d           ej        dejC        d           ej        ded          g          ZdZd ZeZd Zd Zd Zd Zd Z	 dddej        j        dfdZd Z ej	        ej
         ej        dej
        d          g          Zd Zd Zd ZdS )OptimizeBuiltinCallsa<  Optimize some common methods calls and instantiation patterns
    for builtin types *after* the type analysis phase.

    Running after type analysis, this transform can only perform
    function replacements that do not alter the function return type
    in a way that was not anticipated by the type analysis.
    c                 T    |                      |           |                                S )z:Flatten redundant type checks after tree changes.
        )rI   	reanalyserJ   s     r#   visit_PyTypeTestNodez)OptimizeBuiltinCalls.visit_PyTypeTestNode-  s(     	4   ~~r%   c                 h    |                      |           |j        |j        j        k    r|j        S |S )z,
        Drop redundant type casts.
        )rI   r   r   rJ   s     r#   _visit_TypecastNodez(OptimizeBuiltinCalls._visit_TypecastNode3  s7     	4   9)))<r%   c                    |                      |           t          |j        t          j                  r|j        j        |_        |j        }||j        s|j        rdS |j        r!|j	        r|j	        j
        s|j	        j        rdS |S )z7
        Drop dead code and useless coercions.
        N)rI   r(   rM   r   r   r)   is_noner=  r   r   is_localis_arg)rF   r*   rM   s      r#   rN   z'OptimizeBuiltinCalls.visit_ExprStatNode>  s     	4   di!=>> 	&	DIy<4<<4?<4< 	DJ 	DJ,? 	4:CT 	4r%   c                 J   |                      |           |j        }t          |t          j                  r|j        }t          |t          j                  rK|j        t          j        t          j
        fv r,|j                            |                                           S |S )z<Drop redundant conversion nodes after tree changes.
        )rI   r)   r(   r   PyTypeTestNoder   r   r	   r  r
   	bool_typecoerce_to_booleanr   )rF   r*   r)   s      r#   visit_CoerceToBooleanNodez.OptimizeBuiltinCalls.visit_CoerceToBooleanNodeN  s     	4   hc9344 	'Cc9788 	ExJ5w7HIIIw001A1A1C1CDDDr%   oNc                    |                      |           |j        }t          |t          j                  r|j        }t          |t          j                  r|j        j        dk    rt          |j	                  dk    r|j	        d         }|j
        t          j        u r|                    d          S |j
        j        r|j        j        dk    rot          j        |j        d| j        |gd|j        t'          j        dd          |j        	                              |j
        |                                           S |S )
z3Drop redundant conversion nodes after tree changes.r  r   r   =float() argument must be a string or a number, not 'NoneType'__Pyx_PyObject_AsDouble__Pyx_PyNumber_Floatpynumber_floatzTypeConversion.c)r   py_namer   r<  r;  )rI   r)   r(   r   CoerceFromPyTypeNoder+  r   r"   r^   r   r   r
   r  r   r   r  r   PyNumber_Float_func_typer   r   r!   r;  rA  r   )rF   r*   r)   func_args       r#   visit_CoerceToPyTypeNodez-OptimizeBuiltinCalls.visit_CoerceToPyTypeNode_  s/   4   hc99:: 	'Cc9788 	?| G++CH0B0B8A;=G$666#556uvvv]. ?3<3EIb3b3b$7"8$:W&Z ' $'2'>?OQc'd'd'+':    i	4+;+;+=+=>>? r%   c                 j   |                      |           |j        }|j        j        s?|j        |j        k    r-|                    |j        |                                           }|S t          |t          j                  r|j        }|j	        r|j        j
        rt          |t          j                  sL|j        j        rt          |t          j                  s&|j        j
        rGt          |t          j                  r-|                    |j        |                                           S nt          |t          j                  r|j        t           j        u rW|j                            |j        j                  r2|j                            |j        |                                           S n|j        t&          j        u rO|j        j        j        r>|j        j        r2|j                            |j        |                                           S nt          |t          j                  r/|j        j
        s|j        j        r|                     ||          S nR|j        rK|j        }t          |t          j                  r|j        }|j        j
        r|                     |||          S |S )zDrop redundant conversion nodes after tree changes.

        Also, optimise away calls to Python's builtin int() and
        float() if the result is going to be coerced back into a C
        type anyway.
        )rI   r)   r   r   rA  r   r(   r   r  r=  r   r   is_floatr  r   r   r	   r  rf  r
   r   is_unicode_charr   _optimise_numeric_cast_callr   r   _optimise_int_indexing)rF   r*   r)   rn  s       r#   visit_CoerceFromPyTypeNodez/OptimizeBuiltinCalls.visit_CoerceFromPyTypeNodev  s    	4   hx# 	yCH$$mmDIt/?/?/A/ABBJc9344 	'C> 	J	  DZY5F%G%G DI&D+5c9;N+O+ODI$D)3C9K)L)LD }}TY0@0@0B0BCCCY9:: 	Jx:4449,,SW\:: L7,,TY8H8H8J8JKKKL W1117</ LDI4M L7,,TY8H8H8J8JKKKY566 	Jy C49#5 C77cBBBC 	JJ*i&BCC ,'^
% J224jIIIr%   bytesr   check_boundsz
((char)-1)T)r#  exception_checkc                 P   |                                  }|j        d         rdpd}|j        j        t          j        u r|j        t          j        t          j        fv rt          j
        |j        t          |          |          }t          j        |j        d| j        |j                            d          |                    t          j        |          |gdt%          j        dd	          
          }|j        t          j        ur|                    |j        |          }|S |S )Nr   r   r   r  __Pyx_PyBytes_GetItemIntz&'NoneType' object is not subscriptableTbytes_indexStringTools.cr   r   r<  )r   r  r   r   r
   r   r	   c_char_typec_uchar_typer   r   r   rC  r+  PyBytes_GetItemInt_func_typer   rA  r  r   r!   )rF   coerce_noder)   rn  r  bound_check_boolbound_check_noder*   s           r#   r1  z+OptimizeBuiltinCalls._optimise_int_indexing  s'     >-8>QC!8=G...J$:J<S#TTT#,#4O3/?+@+@$4$6 $6 $6  !3O%?5223[\\",,Z-I3OO(
 !!,!8%"8 "8
9 
9 
9 #:+AAA>>+*:C@@Dr%   c                 d    i | ]-}|t          j        |t          j        d |d          g          .S )r)   N)r	   r  r  )rc   r  s     r#   
<dictcomp>zOptimizeBuiltinCalls.<dictcomp>  sS       
 	 	J('z4@@   r%   c           	         |j         }d }t          |t          j                  r|j        }nQt          |t          j                  r7|j        j        r+t          |j        t          j	                  r|j        j        }|t          |          dk    r|S |d         }t          |t          j                  r|j        }n|j        j        r|S |j        dk    rT|j        j        s|j        j        r|j        |j        k    r|S |j        t           j        t           j        fv r|                     ||j        |          S |j                            |j                  s|j        j        r!t          j        |j        ||j                  S n]|j        j        r|j        j        r|j        j        dk    rd}nd|j        j        z   }t          j        |j        || j        |j                 |gd|j        |j                                      |j        |                                           S n|j        d	k    r|j        j        s|j        j        r|j        |j        k    r|S |j        t           j        t           j        fv r|                     ||j        |          S |j                            |j                  s|j        j        r!t          j        |j        ||j                  S |S )
Nr   r   r[  r9  l__Pyx_truncltrunc)r  r   r(  r   r;  r  )r   r(   r   r+  r   r4   r   is_builtin_typer   rJ  r^   r   r)   r   r"   r   r	   re  c_py_unicode_type_pyucs4_to_numberrf  r.  r  r   
is_numericmath_h_modifierfloat_float_func_typesr   r;  rA  r   )rF   r*   r)   r   r   r+  truncls          r#   r0  z0OptimizeBuiltinCalls._optimise_numeric_cast_call  s   <c9788 	*8DD)"455 	*}, *CM9K^1_1_ *})<3t99>>K7h	 <== 	|HH]& 	K=E!!}# ;ty'7 ;=DI--#O]z'@*B^&___11$xPPPY..x}== ^AW ^$1$(HSWS\]]]]^' ;DI,@ ;=0C77+FF$x}'DDF 3Hf"9(-H"! L#'#6   )DIt'7'7'9'9::; ]g%%}% D); D=DI--#O]z'@*B^&___11$xPPPY..x}== DAW D$1(D D D Dr%   r)   r$  r"  g      c                 &   |dv sJ t          j        |j        |dk    rdnd|dk    r| j        n| j        |g||j        |j        t          j        |dk    rdndd                    	                    |j
        |                                           S )	N)r[  r  r[  __Pyx_int_from_UCS4__Pyx_double_from_UCS4
int_pyucs4float_pyucs4
Builtins.c)r  r   r(  r   r;  r<  )r   r+  r   pyucs4_int_func_typepyucs4_double_func_typer   r;  r   r!   rA  r   r   )rF   r*   py_type_namer+  s       r#   rI  z&OptimizeBuiltinCalls._pyucs4_to_number		  s    /////+H|u/D/D++Jb3?53H3Hd//dNj L.$0QVAVAV\jlxyy
 
 
 )DIt//11
2
2	3r%   c           
          |sd}n)t          |t                    s|dk    rd}n|dk    rd}nd}|d|z  }nd}t          |j        d|||t	          |          fz             d S r  r  r  s          r#   r  z+OptimizeBuiltinCalls._error_wrong_arg_count	  r  r%   c                     |S r'   rP   )rF   r*   r  r   arg_listr  s         r#   _handle_functionz%OptimizeBuiltinCalls._handle_function'	  s    r%   c           	         |r|S |r|j         r|j        j        s|S |                                                     |          }|s|S t          j        |j        j        t          j	        |j        |||j
                  |d                              |                                           }	|	|                     |||||          S |j        }
|
|j        r|j        j        }
t          j        |j        |	|
          }|s|j        |_        |                    |                                            d|_        |                    |j
        |                                           S )a  
        Try to inject C-API calls for unbound method calls to builtin types.
        While the method declarations in Builtin.py already handle this, we
        can additionally resolve bound and unbound methods here that were
        assigned to variables ahead of time.
        )r"   r   r   T)r8   r9   	is_calledNr   )r   r8   r   r   r   r   r5   r   r   r4   r   analyse_as_type_attribute%_optimise_generic_builtin_method_callr   r   r   rF   analyse_c_function_callanalysedrA  )rF   r*   	type_name	attr_namer   rY  is_unbound_methodr  
type_entryr   r   	call_nodes               r#   _handle_methodz#OptimizeBuiltinCalls._handle_method*	  s     	K 	x4 	HL<P 	 K%%''..y99
 	K(M" _	& & &
     65d6F6F6H6HII 	 >==i85FH H Hy<DN<>&D,H  	 ! 	*%\IN))$*:*:*<*<===!	""49d.>.>.@.@AAAr%   c                     t          |          }|s|dk    s|j        r|j        s|S |j        j        j        s|S |j        j        t          j        u r|S t          j	        ||j        ||          S )z
        Try to inject an unbound method call for a call to a method of a known builtin type.
        This enables caching the underlying C function of the method at runtime.
        r   )
r^   r   r6   r8   r   rG  r
   	type_typer   CachedBuiltinMethodCallNode)rF   r*   rb  r   rY  rc  r   s          r#   r^  z:OptimizeBuiltinCalls._optimise_generic_builtin_method_callV	  s    
 MM	 		Qx7LQYQdK| 0 	K< 111K4(,	85 5 	5r%   r8   c           	         t          |          dk    r<t          |          dk    r't          j        |j        t	                                S |S |d         }|j        t          j        u r.|                                s|S d}t          j
        dd          }nd}t          j
        dd          }t          j        |j        || j        ||j        |d	
          S )z5Optimise single argument calls to unicode().
        r   r   ro   __Pyx_PyUnicode_UnicodePyUnicode_Unicoder9  __Pyx_PyObject_UnicodePyObject_Unicodeunicoder   r   r<  r(  )r^   r   r   r   r   r   r
   r   may_be_noner   r!   r+  PyObject_Unicode_func_typer   )rF   r*   r   r  r)   r  r<  s          r#   _handle_simple_function_unicodez4OptimizeBuiltinCalls._handle_simple_function_unicodek	  s     x==A8}}!! ,TX]__MMMMKqk8w+++??$$ 
-E&23FXXLL,E&23EWWL+HeT<L%   	r%   c                     |                      |           |j        j        t          j        u r=|j        s6|j        s/|j        r|j        dk    r|                     |d|j        g          S |S )zSimplify or avoid plain string formatting of a unicode value.
        This seems misplaced here, but plain unicode formatting is essentially
        a call to the unicode() builtin, which is optimised right above.
        r   N)	rI   rp   r   r
   r   c_format_specformat_specconversion_charrs  rJ   s     r#   visit_FormattedValueNodez-OptimizeBuiltinCalls.visit_FormattedValueNode	  su    
 	4   :?g2224;M2VZVf2' V4+?3+F+F;;D$UUUr%   r   c                     t          |          dk    r|S |d         }|j        t          j        u r>|                    d          }t          j        |j        d| j        |g|j	                  S |S )z;Replace dict(some_dict) by PyDict_Copy(some_dict).
        r   r   r   PyDict_Copyr'  )
r^   r   r
   r   r   r   r+  r   PyDict_Copy_func_typer   rF   r*   r   r  r)   s        r#   r   z1OptimizeBuiltinCalls._handle_simple_function_dict	  s~     x==AKqk8w(((''(DEEC/-)Cu,   
 r%   r  c                    t          |          dk    r|S |d         }t          j        |j        |                                r5|                                r!|j        t          j        t          j	        fv rdnd| j
        ||j                  S )z0Turn list(ob) into PySequence_List(ob).
        r   r   r  r  r'  )r^   r   r+  r   r  r   r	   r  r
   r   r  r   r|  s        r#   r  z1OptimizeBuiltinCalls._handle_simple_function_list	  s     x==AKqk+H''))'.1.@.@.B.B'H!:G<M NNN +* '*L	
 	
 	
 		
r%   r  c                    t          |          dk    s|                                s|S |d         }|j        t          j        u r|                                s|S |j        t          j        u r;|                    d          |d<   t          j	        |j
        d| j        |d          S t          j        |j
        |t          j                  S )zDReplace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        r   r   r   PyList_AsTupleTr'  )r)   r   )r^   r  r   r
   r   rq  r   r   r   r+  r   PyList_AsTuple_func_typer  r|  s        r#   _handle_simple_function_tuplez2OptimizeBuiltinCalls._handle_simple_function_tuple	  s     x==AT%8%8%:%:Kqk8w)))#//2C2C)J8w(((//35 5HQK /*D,It- - - - (sASTTTTr%   c                 :   t          |          dk    r|S |d         j        rg }g }|d         j        D ]T}|                                s)t	          j        |          }|                    |           |                    |           Ut          j        |j	        d|          }| 
                    ||           |d d d         D ]}t	          j        ||          }|S | 
                    |t          j        |j	        d| j        ||j        d                    S )Nr   r   )r   r   r$  	PySet_Newr  r   r   r(  )r^   rr  r   	is_simpler   r  rH   r   rL  r   r  r  r+  PySet_New_func_typer   )	rF   r*   r   r  r   r   r)   r  ry  s	            r#   r  z0OptimizeBuiltinCalls._handle_simple_function_set	  s7   x==AKA;. 	  DE{' ! !}} &#.s33CLL%%%C    &txFFFFLLv&&&ddd F F"7fEEM <<i&B+(' ' '      r%   c                 V   |st          j        |j                  g}nPt          |          dk    r|S |d         j        t
          j        u r"|d                                         s|d         S t          j        |j        d| j	        ||j
        t          j        dd          d          S )Nr   r   __Pyx_PyFrozenSet_Newpyfrozenset_newrS  	frozensetrp  )r   r  r   r^   r   r
   r   rq  r+  PyFrozenSet_New_func_typer   r   r!   rF   r*   r   r  s       r#   r  z6OptimizeBuiltinCalls._handle_simple_function_frozenset	  s     	!*48445HH]]QKa[!777@W@W@Y@Y7A;+H-*L$01BLQQ! ! ! 	!r%   z((double)-1)c           
          t          |          dk    rGt          j        |dd                              t          j        |                                           S t          |          dk    r|                     d||d           |S |d         }t          |t          j	                  r|j
        }|j        t          j        u r|S |j        t          j        t          j        fv r|                     ||j        |          S |j                            |j                  s|j        j        r!t          j        |j        ||j                  S |d                             d	          }|j        t          j        u rd
}d}nT|j        t          j        u rd}d}n<|j        t          j        u rd}d}n$|j        t          j        u rd}d}n|d         }d}d}t          j        |j        || j        |g|j        |rt=          |          ndd          S )zYTransform float() into either a C type cast or a faster C
        function call.
        r   r  g        r  r   r  0 or 1r9  r$  __Pyx_PyBytes_AsDoublepybytes_as_double__Pyx_PyByteArray_AsDouble__Pyx_PyUnicode_AsDoublepyunicode_as_doublePyLong_AsDoubleNr%  pyobject_as_doublerp  )r^   r   r  rA  r
   r  r   r  r(   r   r)   r   r	   r  re  rH  rI  r"   rf  rJ  r  r   r   r   r   r   int_typer+  PyObject_AsDouble_func_typer   r$   )rF   r*   r   r  r+  r)   
cfunc_nameutility_code_names           r#   r  z2OptimizeBuiltinCalls._handle_simple_function_float
  s7    x==A&E3  )G.0@0@0B0BCCD ]]a''xJJJKA;h	 <== 	$|H=J444O]z8*:VWWW))$xHHHY&&x}55 	<9Q 	<)(< < < < qk++KM M =G...1J 3]g4445J 3]g2223J 5]g...*J $1+C2J 4+Hj,5l@Q[>*;<<<W[   	r%   rp   c                    t          |          dk    r't          j        |j        ddt          j                  S t          |          dk    r|S |d         }t          |t          j                  r=|j        j	        j
        r*t          j        |j        d| j        |j        gdd          S |S |j	        j        r0|j	        j        r$t          j        |j        d	| j        |dd          S |S )
z7Transform int() into a faster C function call.
        r   r   r   r   PyLong_FromDoubleTr[  r  __Pyx_PyNumber_Int)r^   r   r   r   r
   r  r(   r   r)   r   r.  r+  PyLong_FromDouble_func_typer   PyNumber_Int_func_type)rF   r*   r   r  r+  s        r#   _handle_simple_function_intz0OptimizeBuiltinCalls._handle_simple_function_intO
  s    x==A$TXS!*1*:< < < <]]aKA;h	 <== 	| )  3H143S",u   
 =$ 	<)> 	</.0KtU< < < < r%   c                 .   t          |          dk    rLt          j        |j        dd                              t
          j        |                                           S t          |          dk    r|                     d||d           |S |d         	                    |                                           }t          j
        |j        |          }t          j
        |j        |          }|                    |                                           S )z=Transform bool(x) into a type coercion to a boolean.
        r   Fr  r   boolr  r   )r^   r   r   r   rA  r
   r  r   r  r   r   coerce_to_pyobject)rF   r*   r   r  r   s        r#   _handle_simple_function_boolz1OptimizeBuiltinCalls._handle_simple_function_boolf
  s     x==A%u  )G-t/?/?/A/ABBC ]]a''hIIIK qk33D4D4D4F4FGGG'GDDDG'GDDDG--d.>.>.@.@AAAr%   c                    t          |          dk    r|                     d||d           |S |d         j        j        r0t	          j        |j        d| j        |d         g|j        d          S |d         j        j	        rI|d         j
        t          j        u r0t	          j        |j        d| j        |d         g|j        d          S |S )Nr   
memoryviewrY  r   PyMemoryView_FromObjectr  PyMemoryView_FromBuffer)r^   r  r   r   r   r+  r   !PyMemoryView_FromObject_func_typer   r   r   r
   py_buffer_type!PyMemoryView_FromBuffer_func_typer  s       r#   "_handle_simple_function_memoryviewz7OptimizeBuiltinCalls._handle_simple_function_memoryview
  s    x==A''dHcJJJK{+ , 3H7:$QK="l*, , , , !!( ,Xa[-BgF\-\-\ !3H7:$QK="l*, , , , r%   ro  __Pyx_PyUnicode_GET_LENGTHr(  __Pyx_PyByteArray_GET_SIZE__Pyx_PyList_GET_SIZE__Pyx_PyTuple_GET_SIZE__Pyx_PySet_GET_SIZEPyDict_Sizezcpython.array.arrayc                    t          |          dk    r|                     d||d           |S |d         }t          |t          j                  r|j        }|j        j        r+t          j        |j	        d| j
        |g|j                  }n{|j        j        r?t          j        |j	        d| j        |g|j        t          j        dd          	          }n0|j        j        r`t#          j        t"          j        t#          j        d
|j        d          gd          }t          j        |j	        d||g|j                  }n|j        j        r|                     |j                  }|-|j        }|j        s|j        r|j        j        | j        v rd}n|S |                    d          }t          j        |j	        || j        |g|j                  }n0|j        j        r"t          j        |j	        dd|j                  S |S |j        t"          j         t"          j        fvr-|!                    |j        | "                                          }|S )zReplace len(char*) by the equivalent call to strlen(),
        len(Py_UNICODE) by the equivalent Py_UNICODE_strlen() and
        len(known_builtin_type) by an equivalent C-API call.
        r   r^   r   __Pyx_ssize_strlenr'  __Pyx_Py_UNICODE_ssize_strlenssize_pyunicode_strlenr9  r:  memoryviewsliceNT)nogil__Pyx_MemoryView_LenPy_SIZEz&object of type 'NoneType' has no len()rY  r   )#r^   r  r(   r   r   r)   r   rb  r+  r   Pyx_ssize_strlen_func_typer   is_pyunicode_ptrPyx_Py_UNICODE_strlen_func_typer   r!   r   r	   r  r  r  r   _map_to_capi_len_functionis_extension_typerG  r   qualified_name_ext_types_with_pysizer   PyObject_Size_func_typer/  r   c_size_t_typerA  r   )	rF   r*   r   r  r)   r   r  r  r  s	            r#   _handle_simple_function_lenz0OptimizeBuiltinCalls._handle_simple_function_len
  s   
 x==A''tXqAAAKqkc9788 	'C8 %	 3.0Ou,( ( (HH X&  	 394;_u,*67OQ`aa	c c cHH
 X( 	",,+,=sxNN/  I !30)UDL2 2 2HH X! 	77AAJ!8/  83K  $N9T=XXX!*JJK''8: :C 3*d&BUDL2 2 2HH X% 	$TXS!*.)5 5 5 5 K9Z5z7STTT))$)T5E5E5G5GHHHr%   objectc                     t          |          dk    r|S t          j        |j        d| j        |d          }t          j        |t          j                  S )z7Replace type(o) by a macro call to Py_TYPE(o).
        r   Py_TYPEFr'  )r^   r   r+  r   Pyx_Type_func_typerc  r	   r  r  s       r#   _handle_simple_function_typez1OptimizeBuiltinCalls._handle_simple_function_type
  s[     x==AK+Hi!8   !$
(ABBBr%   c           
      
   t          |          dk    rS |\  }}g }t          |t          j                  rz|j        }t          |          dk    r|d         j        t          j        urS |j        s|	                                s)t          j        |          }|                    |           n|j        t          j        u r|g}nS g }g }|                                 |D ]=}	d}
|	j        rB|	j        r;                    |	j        j                  }|r|j        r|j        j        r|j        }
|
t          j        u r |j        dk    s|j        r|j        j        sd}
|
9|j                            d          }||v r|                    |           |g}nP|	j        t          j        u rd}||	g}n6|	j        s)t          j        |	          }	|                    |	           d	}||	g}|                    t          j        |	j        || j        |d
                     ?t          j        ffd	}t7          ||                              j                  }|ddd         D ]}t          j        ||          }|S )zcReplace isinstance() checks against builtin types by the
        corresponding C-API call.
        r   r   r   Nr   F)exact__Pyx_TypeCheckPyObject_IsInstanceTr'  c                 z     |j         d| |          }t          j        |_        |                               |S )Nr  )r   r	   rN  r   r-  )r:   r;   make_binop_nodeor_noder  r*   s       r#   join_with_orzMOptimizeBuiltinCalls._handle_simple_function_isinstance.<locals>.join_with_or>  s=    %odha;;G%1GL!!#&&&Nr%   r$  )r^   r(   r   rJ  r   r   r
   rh  r   r  r   r.   rH   r   r   r   r   r"   rG  scopeis_builtin_scopetype_check_functionr=  r+  r   Py_type_check_func_typer  r   rA  r  )rF   r*   r   r  r)   typesr   tests
test_nodestest_type_nodebuiltin_typer   r  type_check_argsr  r  ry  r  s    `               @r#   "_handle_simple_function_isinstancez7OptimizeBuiltinCalls._handle_simple_function_isinstance  s    x==AK
UeY011 
	JE5zzQuQx}8I'I'I "s}} "-c22S!!!Z7,,,GEEK
  #  	  	NL% 2!' 2JJ~';'@AAE 2 2
0J 2',zw000:'' ((-(D (#'L'&+j&D&D5&D&Q&Q#&%//0111#&%$(999&7##&"7%0 1%.%<^%L%LNLL000&;##&"7,"&(;T=Y(       09/C 	 	 	 	 	 	 	 <44>>ty#NN	$$B$K 	H 	HD!6tYGGIIr%   c           	         t          |          dk    r|S |d         }t          |t          j                  rh|j        j        j        rVt          j        |j        |j        t          j
                                      |j        |                                           S nt          |t          j        t          j        f          rt          |j                  dk    rt          j        |j        t          j        t%          t'          |j                            t'          |j                                                |j        |                                           S |S )z-Unpack ord(Py_UNICODE) and ord('X').
        r   r   r9  rT  )r^   r(   r   r   r)   r   r/  r  r   r	   r  rA  r   r   r?  rp   r   rE  rC  r   r|  s        r#   r  z0OptimizeBuiltinCalls._handle_simple_function_ordI  s+    x==AKqkc9788 	?w|+ ? -GSW:3I  i	4+;+;+=+=>>?? i3Y5HIJJ 	?39~~"" (G*"7c#)nn--$'	NN    i	4+;+;+=+=>>	?
 r%   r   r   r  c           
         |j         }|rt          |          dk     r|S |d         }|j        r|j        s|S |j        t          j        k    s|j        t          j        k    r|S |j        r|j        s|j        |j        k    r|S n|j        |j        k    r|S t          j	        |j
        |dd                   }|                    |                                 d          }|j        r|j        j        }	|	j        ry|	j        rq|	j                                        |                                                                 k    r/t#          j        dd          }
t#          j        |	j        |
          }|r| j        j        }t-          j        |                    d	          j                  }t-          j        |	t-          j        d
|d          t-          j        dt,          j        d          t-          j        dt,          j        d          g          }t          j        ||          }|s%t          j        |j
        t,          j                  }t          j        |j
        |||||gdd          S n|                    d          }tA          j!        dd          }|r,t          j        |j
        d| j"        |||g||j#                  S t          j        |j
        d| j$        ||g||j#                  S )zOReplace 'exttype.__new__(exttype, ...)' by a call to exttype->tp_new()
        r   r   N)r   Tskip_childrentp_new__new__PyTypeObjectr   r   r  r   F)r   may_return_noner   z4object.__new__(X): X is not a type object (NoneType)zObjectHandling.c__Pyx_tp_new_kwargs)r   r<  r   __Pyx_tp_new)%r8   r^   r   r   r
   rh  rd  r"   r   rJ  r   analyse_typesr   r  typeobj_cnamer  r   r   ConstructorSlotget_slot_functionr   cython_scoper	   CPtrTyper   r  r  r  rc  r  r+  r   r   r!   Pyx_tp_new_kwargs_func_typer   Pyx_tp_new_func_type)rF   r*   r   r   rc  r  r8   type_arg
args_tupleext_typetp_slotslot_func_cnamer  PyTypeObjectPtrpyx_tp_new_kwargs_func_typer<  s                   r#   _handle_any_slot__new__z,OptimizeBuiltinCalls._handle_any_slot__new__l  s(    l  	CIIMMK7{ 	("2 	K8w(((HMW=N,N,NK" 	#. 	x8=(( )  CN22K(QRRAAA
--d . 4 4
  	H*/H* &x/E &N//11T5E5E5G5G5T5T5V5VVV#3HiHH"+"=hng"V"V" &#'<#<L&0&9$++N;;@'B 'BO2<2F &3FotTT&3Fj>WY]^^&3Hj>WY]^^#3 3/  )1(OLLH! ^!*!3DH:C\!]!]!]$7/3&
F;(- $& & & &  11FH HH #.x9KLL 	//1Q
F3)	    /.$*C
+)	   r%   c                     |S r'   rP   )rF   r*   r   r   rc  r  s         r#   _handle_any_slot__class__z.OptimizeBuiltinCalls._handle_any_slot__class__  s	    
 r%   rs  c                     t          |          dk    s|j        s|j        j        r|S t	          j        |j        d| j        |d|j        dt          d                    S )z\Optimistic optimisation as X.append() is almost always
        referring to a list.
        r   __Pyx_PyObject_AppendFrH   )r   r  r   r;  r<  )
r^   r;  r   r   r   r+  r   PyObject_Append_func_typer   r$   rF   r*   r   r   rc  s        r#   #_handle_simple_method_object_appendz8OptimizeBuiltinCalls._handle_simple_method_object_append  sh     t99>>T0>DM4G>K+H-t/M!L '11
 
 
 	
r%   c                 P   t          |          dk    r|S |\  }}|j        s|S t          |j                  }|j        t          |          dk    r	 |S |                     |||d          }	|s|j        |	_        |	S |	x}
}t          |          dk    r(|                                st!          j        |          }
g }|d	         }|                                s)t!          j        |          }|                    |           t          j        |j        d
| j        |
|gdt-          d                    }|ddd	         D ]}|                                s)t!          j        |          }|                    |           t          j        |j        dt          j        |j        d| j        |
|gddt-          d                    |t0          j                  }|j        |_        |
|ur|                    |
           |D ]#}t!          j        ||          }|j        |_        $|S )zReplace list.extend([...]) for short sequence literals values by sequential appends
        to avoid creating an intermediate sequence argument.
        r   N   Fr   Tr  extendr$  __Pyx_PyList_Append
ListAppendr:  |__Pyx_ListComp_AppendListCompAppend)r   r(  r   r<  r  )r^   rr  r  r   mult_factorr(   r   rK  r  r  r   r   r  _wrap_self_argr;  r  r   r  rH   r+  r   r  r$   r  r	   c_returncode_typer  )rF   r*   r   r   rc  r8   rp   r   
tuple_nodewrapped_obj
cloned_objr   r)   r   ry  s                  r#   !_handle_simple_method_list_extendz6OptimizeBuiltinCalls._handle_simple_method_list_extend  s\    t99>>K
U, 	KUZ  (CJJNNL K))#x9JHUU 	)-)<K&&&
Su::>>#--//>"-c22J Bi}} 	&s++CLL/H+T-Kc"'55	7 7 7
 R= 	 	C==?? "*3//S!!! +#,H5t7U$c*H !/0@!A!A	C C C
 1	 	 	HH #'"5S  LL$$$ 	: 	:D 5dHEEH&*&9H##r%   	bytearrayc           	      .   t          |          dk    r|S d}| j        }t          |d                   }|j        j        st          |t          j                  rH|                    t          j
        |                                           }t          j        dd          }n|j        r^|                                s|S |                    t          j        |                                           }t          j        dd          }n-|j        j        rd}| j        }t          j        dd          }n|S t          j        |j        |||d         |gd	|j        |
          }	|j        r-|	                    |j        |                                           }	|	S )Nr   __Pyx_PyByteArray_Appendr   ByteArrayAppendr9  __Pyx_PyByteArray_AppendObjectByteArrayAppendObjectr   Fr   r  r   r<  )r^   PyByteArray_Append_func_typer,   r   r   r(   r   r   rA  r	   rE  r   r   r!   is_string_literalcan_coerce_to_char_literalr;  r   "PyByteArray_AppendObject_func_typer+  r   r   r;  )
rF   r*   r   r   rc  	func_namer  rp   r<  r   s
             r#   &_handle_simple_method_bytearray_appendz;OptimizeBuiltinCalls._handle_simple_method_bytearray_append"  s   t99>>K.	5	#DG,,: 	
5)2C D D 	OOJ$94;K;K;M;MNNE&23DoVVLL$ 
	3355 OOJ$:D<L<L<N<NOOE&23DoVVLLZ# 	8I?I&23JO\\LLK/Hiq'5!!L%
 
 
  	I))$)T5E5E5G5GHHHr%   py_indexc_index	is_signed)has_varargsc                 6    |                      ||||d          S )NT)is_list) _handle_simple_method_object_popr  s        r#   _handle_simple_method_list_popz3OptimizeBuiltinCalls._handle_simple_method_list_popQ  s.    44(D"3T 5 C C 	Cr%   Fc                    |s|S |d         }|rd}|                     dddg          }nd}t          |          dk    r;t          j        |j        d	|z  | j        |gd
|j        t          d                    S t          |          dk    rt          |d                   }t          j	        |j                  }	|j
        }
|j
        j        st          |t          j                  rZ|                    |                                           }	|                    t"          j        |                                           }n|rz|j
        j        r;|                    |                                           }	t          j        |	          }|                    t"          j        |                                           }ni|S t#          j        |j
        t"          j                  s|S t          |t          j                  r'|                    |                                           }	|
j        s|j
        }
|
                    |                                           s|S |
j        }t#          j        t"          j        t#          j        d|
d          g          }t          j        |j        d|z  | j        ||	|t          j        |j        t;          |
j        rdpd          |
j        rdpdt"          j                  t          j         |j        t"          j!        |
"                                          t          j         |j        ||          gd
|j        t          d                    S |S )z\Optimistic optimisation as X.pop([n]) is almost always
        referring to a list.
        r   List*'NoneType' object has no attribute '%.30s'r  popr  Objectr   z__Pyx_Py%s_PopTr  r   intvalNz__Pyx_Py%s_PopIndexr   	pop_index)#r   r^   r   r+  r   PyObject_Pop_func_typer   r$   r,   r  r   r   r(   r   r  r   rA  r	   r  r   r_  ra  numeric_type_fitscreate_to_py_utility_codeto_py_functionr  r  r  PyObject_PopIndex_func_typerC  signedrE  RawCNameExprNodec_void_typeempty_declaration_code)rF   r*   r   r   rc  r   r8   ra  r   r  orig_index_typeconvert_funcconversion_types                r#   r!  z5OptimizeBuiltinCalls._handle_simple_method_object_popU  s_     	K1g 	!I''<,"G ( % %CC
 !It99>>/*Y6+U $+E22    YY!^^'Q00E )%)44H#jO:$ HeY%677 	 $778H8H8J8JKKH!OOJ,H$JZJZJ\J\]]EE  z- >#(#9#9$:J:J:L:L#M#M ) 3H = =!OOJ,H$JZJZJ\J\]]EEK1%*j>Z[[ HE9#455 H 33D4D4D4F4FGG") -"'*"<<T=M=M=O=OPP *9L(2)J,CHo_c,d,d+eg gO//);08U'	_=S=YXY=^]^9_9_8G8N8TST8YXY-7-BD D D  0J<R1@1W1W1Y1Y[ [0O\ZZ\ !%+K88    r%   c           	          t          |          dk    r|S |                     ||d| j        d||                              |j        | j                  S )z?Call PyList_Sort() instead of the 0-argument l.sort().
        r   PyList_Sortr  )r^   _substitute_method_callsingle_param_func_typerA  r   r   r  s        r#   _handle_simple_method_list_sortz4OptimizeBuiltinCalls._handle_simple_method_list_sort  sY     t99>>K++(M4+F%t- --6Yty$BR-S-S	Tr%   keydefaultc                 <   t          |          dk    r-|                    t          j        |j                             n-t          |          dk    r|                     d||d           |S |                     ||d| j        d||dt          d          		  	        S )
z:Replace dict.get() by a call to PyDict_GetItem().
        r   r   zdict.get2 or 3__Pyx_PyDict_GetItemDefaultr  Tdict_getitem_defaultr  r<  )	r^   rH   r   r  r   r  r8  Pyx_PyDict_GetItem_func_typer$   r  s        r#   _handle_simple_method_dict_getz3OptimizeBuiltinCalls._handle_simple_method_dict_get  s     t99>>KK	*48445555YY!^^''
D$IIIK++()4+L$d")*@AA , C C 	Cr%   is_safe_typec                 0   t          |          dk    r-|                    t          j        |j                             n-t          |          dk    r|                     d||d           |S |d         j        }|j        rt          |j	        dv           }n|t          j        u rd}nd}|                    t          j        |j        t          |          |	                     |                     ||d
| j        d||dt!          d          	  	        S )zUReplace dict.setdefault() by calls to PyDict_GetItem() and PyDict_SetItem().
        r   r   zdict.setdefaultr>  r   z%str bytes unicode float int long boolr$  r   r  __Pyx_PyDict_SetDefault
setdefaultTdict_setdefaultrA  )r^   rH   r   r  r   r  r   rG  r[  r"   r	   r  r   rC  r8  Pyx_PyDict_SetDefault_func_typer$   )rF   r*   r   r   rc  key_typerD  s          r#   %_handle_simple_method_dict_setdefaultz:OptimizeBuiltinCalls._handle_simple_method_dict_setdefault  s8    t99>>KK	*48445555YY!^^''(94xPPPK7<# 	x}F G H HLL222LLLI%HC--|M M M 	N 	N 	N ++(%t'K+T '(9:: , < < 	<r%   c                 n   d}d}| j         }t          |          dk    r-|                    t          j        |j                             n@t          |          dk    r|j        sd}d}| j        }n|                     d||d           |S | 	                    ||||d	||d
t          |          	  	        S )z7Replace dict.pop() by a call to _PyDict_Pop().
        __Pyx_PyDict_Poppy_dict_popr   r   __Pyx_PyDict_Pop_ignorepy_dict_pop_ignorezdict.popr>  r&  TrA  )PyDict_Pop_func_typer^   rH   r   r  r   r;  PyDict_Pop_ignore_func_typer  r8  r$   )rF   r*   r   r   rc  	capi_funcr  r  s           r#   _handle_simple_method_dict_popz3OptimizeBuiltinCalls._handle_simple_method_dict_pop  s     '	)-	t99>>KK	*48445555YY!^^& =5	$8! <	''
D$IIIK++(y$d '(9:: , < < 	<r%   c                    i | ]}t           j        t           j        fD ]}||ft          j        |t          j        d t           j        d          t          j        dt           j        d          t          j        d|d          t          j        dt           j        d          t          j        dt           j        d          g|j        rdn|j                  S )op1Nop2cvalinplacezerodiv_checkr"  )r	   r  rN  r  r  r   r#  )rc   ctyperet_types      r#   rB  zOptimizeBuiltinCalls.<dictcomp>  s     
 
 
 #2J4JK
 
  
:/'z/H$OO'z/H$OO't<<'	:3I4PP'9OQUVV (0';YttAY[ [ [
 
 
 
r%   c                 4    |                      d||||          S NAdd_optimise_num_binopr  s        r#   $_handle_simple_method_object___add__z9OptimizeBuiltinCalls._handle_simple_method_object___add__      ''tXtEVWWWr%   c                 4    |                      d||||          S NSubtractr`  r  s        r#   $_handle_simple_method_object___sub__z9OptimizeBuiltinCalls._handle_simple_method_object___sub__      ''
D(DJ[\\\r%   c                 4    |                      d||||          S )NMultiplyr`  r  s        r#   $_handle_simple_method_object___mul__z9OptimizeBuiltinCalls._handle_simple_method_object___mul__  rh  r%   c                 4    |                      d||||          S NEqr`  r  s        r#   #_handle_simple_method_object___eq__z8OptimizeBuiltinCalls._handle_simple_method_object___eq__!      ''dHdDUVVVr%   c                 4    |                      d||||          S NNer`  r  s        r#   #_handle_simple_method_object___ne__z8OptimizeBuiltinCalls._handle_simple_method_object___ne__$  rp  r%   c                 4    |                      d||||          S )NAndr`  r  s        r#   $_handle_simple_method_object___and__z9OptimizeBuiltinCalls._handle_simple_method_object___and__'  rc  r%   c                 4    |                      d||||          S )NOrr`  r  s        r#   #_handle_simple_method_object___or__z8OptimizeBuiltinCalls._handle_simple_method_object___or__*  rp  r%   c                 4    |                      d||||          S )NXorr`  r  s        r#   $_handle_simple_method_object___xor__z9OptimizeBuiltinCalls._handle_simple_method_object___xor__-  rc  r%   c                 
   t          |          dk    s t          |d         t          j                  s|S |d                                         rd|d         j        cxk    rdk    sn |S |                     d||||          S )Nr   r   ?   Rshiftr^   r(   r   r   r   r=   ra  r  s        r#   '_handle_simple_method_object___rshift__z<OptimizeBuiltinCalls._handle_simple_method_object___rshift__0      t99>>DGY5F!G!G>KAw**,, 	Q$q':Q5W5W5W5WUW5W5W5W5WK''$$HYZZZr%   c                 
   t          |          dk    s t          |d         t          j                  s|S |d                                         rd|d         j        cxk    rdk    sn |S |                     d||||          S )Nr   r   r  Lshiftr  r  s        r#   '_handle_simple_method_object___lshift__z<OptimizeBuiltinCalls._handle_simple_method_object___lshift__7  r  r%   c                 4    |                      d||||          S N	Remainder_optimise_num_divr  s        r#   $_handle_simple_method_object___mod__z9OptimizeBuiltinCalls._handle_simple_method_object___mod__>  s    %%k44IZ[[[r%   c                 4    |                      d||||          S )NFloorDivider  r  s        r#   )_handle_simple_method_object___floordiv__z>OptimizeBuiltinCalls._handle_simple_method_object___floordiv__A  s    %%mT8TK\]]]r%   c                 4    |                      d||||          S N
TrueDivider  r  s        r#   (_handle_simple_method_object___truediv__z=OptimizeBuiltinCalls._handle_simple_method_object___truediv__D  s    %%lD(DJ[\\\r%   c                 4    |                      d||||          S NDivider  r  s        r#   $_handle_simple_method_object___div__z9OptimizeBuiltinCalls._handle_simple_method_object___div__G  s    %%hhFWXXXr%   c                    t          |          dk    s+|d                                         r|d         j        dk    r|S t          |d         t          j                  rd|d         j        cxk    rdk    sn |S n?t          |d         t          j                  rd|d         j        cxk    rdk    sn |S n|S |                     |||||          S )Nr   r   r   r   r   l       l          )r^   r   r=   r(   r   r   r  ra  )rF   rl   r*   r   r   rc  s         r#   r  z&OptimizeBuiltinCalls._optimise_num_divX  s    t99>>a!<!<!>!>>$q'BY]^B^B^Kd1gy011 	d1g5>>>>>>>> ?Q!455 	d1g5>>>>>>>> ? K''$$HYZZZr%   c                 4    |                      d||||          S r^  r`  r  s        r#   #_handle_simple_method_float___add__z8OptimizeBuiltinCalls._handle_simple_method_float___add__e  rc  r%   c                 4    |                      d||||          S re  r`  r  s        r#   #_handle_simple_method_float___sub__z8OptimizeBuiltinCalls._handle_simple_method_float___sub__h  rh  r%   c                 4    |                      d||||          S r  r`  r  s        r#   '_handle_simple_method_float___truediv__z<OptimizeBuiltinCalls._handle_simple_method_float___truediv__k  s    ''dHdL]^^^r%   c                 4    |                      d||||          S r  r`  r  s        r#   #_handle_simple_method_float___div__z8OptimizeBuiltinCalls._handle_simple_method_float___div__n  s    ''$$HYZZZr%   c                 4    |                      d||||          S r  r`  r  s        r#   #_handle_simple_method_float___mod__z8OptimizeBuiltinCalls._handle_simple_method_float___mod__q  s    ''T8TK\]]]r%   c                 4    |                      d||||          S rm  r`  r  s        r#   "_handle_simple_method_float___eq__z7OptimizeBuiltinCalls._handle_simple_method_float___eq__t  rp  r%   c                 4    |                      d||||          S rr  r`  r  s        r#   "_handle_simple_method_float___ne__z7OptimizeBuiltinCalls._handle_simple_method_float___ne__w  rp  r%   c                    t          |dd          r|S t          |          dk    r|S |j        j        rt          j        }n&|j        t          j        u r|dv rt          j        }n|S t          ||||d         |d                   }|s|S |\  }}	}
}t          d |D                       sJ t          |          |
z   }| 
                    |||| j        ||f         d|dd	                                         z  ||d
d|	
  
        }|j        j        r4|j        s-t          j        ||                                 |j                  }|S )zY
        Optimise math operators for (likely) float or small integer operations.
        special_bool_cmp_functionNr   rn  rs  r   r   c                 &    g | ]}|j         j        S rP   )r   r   rD  s     r#   rf   z<OptimizeBuiltinCalls._optimise_num_binop.<locals>.<listcomp>  s    999SCH(999r%   z__%s__r   TF)r  with_none_checkr<  )r  r^   r   r   r	   r  rN  optimise_numeric_binopr  r  r8  Pyx_BinopInt_func_typeslowerr   r   r   )rF   rl   r*   r   r   rc  r\  r  
func_cnamer<  
extra_argsnum_typere  s                r#   ra  z(OptimizeBuiltinCalls._optimise_num_binopz  s    44d;; 	Kt99>>K9  	!0HHY*000X5M5M!-HHK'$$q'4PQ7SS 	K9?6
L*h99D999:::::DzzJ&00(((H)=>x|))+++-> !% 1 ' '	 9  	_)= 	_!4Y@P@P@R@RTXT]^^Ir%   ucharc           
         |st          |          dk    r|S |d         }t          |t          j                  r|j        j        j        s|S |j        }|j        }t          j	        ddt          |                    }d|                                z  }	|                     |||	| j        |||g|          }
|j        j        r|
                    | j                  }
|
S )	Nr   r   py_unicode_predicater9  )r  r   z__Pyx_Py_UNICODE_%sr  )r^   r(   r   r   r)   r   r/  r9   r   r!   r   upperr8  #PyUnicode_uchar_predicate_func_typer   r  r   )rF   r*   r   r   rc  ustringr  r  r<  r  	func_calls              r#   _inject_unicode_predicatez.OptimizeBuiltinCalls._inject_unicode_predicate  s    	D		QKq''9#?@@ 	;#3	K()5"O[111
 
 
 .0A0A0C0CC00(4C*UG'	 1 ) )	
 9  	G!44T5EFFIr%   rC  keependsc           	          t          |          dvr|                     d||d           |S |                     ||dd           |                     ||d| j        d||          S )zfReplace unicode.splitlines(...) by a direct call to the
        corresponding C-API function.
        r  zunicode.splitlinesz1 or 2r   FPyUnicode_Splitlines
splitlines)r^   r  _inject_bint_default_argumentr8  PyUnicode_Splitlines_func_typer  s        r#   (_handle_simple_method_unicode_splitlinesz=OptimizeBuiltinCalls._handle_simple_method_unicode_splitlines  s|     t99E!!''(<dD(SSSK**4q%@@@++("D$G+T3 3 	3r%   sepmaxsplitc           	         t          |          dvr|                     d||d           |S t          |          dk     r-|                    t          j        |j                             n|                     |d           |                     ||dt          j	        d           | 
                    ||d| j        d||          S )	zaReplace unicode.split(...) by a direct call to the
        corresponding C-API function.
        )r   r   r   zunicode.split1-3r   r   rV  PyUnicode_Splitsplit)r^   r  rH   r   r  r   _inject_null_for_none_inject_int_default_argumentr	   r  r8  PyUnicode_Split_func_typer  s        r#   #_handle_simple_method_unicode_splitz8OptimizeBuiltinCalls._handle_simple_method_unicode_split  s     t99G##''tUKKKKt99q==KK	*48445555&&tQ///))$:7	? 	? 	? ++(t=&. . 	.r%   seqc           	         t          |          dk    r|                     d||d           |S t          |d         t          j                  r|d         }|j        }t          |          }|rkt          j        |j        |dt          j
                  }|D ]<\  }	}
t          j        |	j        |	|j                  }t          j        ||
|           =||d<   |                     ||d| j        d	||          S )
z^
        unicode.join() builds a list first => see if we can do this more efficiently
        r   zunicode.join2r   r  r  r  PyUnicode_Joinrs  )r^   r  r(   r   r  r  r]   r  r   r
   r   r  r|   r   r  r8  PyUnicode_Join_func_type)rF   r*   r   r   rc  r  r  r_   inlined_genexprr  r  r  s               r#   "_handle_simple_method_unicode_joinz7OptimizeBuiltinCalls._handle_simple_method_unicode_join  s)    t99>>''dCHHHKd1gy@AA 	* GM%*I5i@@ *"+"JHmv'.'8#: #: #: :J b b5$o"+"C(,-.5#7 #7 #7K
 4]OU`aaaa)Q++(d;%t- - 	-r%   	substringr)  end	directionc           
      D    |                      ||||ddt          d          S )NrC  endswithr   _inject_tailmatchunicode_tailmatch_utility_coder  s        r#   &_handle_simple_method_unicode_endswithz;OptimizeBuiltinCalls._handle_simple_method_unicode_endswithF  s-    %%(D"3UJ*B0 0 	0r%   c           
      D    |                      ||||ddt          d          S )NrC  
startswithr$  r  r  s        r#   (_handle_simple_method_unicode_startswithz=OptimizeBuiltinCalls._handle_simple_method_unicode_startswithK  s-    %%(D"3UL*B0 0 	0r%   c	           
      d   t          |          dvr|                     | d| ||d           |S |                     ||dt          j        d           |                     ||dt          j        d           |                    t          j        |j        t          |          t          j
                             |d	k    rd
}	nd|                                 d}	|                     |||	| j        ||||          }
|
                    t          j        |                                           S )zReplace unicode.startswith(...) and unicode.endswith(...)
        by a direct call to the corresponding C-API function.
        r   r      rq  2-4r   r   r   PY_SSIZE_T_MAXrp   r   rC  __Pyx_PyUnicode_Tailmatch__Pyx_Py
_Tailmatchr  )r^   r  r  r	   r  rH   r   r   r   rC  rE  
capitalizer8  PyString_Tailmatch_func_typerA  r
   r  r   )rF   r*   r   r   rc  ra  r  r<  r  r  method_calls              r#   r  z&OptimizeBuiltinCalls._inject_tailmatchP  s^   
 t99G##''9(D(D{(D(DdDRWXXXK))$:7	> 	> 	>))$:79I	K 	K 	KI%HC	NN1FH H H 	I 	I 	I 3IIE9#7#7#9#9EEEI22(t8*D'	 3 ) )
 $$W%68H8H8J8JKKKr%   r  c                 6    |                      ||||dd          S )Nfindr   _inject_unicode_findr  s        r#   "_handle_simple_method_unicode_findz7OptimizeBuiltinCalls._handle_simple_method_unicode_findu  s+    (((D"3VRA A 	Ar%   c                 6    |                      ||||dd          S )Nrfindr$  r  r  s        r#   #_handle_simple_method_unicode_rfindz8OptimizeBuiltinCalls._handle_simple_method_unicode_rfindy  s+    (((D"3WbB B 	Br%   c           	         t          |          dvr|                     d|z  ||d           |S |                     ||dt          j        d           |                     ||dt          j        d           |                    t          j        |j        t          |          t          j
                             |                     ||d	| j        |||          }|                    |                                           S )
zwReplace unicode.find(...) and unicode.rfind(...) by a
        direct call to the corresponding C-API function.
        r  z
unicode.%sr  r   r   r   r  r  PyUnicode_Find)r^   r  r  r	   r  rH   r   r   r   rC  rE  r8  PyUnicode_Find_func_typer  r   )rF   r*   r   r   rc  r  r  r  s           r#   r  z)OptimizeBuiltinCalls._inject_unicode_find}  s   
 t99G##''{(BD$PUVVVK))$:7	> 	> 	>))$:79I	K 	K 	KI%HC	NN1FH H H 	I 	I 	I 22(,d.K*D2 2 --d.>.>.@.@AAAr%   c           	      r   t          |          dvr|                     d||d           |S |                     ||dt          j        d           |                     ||dt          j        d           |                     ||d| j        d	||          }|                    |                                           S )
zaReplace unicode.count(...) by a direct call to the
        corresponding C-API function.
        r  zunicode.countr  r   r   r   r  PyUnicode_Countcount)	r^   r  r  r	   r  r8  PyUnicode_Count_func_typer  r   )rF   r*   r   r   rc  r  s         r#   #_handle_simple_method_unicode_countz8OptimizeBuiltinCalls._handle_simple_method_unicode_count  s     t99G##''tUKKKK))$:7	> 	> 	>))$:79I	K 	K 	K 22(-t/M&. . --d.>.>.@.@AAAr%   replstrmaxcountc           	          t          |          dvr|                     d||d           |S |                     ||dt          j        d           |                     ||d| j        d||          S )zcReplace unicode.replace(...) by a direct call to the
        corresponding C-API function.
        )r   r  zunicode.replacez3-4r   rV  PyUnicode_Replacer  )r^   r  r  r	   r  r8  PyUnicode_Replace_func_typer  s        r#   %_handle_simple_method_unicode_replacez:OptimizeBuiltinCalls._handle_simple_method_unicode_replace  s     t99E!!''(94uMMMK))$:7	? 	? 	? ++(/1Q($0 0 	0r%   encodingerrors)UTF8UTF16UTF-16LEUTF-16BELatin1ASCIIunicode_escaperaw_unicode_escapec                 :    g | ]}|t          j        |          fS rP   )r   
getencoder)rc   r"   s     r#   rf   zOptimizeBuiltinCalls.<listcomp>  s8     9 9 9  v0667 9 9 9r%   c                 2   t          |          dk     st          |          dk    r|                     d||d           |S |d         }|                     |j        |          }||S |\  }}}	}
|                                r[	 |j                            ||	          }t          ||pd          }t          j	        |j        |t          j                  S #  Y nxY wt          |          dk    r<t          j        |j                  }|                     ||d	| j        d
||||g          S |rG|	dk    rA|                     |          }|*d|vr&d|z  }|                     |||| j        d
||g          S |                     ||d	| j        d
||||
g          S )z_Replace unicode.encode(...) by a direct C-API call to the
        corresponding codec.
        r   r   zunicode.encoder  r   NzUTF-8r  PyUnicode_AsEncodedStringr>  strictr  zPyUnicode_As%sString)r^   r  _unpack_encoding_and_error_moder   r   r=   r>  r   r   r?  r
   r   r  r8  #PyUnicode_AsEncodedString_func_type_find_special_codec_namePyUnicode_AsXyzString_func_type)rF   r*   r   r   rc  string_node
parametersr  encoding_nodeerror_handlingerror_handling_noderp   	null_node
codec_nameencode_functions                  r#   $_handle_simple_method_unicode_encodez9OptimizeBuiltinCalls._handle_simple_method_unicode_encode  s    t99q==CIIMM''(8$eLLLK1g99$(DII
KGQD-1D**,, 		bb#3::8^TT
 &eX-@AA *;?%gN`aaaa
 t99>>!*4844I//h ;8+k9i-PR R R
  	@(2266x@@J%#Z*?*?"8:"E33(O8/+@ @ @
 ++(74'-)<=	? ? 	?s   C Cstringr]  r*  decode_funcc                 
   dt          |          cxk    rdk    sn |                     d||d           |S |d         }|                     |j        |          }||S |\  }}}	}
|                                rb	 |j                            ||	          }t          |j        t          |          |j                  S # t          t          t          f$ r Y nw xY wdx}}t          |t          j                  r&|}|j        }|j        |j        }}|r|j        dk    rd}t          |t          j                  r|j        }|j        }|t*          j        t*          j        fv r;|r|                    dd	|j        g
          }n*|                    ddd	g          }n|j        s	|j        s|S |st          j        |j        dd          }n>|j        j        s2|                    t>          j         | !                                          }|r>|j        j        s2|                    t>          j         | !                                          }d}|| "                    |          }|^|dv rd|#                    dd          z  }nd|z  }t          j$        |j        | j%        |          }t          j&        |j                  }nt          j&        |j                  }g }|j        ra|sT|j'        s)tQ          j)        |          }|*                    |           t          j+        |j        d| j,        |gd          }| j-        }d}nZ|j        r|s&t          j        |j        dt          j.                  }| j/        t?          j0        t*          j1        t?          j2        d|d          t?          j2        dt>          j         d          t?          j2        dt>          j         d          t?          j2        dt>          j3        d          t?          j2        dt>          j3        d          t?          j2        d | j%        d          g          | _/        | j/        }d!|j         }nB|s&t          j        |j        dt          j.                  }| j4        }|t*          j        u rd"}nd#}t          j+        |j        d$|z  ||||||
|g|j5        tm          j7        |d%          &          }|ddd'         D ]}tQ          j8        ||          }|S )(zReplace char*.decode() by a direct C-API call to the
        corresponding codec, possibly resolving a slice on the char*.
        r   r   zbytes.decoder  r   Nrp   rM  @descriptor '%s' requires a '%s' object but received a 'NoneType'decoder  r%  r  r  r   r  )r  r  r  z__Pyx_PyUnicode_Decode%sr  r  zPyUnicode_Decode%s)r   r  r  Tr'  decode_c_stringr  r  r)  r*  r  r  r  decode_cpp_decode_bytesdecode_bytearrayz__Pyx_%sr9  r:  r$  )9r^   r  r  r   r   r=   r"  r   r   r  
ValueErrorUnicodeDecodeErrorr(   r   r.  r   r)  r*  r   r)   r   r
   r   r   r   r"   rb  is_cpp_stringr   r   rA  r	   r  r   r  r  r0  !PyUnicode_DecodeXyz_func_ptr_typer  r   r   r  rH   r+  r  _decode_c_string_func_typer   _decode_cpp_string_func_typer  r   r  r@  _decode_bytes_func_typer   r   r!   r  )rF   r*   r   r   rc  r  r  r  r  r  r  r=   r)  r*  rn  string_typer  codec_cnamedecode_functionr   helper_func_typer  ry  s                          r#   "_handle_simple_method_bytes_decodez7OptimizeBuiltinCalls._handle_simple_method_bytes_decode!  s    SYY####!####''dEJJJK 1g99$(DII
KGQD-1D**,, 
		"-"="D"DX~"^"^ #O'88 + ;    #J0BC    k9#;<< 	$J$/K$*JO4E E1Q66k9#?@@ 	*%/K!&7-w/EFFF  ,);;V!);+; < < > > *;;@0!)
 < , , & 	{/H 	K 	V%dhc1MMMEE" 	VOOJ$@$BRBRBTBTUUE 	T	( 	T>>*">@P@P@R@RSSD 
66x@@J!>>>8:;M;McSU;V;VV2Z?'8tE[Z Z ZO%.tx88MM'0::O   )	7 	"* ."+"6{"C"CKLL--- 3O%94;Z%   
  $> 1& 	7 S (9I9B9QS S S084>4H("/+tLL"/9UW[\\"/
8TVZ[["/
J<\^bcc"/*:Z\`aa"/t?egkll+5 51  $@ @k.> @ @  S (9I9B9QS S S#;g000$2!!$6!+Hj#446FudM;NP_`L$01BOTT	
 
 
 $$B$K 	> 	>D1$==DDs   :B> >CCc                     	 t          j        |          }n# t          $ r Y d S w xY w| j        D ]E\  }}||k    r:d|v r2d                    d |                    d          D                       }|c S Fd S )Nr"  r  c                 6    g | ]}|                                 S rP   )r  )rc   r   s     r#   rf   zAOptimizeBuiltinCalls._find_special_codec_name.<locals>.<listcomp>  s0     $> $> $>() %&LLNN $> $> $>r%   )r   r  LookupError_special_codecsrs  r  )rF   r  requested_codecr"   codecs        r#   r  z-OptimizeBuiltinCalls._find_special_codec_name  s    	$/99OO 	 	 	44	/ 	 	KD%''$;;77 $> $>-1ZZ__$> $> $> ? ?D	 (
 ts    
%%c                 .   t          j        |          }t          |          dk    r#|                     |d                   \  }}|d S nd }|}t          |          dk    r+|                     |d                   \  }}|d S |dk    r|}nd}|}||||fS )Nr   r   r   r  )r   r  r^   _unpack_string_and_cstring_node)rF   r   r   r  r  r  r  r  s           r#   r  z4OptimizeBuiltinCalls._unpack_encoding_and_error_mode  s    &s++	t99>>&*&J&J4PQ7&S&S#Hm$t % H%Mt99>>262V2VW[\]W^2_2_/N/"*t))&/#%N"+-9LMMr%   c                 v   t          |t          j                  r|j        }t          |t          j                  r@|j        }t          j        |j        |                                t          j
                  }nt          |t          j                  rF|j                            d          }t          j        |j        |j        t          j
                  }n[|j        t          j        u r5d }|                    t          j
        |                                           }n|j        j        rd }nd x}}||fS )Nr  z
ISO-8859-1)r(   r   r   r)   r   rp   r?  r   as_utf8_stringr	   r@  r"  r   r
   r   rA  r   rb  )rF   r*   r  s      r#   r;  z4OptimizeBuiltinCalls._unpack_string_and_cstring_node  s#   dI899 	8DdI122 	#zH& 7 7 9 9
@`b b bDDi122 
	#z((66H&
1QS S SDDY',,,H>>*"BDDTDTDVDVWWDDY  	#HH""Ht~r%   c           
      D    |                      ||||ddt          d          S )Nr3  r  r   r  bytes_tailmatch_utility_coder  s        r#   $_handle_simple_method_bytes_endswithz9OptimizeBuiltinCalls._handle_simple_method_bytes_endswith  s-    %%(D"3Wj(". . 	.r%   c           
      D    |                      ||||ddt          d          S )Nr3  r  r$  r?  r  s        r#   &_handle_simple_method_bytes_startswithz;OptimizeBuiltinCalls._handle_simple_method_bytes_startswith  s-    %%(D"3Wl(". . 	.r%   rP   c           
          t          |          }|r#|r!|                     |d         |||          |d<   |	|j        }	t          j        |j        ||||	||
|j                  S )Nr   )r   r   r<  r  r;  )r  r  r   r   r+  r   r;  )rF   r*   r   r"   r  rb  rc  r   r<  r   r  r  s               r#   r8  z,OptimizeBuiltinCalls._substitute_method_call  s    
 Dzz 	[t 	[))$q'8=NPYZZDG?lG+HdI'-!0   	r%   c                     |j         r|S |r$|                    d||j        j        g          }nA|                    d                    t          |          dk    rdnd          d|g          }|S )	Nr!  r#  r  r  r  r  r  r  )r=  r   r   r"   r  r^   )rF   self_argr   rc  rb  s        r#   r  z#OptimizeBuiltinCalls._wrap_self_arg	  s     	O 	)11R&(:; 2 = =HH  11;BBCPYNN^`L`L`55fhii,&K 2 ) )H r%   c           	         t          |          |k    rd S ||         }|j        rt          j        |j                  nHt          j        |j        d| j        |                    |                                           gd          ||<   d S )N__Pyx_NoneAsNullr   r'  )	r^   r  r   r  r   r+  obj_to_obj_func_typer_  r   )rF   r   r   r)   s       r#   r  z*OptimizeBuiltinCalls._inject_null_for_none  s    t99F5k58[ 
i(111iFbG'%&&t'7'7'9'9::;	G
 G
 G
Ur%   c                    t          |          |k    sJ t          |          |k    s||         j        r?|                    t          j        |j        t          |          ||                     d S ||                             ||                                           }t          |t          j
                  rt          |          |_        |||<   d S )NrU  )r^   r  rH   r   r   r   rC  rA  r   r(   r)  special_none_cvalue)rF   r*   r   	arg_indexr   default_valuer)   s          r#   r  z1OptimizeBuiltinCalls._inject_int_default_argument'  s     4yyI%%%%t99	!!T)_%<!KK	)$(#m:L:L/3]T T T U U U U U y/++D$2B2B2D2DEEC#y=>> =*-m*<*<'!DOOOr%   c                 6   t          |          |k    sJ t          |          |k    r@t          |          }|                    t          j        |j        ||                     d S ||                             |                                           ||<   d S Nr  )r^   r  rH   r   r   r   r   r   )rF   r*   r   rL  rM  s        r#   r  z2OptimizeBuiltinCalls._inject_bint_default_argument5  s    4yyI%%%%t99	!! //MKK	*48=;HJ J J K K K K K #9o??@P@P@R@RSSDOOOr%   r'   r  )rW   rX   rY   rZ   r  r  rN   r!  r	   r  r  r  r*  r,  r2  r;  r
   r   r  rE  r=  r1  c_float_typer  c_longdouble_typerL  r0  re  rT  rU  rI  r  rZ  rf  r^  r   rr  rs  _handle_simple_function_strrx  r   r{  r   r   r  r  r   r  r  r   r  r  r   r  r  r  r  r  r  r  r  r  memoryview_typer  r  r  r  r@  r  c_const_py_unicode_ptr_typer  r  r   r  r  r  r  rh  r  r  rN  r  r  r  r  r  r  r  r	  r  r  r  r  r  r  r*  r.  r"  r!  r9  r:  rB  rC  rI  rK  rQ  r#  rR  rT  r  r  rb  rg  rk  ro  rt  rw  rz  r}  r  r  r  r  r  r  !_handle_simple_method_int___add__!_handle_simple_method_int___sub__!_handle_simple_method_int___mul__ _handle_simple_method_int___eq__ _handle_simple_method_int___ne__!_handle_simple_method_int___and__ _handle_simple_method_int___or__!_handle_simple_method_int___xor__$_handle_simple_method_int___rshift__$_handle_simple_method_int___lshift__!_handle_simple_method_int___mod__&_handle_simple_method_int___floordiv__%_handle_simple_method_int___truediv__r  r  r  r  r  r  r  r  ra  r  r  %_handle_simple_method_unicode_isalnum%_handle_simple_method_unicode_isalpha'_handle_simple_method_unicode_isdecimal%_handle_simple_method_unicode_isdigit%_handle_simple_method_unicode_islower'_handle_simple_method_unicode_isnumeric%_handle_simple_method_unicode_isspace%_handle_simple_method_unicode_istitle%_handle_simple_method_unicode_isupper)_handle_simple_method_unicode_isprintable$PyUnicode_uchar_conversion_func_typer  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  _special_encodingsr7  r  r  r+  r,  r.  r-  r3  &_handle_simple_method_bytearray_decoder  r  r;  rA  rC  r   r+  r  r8  r  rI  r  r  r  rP   r%   r#   r  r  "  s{             	 	 	   
 
 
  4z3!#J#C)BDII$   
  .& & &P $8:#7#J#GW-?FF#J#GZ-I4PP#J#NJ4I4PP!
 '$  $  $    2 
 &2J4LjNjk  3 3 3j 0:/#J#E:+DdKK 
 	   3j2 #J#E:+DdKK#
 	  
3 
3 
3> > > >$  (B (B (BX5 5 5  "6!5#J#E:+DdKK" "
  . #B
 
 
 1J0#J#FG,=tDD 
   !5
 4	 	 z'@$	G	GH!J !J
 
 
"  4z3#J#FG,=tDD   
U U U$ /*.#J#D**CTJJ
 
     < !5
 4#J#D**CTJJ!
! !
! ! !  #7*"6 #J#E:+DdKK# )#  #  # 4 4 4l 2Z1#J#C)BDII 
 #7*"6#J#GZ-EtLL# #
  .B B B$ )=
(<#J#GZ-FMM") )%
 )=
(<#J#GW-CTJJ") )%
  4 "6!5$#J#GZ-MtTT'
 	" " " ';j&:$#J#Iz/UW[\\'
 	' ' '# 3j2$#J#E:+DdKK'
 	   	!=!9!=!8!9!7!7	! 
  443 3 3j .-#J#Hj.GNN 
	C 	C 	C 3j2#J#E:+DdKK! 
B B BH  , 0:/!#J#Fj.GNN#J#Fg.@$GG$  #7*"6!#J#Fj.GNN#J#Fg.@$GG#J#Hg.?FF$
# # ;?G G G GT ;?    !5
 4$#J#FJ,EtLL#J#FJ,EtLL' ! ! !
 
 
 = = =~ $8:#7$#J#K1JDQQ#J#GZ-BDII' $ $ $  *>)=$#J#K1JDQQ#J#GZ-FMM' * * *&  B 2Z1!#J#FJ,EtLL$ 
 #7*"6!#J#FJ,EtLL#J#J
0I4PP#J#Iz/KTRR#J#K1FMM	$
 # # #C C CB B B BH 2Z1$#J#E:+DdKK' 	  T T T $8:#7!#J#FJ,EtLL#J#E:+DdKK#J#Iz/H$OO$$ $ C C C  ';j&:!#J#FJ,EtLL#J#E:+DdKK#J#Iz/H$OO#J#NJ4I4PP	$' '#< < <4 0:/!#J#FJ,EtLL#J#E:+DdKK#J#Iz/H$OO$  #7*"6#J#FJ,EtLL#J#E:+DdKK#J#Iz/H$OO 
 '1A# # #< < <4
 
 !,j.FG
 
 
X X X] ] ]] ] ]W W WW W WX X XW W WX X X[ [ [[ [ [\ \ \^ ^ ^] ] ]Y Y Y )M%(L%(L%'J$'J$(L%'J$(L%+R(+R((L%-V*,T)[ [ [X X X] ] ]_ _ _[ [ [^ ^ ^W W WW W W# # #N +?**>#J#GZ-FMM!+ +'
  0 /H).G).G+.G).G).G+.G).G).G)0I-+?:+?!#J#GZ-FMM$, ,(0 &:Z%9#J#E7+?FF#J#J
0FMM& &"3 3 3 !5
 4#J#E7+?FF#J#E:+DdKK#J#J
0LdSS!
 !
. . .&  4z3#J#E7+?FF#J#E:+DdKK   - - -@ $8:#7#J#E:+DdKK#J#K1JDQQ#J#GZ-I4PP#J#E:+GNN#J#K1FMM! $ $ $ 0 0 0
0 0 0
L L L6  4z3$#J#E7+?FF#J#K1JDQQ#J#GZ-I4PP#J#E:+GNN#J#K1FMM'      A A AB B BB B B( !5
 4$#J#E7+?FF#J#K1JDQQ#J#GZ-I4PP#J#E:+GNN	' ! ! !B B B" #7*"6#J#E7+?FF#J#K1JDQQ#J#Iz/H$OO#J#J
0LdSS	# #0 0 0 +?**>#J#E7+?FF#J#J
0PRVWW#J#Hj.NPTUU+ +' ';j&:#J#E7+?FF' '#
B B B9 9$69 9 9O/? /? /?b )<
(;<PJ<P#J#Hj.NPTUU#J#FJ,H$OO#J#Hj.NPTUU
= = ) )% "6!5#J#Hj.NPTUU#J#GZ-I4PP#J#FJ,H$OO#J#J
0PRVWW#J#Hj.NPTUU#J#M3TVZ[[
" " 3j2#J#Hj.GNN#J#GZ-I4PP#J#FJ,H$OO#J#J
0PRVWW#J#Hj.NPTUU#J#M3TVZ[[
  $( A A AF .P*  N N N.  (. . .
. . .

 DF-14090L0\04	   &   0:/!#J#E:+DdKK$
 
	
 	
 	
" " "T T T T Tr%   r  c           	         t           j        t           j        f}t          ||          r-|j        t
          j        ur|j        t          j        urdS |}d}n?t          ||          r-|j        t
          j        ur|j        t          j        urdS |}d}ndS |	                                sdS t          |t           j                  }|rt
          j
        nt
          j        }	|r| dvrdS n"| dk    rdS t          |j                  dk    rdS | dv r|j        dk    rdS g }
|
                     |rt           j        nt           j        |j        |j        |j        |		                     t          |t           j                  r|j        nd
}|
                    t          j        |j        ||                     |s| dvrY|dk    o#t          |t           j                  r|j         nd
}|
                    t          j        |j        ||                     t-          j        |rdn| dv rdnddt1          | ||                    }d|rdndd|j        rdnd| |}|||
|	fS )zQ
    Optimise math operators for (likely) float or small integer operations.
    NObjCCObj)r_  rf  r  r  r  rn  rs  r  r   )r  r  r  r  r   r   Fr  r  PyFloatBinopPyLongComparePyLongBinopr    )oporderr\  r  r  FloatLongr"  r  Bool)r   r   r  r(   r   r	   r  r
   r  r   r  r  r\  r=   rH   r   rp   NumBinopNoderY  r   r  	cdivisionr   r!   r   r   )rl   r*   r\  arg0arg1	num_nodesnumval	arg_orderr.  r  r  rY  zerodivision_checkr<  r  s                  r#   r  r  ?  s    "I$78I$	"" 9J555$)7K[:[:[4			D)	$	$ 9J555$)7K[:[:[4		t%%'' t &)"566H+3Oz''9OH ___4 `	X		t	V#	$	$u	,	,tGGG1$$4JMhMy**I<M
&,8N      )y/EFFQdllEGi(RYZZZ[[[ v8<//&&0 R",T93D"E"EP5 	),TX=Oastttuuu%1"f8|;S;SYf	HEEEG G GLL '''"..		J |Z99r%   unicode_tailmatchr9  bytes_tailmatchc                   F    e Zd ZdZd) fd	Zd Zej        ej        ej	        ej
        gZd Zd Zd Zd Zd	d
dddj        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdZd Zd Zd Zd Z d Z!d Z"d Z#d  Z$d! Z%d" Z&d# Z'd$ Z(d% Z)d& Z*d' Z+d( Z,e-j.        j/        Z0 xZ1S )*ConstantFoldingaF  Calculate the result of constant expressions to store it in
    ``expr_node.constant_result``, and replace trivial cases by their
    constant result.

    General rules:

    - We calculate float constants to make them available to the
      compiler, but we do not aggregate them into a single literal
      node to prevent any loss of precision.

    - We recursively calculate constants from non-literal nodes to
      make them available to the compiler, but we only aggregate
      literal nodes at each step.  Non-literal nodes are never merged
      into a single node.
    Fc                 V    t                                                       || _        dS )z
        The reevaluate argument specifies whether constant values that were
        previously computed should be recomputed.
        N)superrC   
reevaluate)rF   r  	__class__s     r#   rC   zConstantFolding.__init__  s&    
 	$r%   c                 6   | j         s|j        t          j        urd S t          j        }||_        |                     |          }|                                D ]K}t          |          t          u r|D ]}t          |d|          |u r  d S 5t          |d|          |u r d S L	 |
                                 d S # t          t          t          t          t          t           f$ r Y d S t"          $ r' dd l}dd l}|                    |j                   Y d S w xY w)Nr=   r   )file)r  r=   r   constant_value_not_setr   rI   r   r   r  r  calculate_constant_resultr(  	TypeErrorrg   
IndexErrorr  ArithmeticError	Exception	tracebacksys	print_excstdout)rF   r*   r   childrenchild_resultchildr  r  s           r#   _calculate_constz ConstantFolding._calculate_const  sq    	$I,LLLF #1- %%d++$OO-- 	 	LL!!T)))  Eu&7HHNZZ [ '8.II^[[ \
	1**,,,,, Ix^_] 	 	 	DD 	1 	1 	1!!!!!!!!SZ000000	1s   &B< <)D(,DDc           
          	 | j         t          t          | j         j        t          t          |                                       S # t
          $ r Y d S w xY wr'   )NODE_TYPE_ORDERmaxr  r   r   r(  )rF   nodess     r#   _widest_node_classz"ConstantFolding._widest_node_class  s`    	'C,2Ce4D4DEEFFH H 	 	 	44	s   AA 
AAc                 X    t          |          }t          j        |j        ||          S rO  )r  r   r   r   )rF   r*   rp   s      r#   
_bool_nodezConstantFolding._bool_node  s'    U!$(%OOOOr%   c                 0    |                      |           |S r'   )r  rJ   s     r#   visit_ExprNodezConstantFolding.visit_ExprNode  s    d###r%   c                 r   |                      |           |                                s"|j        dk    r|                     |          S |S |j        j        s|S |j        dk    r|                     ||j                  S t          |j        t          j
                  rXt          j        |j        t          t          |j                            t          j        t          |j                            S |j        dk    r|                     |          S |j        dk    r|                     |          S |S )N!rU  rW  r  )r  r   rl   _handle_NotNoder   r=  r  r=   r(   r   r   r   r   rC  r[  r	   rE  _handle_UnaryPlusNode_handle_UnaryMinusNoderJ   s     r#   visit_UnopNodezConstantFolding.visit_UnopNode  s1   d###'')) 	}##++D111K|& 	K=C??4)=>>>i&899 	5$TXST=Q9R9R5S5S*4*?589M5N5NP P P P ]c!!--d333]c!!..t444r%   r   rA  is_notis)rA  r   r  r  c                     |j         }t          |t          j                  rL|                     |j                  }|r0t          j        |          }||_        |                     |          }|S r'   )r   r(   r   r   _negate_operatorrl   r   r   )rF   r*   r   rl   s       r#   r  zConstantFolding._handle_NotNode  sj    ,gy788 	7,,W-=>>H 7y)) (0066r%   c                    d }|j         j        }t          |j         t          j                  r5t          j        |j         ||j         j                  ||j                  S |j        r|j	        s&t          |j         t          j
                  rG|j        r@t          j
        |j         ||j         j                  ||j         j        |j                  S |S )Nc                 P    |                      d          r| dd          } nd| z   } | S )Nr  r   )r  ro   s    r#   _negatez7ConstantFolding._handle_UnaryMinusNode.<locals>._negate  s5    $$ $abb	eLr%   rU  )rp   r   longnessr=   )r   r   r(   r   r  r   rp   r=   r   r/  r   r   r  )rF   r*   r  	node_types       r#   r  z&ConstantFolding._handle_UnaryMinusNode  s    	 	 	 L%	dlI$788 	M&txwwt|?Q7R7R,57;7KM M M M  	K	 0 	K4<):;;	K@I@U	K$TXWWT\=O5P5P*3.2l.C595IK K K K r%   c                 p    |j                                         r|j        |j         j        k    r|j         S |S r'   )r   r   r=   rJ   s     r#   r  z%ConstantFolding._handle_UnaryPlusNode  s8    L,,.. 	 (DL,HHH<r%   c                     |                      |           |j                                        s|S |j        j        r|j        dk    r|j        S |j        S |j        dk    r|j        S |j        S )Nr  )r  rm   r   r=   rl   rn   rJ   s     r#   r.  z#ConstantFolding.visit_BoolBinopNode  sx    d###}0022 	K=( 		%}%%}$}$}%%}$}$r%   c                    |                      |           |j        t          j        u r|S t	          |j        t
                    r|S |j        |j        }}|j        r|j        s|S 	 |j	        |j	        }}|||S n# t          $ r |cY S w xY w|j        r|j        rt          j        ||          }nt          j        }|                     ||          }||S |t          j        u r|j        dv rt          j        }n#|t          j        u r|j        dv rt          j        }|t          j        u rt)          |dd          ot)          |dd          }dd t+          t-          t)          |dd                    t-          t)          |dd                                       }	t/          t1          |j                            }
t3          j        |
          }
t          j        |j        ||	|
t1          |j                            }|j        s|j	        j        rt          j        |_	        nct          j        ||j	                  |_	        nC|t          j        u r|j        }nt;          |j                  } ||j        |||j                  }|S )	Nz+-//<<%**>>z+-//<<%**>>&|^unsignedr  LLr  )r   r  r  rp   r=   )r   r   rp   r=   )r  r=   r   r   r(   r  rm   rn   r=  r   r  rJ  r	   widest_numeric_typer  r  r   rl   r   r  r  r  r^   hexr[  r   strip_py2_long_suffixr   r   rC  )rF   r*   rm   rn   type1type2widest_typetarget_classr  r  rp   r   
node_values                r#   visit_BinopNodezConstantFolding.visit_BinopNode#  s   d###9#;;;Kd*E22 	K!]DM(" 	(*= 	K	#=(-5E} !. 	 	 	KKK	  	4 0 	4$8FFKK$3K..xBBKY///DM]4R4R$,LLY///DMEU4U4U$,L9,,,xR88 9xR88  ISWXz2%F%F!G!G!$WXz2%F%F!G!GI I I JHD01122E/66E (TX2:X/49<T=Q9R9RT T TH & [(-*C [ * 9 * >{HM Z Zy111!1

 !566
#|,66:6JL L LH s   &A; ;B
	B
c                 x   |                      |           t          |j        t                    r2t	          j        |j        j        t          |j                            S |j        |j	        }}t          |t          j
                  rt          |t          j
                  rE|j                            |j                   t          j        |_        |                     |          S t          |j        t                    r|j        s|S t          |t          j                  s t	          j        |j        |j                  }|j                            |           t          j        |_        |                     |          S nt          |t          j
                  rt          |j        t                    r|j        s|S t          |t          j                  s t	          j        |j        |j                  }|j                            d|           t          j        |_        |                     |          S |j        t          j        u r|S |j        rK|j        rCt          |t          j                  rt          |t          j                  rd }|j        H|j        A|j        j        |j        j        k    r't+          |j        |j        z   |j        j                  }t          |j                  }t	          j        |j        ||          S t          |t          j                  rtt          |t          j                  rZ|j        j        |j        j        k    r@t+          |j        |j        j                  }t	          j        |j        ||j                  S |                     |          S )Nro   r   r   r  )r  r(   r=   rC  r   r   rm   r   r   rn   JoinedStrNoder   r   r  simplify_JoinedStrNoderH   r  r   r  rM  r  r   r?  rp   r  )rF   r*   rm   rn   rM  string_values         r#   visit_AddNodezConstantFolding.visit_AddNode_  sz   d###d*C00 	N(!t7K)L)LN N N N "]DM( h	 788 	=(I$;<< =&&x777+4+K(228<<<(2C88 =/ $#O!(I,ABB F(4 H,D F  F  FH&&x000+4+K(228<<<= )"9:: 		=(2C88 =/ $#O!(I,ABB F(4 H,D F  F  FH&&q(333+4+K(228<<<9#;;;K% 	v(*D 	v(I$9:: vz(T]Ti?j?j v"'38L8X+48L8UUU&3$083GG$09'; ';  -T-ABB ,X\[fggggHi&9:: vz(T]Tg?h?h v>*hn.EEE"/0DhnF]"^"^K$.x|;`d`tuuuu##D)))r%   c                    |                      |           |j        j        r!|                     ||j        |j                  S t          |j        t          j                  r-|j        j        r!|                     ||j        |j                  S |j        j        r!| 	                    ||j        |j                  S |j        j        r!| 	                    ||j        |j                  S | 
                    |          S r'   )r  rm   rr  _calculate_constant_seqrn   r(   r   r   r  _multiply_stringr  rJ   s     r#   visit_MulNodezConstantFolding.visit_MulNode  s    d###=0 	T//dmT]SSSdmY%677 	T5	T//dmT]SSS=* 	M((t}dmLLL], 	M((t}dmLLL##D)))r%   c                 L   |j         }t          |t                    s|S |                                rt          |j         t                    s|S t          |j                   dk    r|S t          |t          j                  rt          }njt          |t          j	                  r6t          }|j        't          |j        |z  |j        j                  |_        nJ dt          |          z               ||j        |z  |j        j                  |_        |j        |_         |S )N   Fzunknown string node type: %s)r=   r(   r[  r   _py_string_typesr^   r   r?  r   r   r   rM  r  r   rp   )rF   r*   r  multiplier_node
multiplierbuild_strings         r#   r  z ConstantFolding._multiply_string  s,   $4
*c** 	K((** 	z$:NP`/a/a 	Kt#$$s**Kk9#677 		M(LLY%:;; 	M)L&2*7+j8+4+6 +6' M84;L;LLLLL(L
*&( ( '2&7#r%   c                    |j         dk    r|j        rt          |j         t                    r|j         dk    r|j        d d = d |_        n|j        t          |j         t                    rgt          |j        j         t                    rH|j        j         |j         z  }t          j        |j        j        t          |          |          |_        n| 	                    |          S ||_        |S r  )
r=   r   r(   r[  r  r   r   r   rC  r  )rF   r*   sequence_nodefactorrp   s        r#   r  z'ConstantFolding._calculate_constant_seq  s    !Q&&=+=&&0#66 36;QUV;V;V!&qqq),0))*6v5s;; 6"=#<#LcRR6)5EH^^E090A%15!%jj%1A 1A 1AM--
  //555,2)r%   c                 \   |                      |           t          |j        t          j                  rdt          |j        t          j                  rE|j        j        s9|                     |j        j	        |j        j
        |j        j                  }||S |                     |          S r'   )rI   r(   rm   r   r   rn   rJ  r  _build_fstringr   rp   r   r  )rF   r*   fstrings      r#   visit_ModNodezConstantFolding.visit_ModNode  s    4   dmY%:;; 	#
4=ZcZm@n@n 	#=, #--dm.?ATVZVcVhii&"N##D)))r%   z'(%(?:(?:[-0-9]+|[ ])?(?:[.][0-9]+)?)?.)c                    t          |          }g }d}t          j        | j        |          D ]}|s|dk    r7|                    t          j        |t          d                               C|d         dk    rc|d         dk    r t          |d|dd           d	d
           d}|                    t          j        |t          |                               |d         }	 t          |          }	n%# t          $ r t          |dd
           d}Y  nw xY w|	j        rd} n|dv r|d
d          }
d }|dv rd|
v rd}n;|dv r/|
d d         }
|}|
                    d          rd|
d
d          z   }
n|dk    rd}|
                    d          rd|
d
d          z   }
|                    t          j        |	j        |	||
r#t          j        |t          |
                    nd                      d} |sd S 	 t          |           t          |dd
           d S # t          $ r Y nw xY wt          j        ||          }|                     |          S )NTz%%%ro   r   r$  zIncomplete format: '...'r   )levelFz)Too few arguments for format placeholdersasrfdoxXdoxXrq  arsr   r   dr  r   )rp   rw  rv  z*Too many arguments for format placeholders)r   )iterr   r  _parse_string_format_regexrH   r   r   r   r   nextStopIterationrC  r  FormattedValueNoder   r  visit_JoinedStrNode)rF   r   r  r  r   
substringscan_be_optimisedr   format_typer)   rv  rw  r*   s                r#   r  zConstantFolding._build_fstring  s   K  
$97CC 1	 1	A Dyy!!)"7=QTCUCU"V"V"VWWWts{{R5C<<C!D1RSS6!D!D!DANNNN',$!!)"7=QRCSCS"T"T"TUUUB%K4jj    HPQRRRR#(  ~ #( j((e"&&((SK-?-?',$$ E))"-crc"2K&1O"--c22 <&)KO&; C''&)O))#.. 8"%ABB"7K!!)">G3$3&!1	 5c{A[A[ \ \ \ \,0	# # #     $)  	4	JJJ CEQOOOO4 """dd"
 &s:>>>''---s$   )C99DD H# #
H0/H0c                    |                      |           |j        pd}|j        |j        j        r|j        j        sd |_        |j        ~|j                                        ret          |j        j        t                    rFt          t          |j        j                            }t          j        |j        j        |          S |j        |dk    r|j        j        r|j        S |S )Nr   ro   )rI   rw  rv  r  rp   r   r(   r=   r[  r   rC  r   r   r   )rF   r*   rw  rp   s       r#   rx  z(ConstantFolding.visit_FormattedValueNode'  s    4   .5#'D,<,N'W[WgWm'#D#
(F(F(H(H#ZX\XbXrtwMxMx#!#dj&@"A"ABBE(uEEEE#3(>(>z+ "z!r%   c                 V    |                      |           |                     |          S r'   )rI   r  rJ   s     r#   r  z#ConstantFolding.visit_JoinedStrNode4  s*    4   **4000r%   c                    g }t          j        |j        t          d                    D ]\  }}|rt	          |          }|d         }t          |          dk    rGt          d                    d |D                                 }t          j	        |j
        |          }|j        r|                    |           |                    |           |s)t          j	        |j
        t          d                    }nOt          |          dk    r	|d         }n3t          |          dk    rt          j        |j
        d	g|R  }n||_        |S )
z
        Clean up after the parser by discarding empty Unicode strings and merging
        substring sequences.  Empty or single-value join lists are not uncommon
        because f-string format specs are always parsed into JoinedStrNodes.
        r  )r;  r   r   r  c              3   $   K   | ]}|j         V  d S r'   ro   )rc   rp   s     r#   	<genexpr>z9ConstantFolding.simplify_JoinedStrNode.<locals>.<genexpr>D  s$      1V1V%%+1V1V1V1V1V1Vr%   ro   r   rW  )r   groupbyr   r   r  r^   r   rs  r   r   r   rp   rH   r   r  )rF   r*   r   is_unode_groupr  unoderp   s          r#   r  z&ConstantFolding.simplify_JoinedStrNode8  sX    *3*;DKZXkMlMl*m*m*m 	* 	*&NJ 
*!*--
"1z??Q&&)"''1V1V:1V1V1V*V*VWWE%1%)5IIIE; )MM%(((j)))) 	!(r9J9JKKKDD[[A!9DD[[A'#????DD DKr%   c                 d   |                      |           g g fd|j        D ]} ||           r                               t                    dk    r+d         }|j        st          |t          j                  r|S |j        dd<   |                     |           |S )z!Unpack **args in place if we can.c                    |j         rVr=d         j        |j        k    r'd         j                            |j                   d S                     |           d S t          |t          j                  r(| j        |j        k    r|j        D ]} ||           d S r                               d d =                     |           d S )Nr$  )	is_dict_literalreject_duplicatesr  r   rH   r(   r   MergedDictNoder  )parentr)   	child_argr  r   r   s      r#   r  z1ConstantFolding.visit_MergedDictNode.<locals>.add]  s    " ! &U2Y8C<QQQ"I-44S5HIIIIILL%%%%%C!9:: !v?W[^[p?p?p!$!1 ( (ICY''''( (  !KK&&&aaaC     r%   r   r   N)	rI   r  r   r^   r  r(   r   r  r  )rF   r*   r)   r  r   r   s      @@@r#   visit_MergedDictNodez$ConstantFolding.visit_MergedDictNodeW  s    4   	! 	! 	! 	! 	! 	! 	! $ 	 	CCcNNNN 	KKt99>>q'C" ji6N&O&O 
#!!!d###r%   c                    |                      |           |j        t          j        u g g fd|j        D ]} |           r                    d                    t                    dk    rBd         }r|j        s/|j        r|j        |j        u st          |t          j                  r|S |j        dd<   |                     |           |S ) Unpack *args in place if we can.c                    r| j         s| j        rG| j        s@r'd         j                            | j                   d S                     |            d S t          | t          j                  r| j        D ]} |           d S r                     d                    d d =                     |            d S )Nr   )	is_set_literalrr  r  r   r   rH   r(   r   MergedSequenceNode)r)   r  r  r   r  r   s     r#   r  z5ConstantFolding.visit_MergedSequenceNode.<locals>.add  s     !3- !33N !WZWf ! '1IN))#(33333MM#&&&&&C!=>> !!$ # #IC	NNNN# #  "KKq	***qqq	C     r%   r   r   N)rI   r   r
   r   r   rH   r^   r  rr  r(   r   r  r  )rF   r*   r)   r  r   r  r   s      @@@@r#   visit_MergedSequenceNodez(ConstantFolding.visit_MergedSequenceNodey  s"   4   g..	! 	! 	! 	! 	! 	! 	! 	! 9 	 	CCHHHH 	#KKq	"""t99>>q'C C. 058X5J5JsI$@AA 6K
	!!!d###r%   c                 ^   |                      |           g }|j        D ]l}|j        s|                    |           |j        j        r,|j        j        s |                    |j        j                   W|                    |           m||j        dd<   |                     |           |S )r  N)	rI   r   rC  rH   r|   rr  r  r   r  )rF   r*   r   r)   s       r#   visit_SequenceNodez"ConstantFolding.visit_SequenceNode  s    4   9 	! 	!C> !C    3 !CJ<R !CJO,,,,C    	!!!d###r%   c                    |                      |dg           |j        }|}||                      |dg           |j        }t          |_        |                                r_|                                rK	 |                    |j                   n/# t          t          t          t          t          t          f$ r Y nw xY w|}|j        }||j        s1|                                r|                     ||j                  S |S |j        gg}g }|}||                                rM|j        s*|                    |                     |d                     n@|                    |j        g           n|d                             |           |j        }|g }|D ]}t!          |          dk     r|d         }t#          j        |j        |d         |j        |j        t                    }	|                    |	           |	}
|dd          D ]}||
_        |}
d |
_        |r|                    |d                    n|s|                     |d	          S |d         }t!          |          dk    r0|                                r|                     ||j                  S n0|dd          D ]%}t#          j        |j        |d
|t                    }&|S )Nrm   rn   Fr$  r   r   r   )rm   rl   rn   r=   Tr  )rI   rm   rn   r   r=   r   "calculate_cascaded_constant_resultr(  r  rg   r  r  r  r  r  rH   r^   r   r   r   rl   r  )rF   r*   	left_noder   
right_nodecascadesfinal_false_result	cmp_nodesr  	pcmp_nodelast_cmp_nodes              r#   r   z$ConstantFolding.visit_PrimaryCmpNode  sL   4*...M	"x*666!*J'5H$,,.. :3Q3Q3S3S ??	@YZZZZ"Ix^Ude   D"I'H " | 	'')) CtT-ABBBK ]O$"++-- 
./ 9&--dooh.N.NOOO OOX%6$78888 ##H---'H " 	 	) 	)G7||aqzH!0 !*!* .0 0 0I Y'''%M#ABBK ) )(0% ($(M!! 	//23333 	/??4...|y>>Q'')) CtT-ABBBC &abbM 4 4 .H!"%$24 4 4 s   6B )B=<B=c                     |                      |           |j                                        s|S |j        j        r|j        S |j        S r'   )r  r  r   r=   r'  r(  rJ   s     r#   r*  z"ConstantFolding.visit_CondExprNode  sN    d###y,,.. 	K9$ 	"= >!r%   c                 8   |                      |           g }|j        D ]H}|j        }|                                r|j        r|j        |_         n3|                    |           I|r	||_        |S |j        r|j        S t          j	        |j
        g           S Nrt   )rI   ry   rw   r   r=   rx   rz   rH   r   r   r   )rF   r*   ry   r!  rw   s        r#   r$  z ConstantFolding.visit_IfStatNode  s    4   
 
	- 
	-I!+I,,.. -, '0~D$E !!),,,, 	:(DOK 	:##%dhb9999r%   c                    |                      |           |j        |j        j        
d x}|_        n|j        j        }|j        |j        j        
d x}|_        n|j        j        }|j        t          urL|j        }|j        r|j        |j        ||         |_        |S |j	        r|
                    ||          }||S |S r'   )r  r)  r=   r*  r   r   rr  r  r   r  as_sliced_node)rF   r*   r)  r*  r   s        r#   visit_SliceIndexNodez$ConstantFolding.visit_SliceIndexNode  s    d###:!;!C!%%EDJJJ.E9	 9 A##D4999,D~559D+  0@0H IeDj1	'  **5$77#Kr%   c                    |                      |           t          |j        t          j                  r|j        j        s|j        t          j        u rt          j
        |j        g g           S |j        t          j        u r(t          j        |j        g t                                S |j        t          j        u rt          j        |j        g i           S |S )Nr  r  )rI   r(   r  r   r   ru   r   r
   r   r   rK  r   r   rL  r  r   r  rJ   s     r#   visit_ComprehensionNodez'ConstantFolding.visit_ComprehensionNode5  s    4   di!344 
	FTY_ 
	FyG--- )H2r; ; ; ;g... (H2suu> > > >g/// )Hb"F F F Fr%   c                 L   |                      |           |j        j        }t          |t          j                  rh|j        s)|j        r|j        S t          j	        |j
        g           S t          |t          j                  r|                                |j        _        |S r  )rI   r}   r{   r(   r   SequenceNoder   rz   r   r   r   rK  r  )rF   r*   r{   s      r#   r   z#ConstantFolding.visit_ForInStatNodeD  s    4   =)h	 677 		== B# B++ !-dhbAAAA(I$677 =)1):):)<)<&r%   c                     |                      |           |j        r;|j                                        r"|j        j        rd |_        d |_        n|j        S |S r'   )rI   rw   r   r=   rz   rJ   s     r#   visit_WhileStatNodez#ConstantFolding.visit_WhileStatNodeS  sb    4   > 	(dn@@BB 	(~- (!%#'  ''r%   c                     |                      |           t          |j        t          j                  s|S |j                                        rd S |S r'   )rI   r(   rM   r   ExprNoder   rJ   s     r#   rN   z"ConstantFolding.visit_ExprStatNode]  sR    4   $)Y%788 	K9((** 	4r%   c                     |                      |           |j        |S |j                                        r|j        j        rd |_        n|j        S |S r'   )rI   rw   r   r=   rx   rJ   s     r#   visit_GILStatNodez!ConstantFolding.visit_GILStatNodeg  sb    4   >!K>--// 
	! ~- !!% y  r%   r  )2rW   rX   rY   rZ   rC   r  r   r   r  r   r  r  r  r  r  r  r  r  r  r  r  r.  r  r  r  r  r  r  r  r  rx  r  r  r  r  r  r   r*  r$  r  r  r   r  rN   r  r   r<  r=  r[   __classcell__)r  s   @r#   r  r    st         % % % % % %1 1 1@ !)9+= ()*=?O  P P P    * 	 
 
     ,  % % %: : :x5* 5* 5*n* * *  6  &* * *	 D. D. D.L  1 1 1  >     D$ $ $L  N N N`" " ": : :.  .          6 )=JJJJJr%   r  c                   j    e Zd ZdZdZd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd ZddZdej        fdZdS )FinalOptimizePhasea  
    This visitor handles several commuting optimizations, and is run
    just before the C code generation phase.

    The optimizations currently implemented in this class are:
        - eliminate None assignment and refcounting for first assignment.
        - isinstance -> typecheck for cdef types
        - eliminate checks for None and/or types that became redundant after tree changes
        - eliminate useless string formatting steps
        - inject branch hints for unlikely if-cases that only raise exceptions
        - replace Python function calls that look like method calls by a faster PyMethodCallNode
        - replace duplicate FormattedValueNodes in f-strings with CloneNodes
    Fc                 Z    |                      |           |j        r|j        }d|_        |S )zaAvoid redundant initialisation of local variables before their
        first assignment.
        T)rI   r2  rr   lhs_of_first_assignment)rF   r*   rr   s      r#   visit_SingleAssignmentNodez-FinalOptimizePhase.visit_SingleAssignmentNode  s6     	4   : 	/(C*.C'r%   c                 f   |j         }|j        }|j        s|j        r|j        nd }|                                 }|j        p|j        p|j        o|j	        j        }|
                                oC|j        o<|t          j        uo.|o|j         o$| j                            | j        s|rdnd          S )Nz&optimize.unpack_method_calls_in_pyinitzoptimize.unpack_method_calls)r   r   r   r   r   r   is_module_scopeis_c_class_scopeis_py_class_scopeouter_scoper  r   r
   rh  r   r  r  in_loop)rF   r*   r   function_typer   r  in_global_scopes          r#   _check_optimize_method_callsz/FinalOptimizePhase._check_optimize_method_calls  s    = "*"2Uh6KUQU   H H"Fs'F 	 !! 5%5!225 +5+,5 #''|4(748835 5		
r%   c                    |                      |           |j        }|j        j        r|j        r|j        dk    rt          |j                  dk    r|j        d         }|j        j        r|j        j        dk    r| j	        j
        }|                    d          |_        |j        j        |_        t          j        |                    d          j                  }t          j        |j        d         |          |j        d<   nt          j                            |j        d          rt          j                            |          r|j        rJ|j        rCt/          |j        t          j                  r$|j        j        |j        u r|j        j        |_        |                     |t          j                            |||j        |j        |                     |          	                    }|S )
z
        Replace generic calls to isinstance(x, type) by a more efficient type check.
        Replace likely Python method calls by a specialised PyMethodCallNode.
        r(   r   r   r   PyObject_TypeCheckr  F)
has_kwargs)r   r   r   unpack)rI   r   r   is_cfunctionr   r"   r^   r   rG  r   r  r   r   r	   r  r   rc  PyMethodCallNodecan_be_used_for_posargsr   can_be_used_for_functionrF   r   r(   r8   ra  r)   r  	from_noder'  )rF   r*   r   r  r  r  s         r#   r  z'FinalOptimizePhase.visit_SimpleCallNode  s   
 	4   ==% 	I(*: 	I},,TY11D1D9Q<=0 UX]5G65Q5Q#'<#<L%1%8%89M%N%NHN$,N$7HM&0&9,:M:Mn:]:]:b&c&cO#,#5dilO#T#TDIaL )AA$.]bAcc 	I-FFxPP I	 8h&; 8&x|Y5HII8NVlN^bfbkNkNk'/|'7<<i.H.R.Rx4>PTPY#@@FF /S /H /H I ID r%   c                    |                      |           t          |j                  }t          |j        t          j                  }t          j                            |j        ||          s|S |j	        }t          j        
                    |          s|S |                     |t          j                            |||j        |j        |j        |                     |                              }|S )zW
        Replace likely Python method calls by a specialised PyMethodCallNode.
        )r*  has_explicit_kwargs)r   r   kwdictr   r+  )rI   r  r  r(   r   r  r-  r.  r  r   r/  r  r0  r   r'  )rF   r*   r*  r2  r   s        r#   r  z(FinalOptimizePhase.visit_GeneralCallNode  s     	4   $+,,
():I<NOO)AA$Qd B f f 	K=)BB8LL 	K||D)"<"F"F8t/CDL]4#D#DT#J#J #G #L #L M M r%   c                 0    |                      |           |S r'   )rI   rJ   s     r#   visit_NumPyMethodCallNodez,FinalOptimizePhase.visit_NumPyMethodCallNode  s    4   r%   c                 ~    |                      |           |j        s |j                                        sd|_        |S )zRemove tests for alternatively allowed None values from
        type tests when we know that the argument cannot be None
        anyway.
        T)rI   notnoner)   rq  rJ   s     r#   r  z'FinalOptimizePhase.visit_PyTypeTestNode  sD    
 	4   | 	$8'')) $#r%   c                 p    |                      |           |j                                        s|j        S |S )z_Remove None checks from expressions that definitely do not
        carry a None value.
        )rI   r)   rq  rJ   s     r#   visit_NoneCheckNodez&FinalOptimizePhase.visit_NoneCheckNode  s:     	4   x##%% 	8Or%   c                 Z    | j         }d| _         |                     |           || _         |S )zeRemember when we enter a loop as some expensive optimisations might still be worth it there.
        T)r$  rI   )rF   r*   old_vals      r#   visit_LoopNodez!FinalOptimizePhase.visit_LoopNode  s2     ,4   r%   c                     |                      |           d}t          |j                  D ])\  }}|                     ||j                   |j        s|}*|j        r|r|                     ||j        d           |S )zQAssign 'unlikely' branch hints to if-clauses that only raise exceptions.
        NT)inverse)rI   r   ry   _set_ifclause_branch_hintrx   branch_hintrz   )rF   r*   last_non_unlikely_clauser  r!  s        r#   r$  z#FinalOptimizePhase.visit_IfStatNode  s     	4   #' %do66 	5 	5LAy**9inEEE( 5+4( 	e 8 	e**+CTEU_c*dddr%   c                 :   |j         sdS t          j        t          j        t          j        t          j        t          j        t          j        f}|g}t          |d          D ]\  }}t          |t          j
                  r|                    ||j                   ;t          |t          j                  r|j        |||<   bt          ||          sG|t          |          k    r1t          |t          j        t          j        f          r|rdnd|_         dS dS )z\Inject a branch hint if the if-clause unconditionally leads to a 'raise' statement.
        Nr   likelyunlikely)is_terminatorr   r  AssignmentNodeAssertStatNodeDelStatNode
GlobalNodeNonlocalNoder   r(   GILStatNoder  rx   r   ru   r^   RaiseStatNodeReraiseStatNoder@  )rF   clausestatements_noder>  non_branch_nodes
statementsnext_node_posr*   s           r#   r?  z,FinalOptimizePhase._set_ifclause_branch_hint  s)    , 	F   
 &&
#,Z#;#; 	 	M4$ 122 !!-;;;$ 233 :>*
=67d$455  C
OO33
4%J]_d_tIu8v8v35<)L*F&		 	r%   r*   c                 *   t           j        }t           j        }i }|j        dd         }t	          |j                  D ]\  }}t          ||          s|j        }t          |j        |          r|j        }n|j        n|j	        j
        rnP|j        r|                                sl|j        |j        |j        |j        pdf}	|                    |	|          }
|
|u rt          j        |
          }|j        |_        |||<   ||j        dd<   |S )a  
        Deduplicate repeatedly formatted (C) values by replacing them with CloneNodes.
        It's not uncommon for a formatting expression to appear multiple times in an f-string.

        Note that this is somewhat handwavy since it's potentially possible even for simple
        expressions to change their value while processing an f-string, e.g. by modifying the
        world in a ".__format__" method.  However, this seems unlikely enough to appear in
        real-world code that we ignore the case here.
        Nr   )r   r  r   r   r   r(   rp   r)   ru  r   rG  r   r  r"   rv  rw  rG  ra  r   )rF   r*   r  r   r  r   r  fnodefnode_value_noder;  
seen_fnodededup_fnodes               r#   r  z&FinalOptimizePhase.visit_JoinedStrNode1  sH    '9&9QQQ!$+.. "	$ "	$HAue%788 ${%+'9:: #3#7  $0!&6   $, 1A1K1K1M1M 
 #(%*=u?PRWRgRnknoCe44JU""#-j99K#iKO#F1IIAAAr%   Nr  )rW   rX   rY   rZ   r$  r  r'  r  r  r5  r  r9  r<  r$  r?  r   r  r  rP   r%   r#   r  r    s          G  
 
 
*  <  &  
	 	 	         84	(? 4 4 4 4 4 4r%   r  c                   "    e Zd ZdZdZd Zd ZdS )ConsolidateOverflowChecka5  
    This class facilitates the sharing of overflow checking among all nodes
    of a nested arithmetic expression.  For example, given the expression
    a*b + c, where a, b, and x are all possibly overflowing ints, the entire
    sequence will be evaluated and the overflow bit checked only at the end.
    Nc                     | j         +| j         }d | _         |                     |           || _         n|                     |           |S r'   )overflow_bit_noderI   )rF   r*   saveds      r#   r[   z#ConsolidateOverflowCheck.visit_Nodeq  sS    !-*E%)D"t$$$%*D""t$$$r%   c                     |j         rL|j        rE| j        d u }|r|| _        n| j        |_        d|_         |                     |           |rd | _        n|                     |           |S r3   )overflow_checkoverflow_foldr[  rI   )rF   r*   top_level_overflows      r#   visit_NumBinopNodez+ConsolidateOverflowCheck.visit_NumBinopNode{  s     	%4#5 	%!%!74!?! ,)-&&)-)?&&+#t$$$! .)-&t$$$r%   )rW   rX   rY   rZ   r[  r[   ra  rP   r%   r#   rY  rY  h  sD                r%   rY  )Dcythondeclarer  r   r   r   r   rl   r   r  r   r   r   r   r3  rC  r  r   r	   r   r
   r   r   Coder   r   StringEncodingr   r   r   Errorsr   r   ParseTreeTransformsr   r   	functoolsr   r$   r   r)  r,   r1   r7   r>   rB   r@   r`   r]   EnvTransformri   r  r<  r?  rR  r|  NodeRefCleanupMixinr  MethodDispatcherTransformr  r  r!   r  r@  r  r  CythonTransformrY  rP   r%   r#   <module>rm     s    6v^dv&&vvfSY[ [ [ [ 
			                   2 2 2 2 2 2 2 23<                                            1 1 1 1 1 1 1 1 H H H H H H H H H H " " " " " " " " 1 1 1 1 1 1            7 7 7 /8.JILj-k              '-   @    v v v v v- v v vrC> C> C> C> C>g* C> C> C>LF> F> F> F> F>W57G F> F> F>Rq& q& q& q& q&w7 q& q& q&hG G G G Gw3 G G GT    4g6J   DZ T Z T Z T Z T Z T76"<Z T Z T Z Tz@B: B: B:J "9!89Lo!^!^ 6{67H/ZZ z> z> z> z> z>g.0@ z> z> z>z` ` ` ` `-w/J ` ` `F         w6          r%   