
    Ng+u                    F   d dl mZ d dlZd dlZd dlZd dlZd dlZddlmZ ddl	m
Z
 d dlZ ej        eeeeeeeeee
  
         ej        d          dk    reZeefZneef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* n# e+$ r	 d dl,m*Z* Y nw xY w	 d dl)m-Z- n# e+$ r eZ-Y nw xY wd Z.e	j/        e	j0        ffdZ1d Z2d Z3d Z4 G d dej5                  Z6d Z7d Z8 G d  d!ej9                  Z: G d" d#ej9                  Z; G d$ d%ej<        e'          Z= G d& d'ej<                  Z> G d( d)ej9                  Z? G d* d+ej@        ej9                  ZA G d, d-ej@        ejB                  ZCd. ZD ejE        d/d0          ZF ejE        d1d0          ZG ejE        d2d0          ZH G d3 d4ej<        e'          ZI G d5 d6ej9        ej@                  ZJ G d7 d8ejK                  ZLdS )9    )absolute_importN   )	TypeSlots)not_a_constant)
UtilityCodeEncodedStringbytes_literalencoded_stringNodes	ExprNodes
PyrexTypesBuiltin	UtilNodes_py_int_types   )r   )r   )r   )Visitor)r   )r   )Options)r   TempitaUtilityCode)r   r	   r
   )errorwarning)SkipDeclarations   )Utils)reduce)
basestringc                 ,    t          j        | d          S )N
Optimize.c)r   load_cached)names    T/var/www/html/ai-engine/env/lib/python3.11/site-packages/Cython/Compiler/Optimize.pyload_c_utilityr!   0   s    "4666    c                 4    t          | |          r| j        S | S N)
isinstancearg)nodecoercion_nodess     r    unwrap_coerced_noder)   4   s     $'' xKr"   c                 |    t          | t          j                  r!| j        } t          | t          j                  !| S r$   )r%   r   ResultRefNode
expressionr'   s    r    unwrap_noder.   :   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)
r.   r%   r   NameNoder   AttributeNode
is_py_attris_common_valueobj	attribute)abs     r    r4   r4   @   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_resultr-   s    r    filter_none_noder;   J   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    r@   z_YieldNodeCollector.__init__T   s/    $$T*** "r"   c                 d    | j                             |           |                     |           d S r$   )rB   appendvisitchildrenrC   r'   s     r    visit_YieldExprNodez'_YieldNodeCollector.visit_YieldExprNode[   s3    %%%4     r"   c                 n    |                      |           |j        | j        v r|| j        |j        <   d S d S r$   )rF   exprrB   rA   rG   s     r    visit_ExprStatNodez&_YieldNodeCollector.visit_ExprStatNode_   sC    4   9(((/3D!$),,, )(r"   c                     d S r$    rG   s     r    visit_GeneratorExpressionNodez1_YieldNodeCollector.visit_GeneratorExpressionNodef       r"   c                     d S r$   rM   rG   s     r    visit_LambdaNodez$_YieldNodeCollector.visit_LambdaNodei   rO   r"   c                     d S r$   rM   rG   s     r    visit_FuncDefNodez%_YieldNodeCollector.visit_FuncDefNodel   rO   r"   N)__name__
__module____qualname____doc__r@   r   r?   rF   
visit_NoderH   rK   rN   rQ   rS   rM   r"   r    r=   r=   P   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]   p   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 rM   )r&   rA   ).0
yield_node	collectors     r    
<listcomp>z*_find_yield_statements.<locals>.<listcomp>{   s8     
 
 
 ^Y7
CD
 
 
r"   )r=   rF   rB   KeyError)r'   r\   rb   s     @r    rZ   rZ   w   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          Z e	j
        e	j         e	j        dej        d	          g          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iteratorru   rw   tempsru   not_inoperand)is_ptr_containsposr   r+   rk   is_subscriptbasetype	base_type
TempHandlerefr   PrimaryCmpNoderj   r   StatListNodeSingleAssignmentNodeBoolNodeBreakStatNode
IfStatNodeIfClauseNodeTempsBlockNodeForInStatNodeIteratorNodeanalyse_expressionscurrent_envvisitTempResultFromStatNoderi   NotNoderF   )rC   r'   r   
result_refr   target_handlery   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 /edmfN N N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$   )rF   _optimise_for_looprz   rx   rG   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   r   itemsdictiterkeysr   
itervaluesr   	iteritemsr   	enumerater   )rangexrange      @)6is_nameis_attributeentry
annotationrJ   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[   rC   functionr5   r6   global_scopecontextlanguage_levelCallNoder   
is_builtin_transform_enumerate_iteration_transform_reversed_iterationr   convert_rangery   is_intis_enum_transform_range_iterationis_pyobjectIntNodehas_constant_resultr:   )rC   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_noderz   rx   r   r   )rC   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   rm   r:   r   c                      t          j        j        dt          j                            d                    } t          j        j        | g          S )Nr[   )r   r   r   r   )r   r1   r   r   builtin_scopelookupr   )builtin_lenr'   unpack_temp_nodes    r    make_length_callzKIterationTransform._transform_indexable_iteration.<locals>.make_length_callL  s_    #,TXE3:3H3O3OPU3V3VX X XK+DH-8*:);& & & &r"   )r   r   >>=<=<r   r   )r   indexr   ro   rp   )boundscheck
wraparound)
directivesru   rq   rn   N	bound1	relation1ry   	relation2bound2stepru   rw   
from_rangerJ   r   )r   
LetRefNoder   r   r   r   r   c_py_ssize_t_type	IndexNoder   r   ry   r   r   copy_inherited_directivesr   CompilerDirectivesNoder   rr   rE   ForFromStatNoderw   LetNodeExprStatNoder   r   insertru   )rC   r'   
slice_noder   r   
start_noder   length_tempend_noder  r  counter_reftarget_valuetarget_assignenvnew_directivesru   loop_length_reassign	loop_noderetr   s    `                  @r    r   z1IterationTransform._transform_indexable_iterationC  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"   sNc                    |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   PyBytes_AS_STRINGr   r   r   PyBytes_GET_SIZEr   )r   startr  stopr   r   r   )ry   r   r   r   r   r   r  r   r   PythonCapiCallNoder   PyBytes_AS_STRING_func_typePyBytes_GET_SIZE_func_typer  r   SliceIndexNode)rC   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.+$%	    ,,(N* #*/   $ - % %& & 	&r"   kinddatar   length-1exception_valuec                 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   rq   Tr   __Pyx_init_unicode_iterationr   r   unicode_iterr   )r   r   result_is_usedutility_coder  r{   )0
is_literalr	   rm   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_typery   r   r   r   r   ru   r  rw   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   )rC   r'   r  r   bytes_valuebytes_slicer   r  r  r  r  r  	kind_temp	data_tempcounter_tempr  r  ru   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   rm   r:   rm   r   r:   r-  r   r   +rj   ri   rk   r   r4  1r   )r!  r"  r   r   r   )r   r   r   r   rq   Tr   r{   )6r%   r   r&  r   r;   r!  r"  r   r   r   r   r   r   	SliceNoder  r:   r   r   r   r  r>  absr   sizer<  r   element_ptr_typecoerce_to_simpleAddNode	CloneNoder   r   r   ry   	is_stringr   r   CastNodeDereferenceNoder   c_py_ucs4_typer@  r   r   assignable_fromr	  r   r   r   ru   _find_for_from_node_relationsr  rw   r   )rC   r'   r  r   neg_step
slice_baser!  r"  r  r   
step_valueptr_type
carray_ptrstart_ptr_nodestop_ptr_nodecounterrL  r  r  ru   r  r  for_nodes                          r    r   z.IterationTransform._transform_carray_iteration5  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FF 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   rP  rT  rR  )rj   rk   ri   r   r   r   rq   )r   r   r[   r   r   ry   is_sequence_constructorr   r   r   r)   r<  r   r   r   r   r  rZ  r   r   r%   ru   r   rr   rE   itemrz   rx   r  r   )rC   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   rM   )rC   neg_step_valuer   s      r    ra  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   rT  rm   r:   r   r   r   r   TF)	ry   r   r  r  r  r  ru   rw   r  )r   r   r[   r   r   r   r%   r:   r   r>  coerce_to_integerr   ra  rV  r   spanning_typer   r   r  _build_range_step_calculationrm   r8  r   r  ry   ru   rw   set_up_loopr  )rC   r'   range_functionr   r   step_posrd  r  r   r  r  r  bound2_ref_nodeabs_stepbegin_value	end_valuebound1_valuebound2_is_temprj  s                      r    r   z-IterationTransform._transform_range_iteration.  s   ',t99q==%)HJ$XS!LLLDD7DxHd2MBB -JQ$XS__5?A A AD t99>>&~'978: : :F!W..t/?/?/A/ABBFF!W..t/?/?/A/ABBF!W..t/?/?/A/ABBF#AA*q.RZ[[	9 	C#VFF:H1}}v5}EE C"6#9=II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&6&6&8&899  	#!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   -rR  r   *rS  rT  r   ry  z//)rV  r   r{  r   r   r@  r   
binop_noder   MulNoder   r>  DivNodeSubNode)rC   r   r  r  rd  r  r{  spanning_step_typer  r  final_opstep_calculation_nodes               r    r|  z0IterationTransform._build_range_step_calculation  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                 x   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|          }|                    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   rr   r4  r   T)is_identifierrm   *'NoneType' object has no attribute '%{0}s'   .30 PyExc_AttributeErrorr   format_argsr   c                 b    | rdpd} t          j        j        t          |           |           S Nr   r   ry  r   r   r   r>  rm   r'   s    r    	flag_nodez?IterationTransform._transform_dict_iteration.<locals>.flag_node  2    Ka$1E$TXSZZQVWWWWr"   r   ry  rn   __Pyx_dict_iterator	dict_iterr   r7  r   r   rt   ru   rw   rq   r{   )(r   r   r   py_object_typerE   r   r   r  ry   rl  r[   r   r%   ru   r   r   r   rD  
c_ptr_typer   r@  DictIterationNextNoder   r   rr   
StringNoder   formatNullNoder   r   r#  PyDict_Iterator_func_typer   r   r   r   WhileStatNoderw   r   )rC   r'   r   r   r   r   r|   rs  	dict_temppos_temp
key_targetvalue_targettuple_targetru   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  sX   #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#.D@ @ @K11<CCSQW[[\^M^M^EEdfgg.%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  r4  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_nodeW  r  r"   r   ry  rn   __Pyx_set_iteratorset_iterr   Tr  r  rq   r{   )!r   r   r   r  rE   r   r   r  r%   ru   r   r   r   rD  r  r   r@  ry   SetIterationNextNoder   r   rr   r   r   r#  PySet_Iterator_func_typer   r   r   r   r  rw   r   )rC   r'   set_objr|   rs  set_tempr  ru   set_len_tempset_len_temp_addris_set_tempis_set_temp_addrr  r  r  r  s    `              r    r   z+IterationTransform._transform_set_iteration5  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)&rT   rU   rV   rW   r   r   r   r   r   r   	CFuncTypec_char_ptr_typeCFuncTypeArgr   r   r$  r  r%  r   r_  r@  rA  rB  r  rE  rF  rG  rC  r   r   r   ra  r   r|  r   r  r  r   rM   r"   r    rf   rf      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'" "
$& $& $& $&L  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>% >% >%@a a aF !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"   rf   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}   rh   F!=r   orand)r%   r   CoerceToTempNodeCoerceToBooleanNoder&   BoolBinopResultNoder   EvalWithTempExprNodesubexpressionTypecastNoder   r   cascadeNO_MATCHis_c_string_containsrk   UnicodeNoder:  ri   contains_surrogatesrj   extract_in_string_conditionsis_python_comparisonr4   r8  getattrr   is_constBoolBinopNodeextract_conditions)
rC   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 ry  r  r`   charvalstring_literals     r    rc   z@SwitchTransform.extract_in_string_conditions.<locals>.<listcomp>  sN     / / /  &~'9W7>@ @ @ / / /r"   c                 *    h | ]}||d z            S )r   rM   )r`   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    rc   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  rm   sortr   r[   )rC   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 rM   )r   r   r   )r`   r  s     r    rc   z=SwitchTransform.extract_common_conditions.<locals>.<listcomp>  s*    TTTdi&;$)*;<TTTr"   )r  r  r4   r   r   r   any)rC   
common_varrt   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)rC   condition_valuesseenrm   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  ru   c                 &    g | ]}|j         D ]}|S rM   )r  )r`   caser  s      r    rc   z4SwitchTransform.visit_IfStatNode.<locals>.<listcomp>	  sD     @ @ @t@ @'+D@ @ @ @r"   r   rw   ru   r   testcasesrw   )current_directivesgetrF   rv   r  rt   rE   r   SwitchCaseNoder   ru   r[   r  r.   SwitchStatNoderw   )
rC   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  rF   r  r  r[   r  build_simple_switch_statementtrue_val	false_valrC   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   ry  F)r  r  rF   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  rF   r  r[   r  r"  r   r   r   r%  s        r    r   z$SwitchTransform.visit_PrimaryCmpNodeB  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ro   rp   firstr  r  )r   r+   r   r   r   r<  r   r   r  r.   r  r   )rC   r'   r  r  r}   r#  r$  r   	true_body
false_bodyr  r  replacements                r    r"  z-SwitchTransform.build_simple_switch_statementT  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  rF   r  	lazy_tempr   tree_contains)rC   r'   	orig_exprtemp_refs       r    visit_EvalWithTempExprNodez*SwitchTransform.visit_EvalWithTempExprNodeq  s    &**+@AA 	t$$$K &	>4   Y..();XFF *))r"   N)rT   rU   rV   rW   r  r  r  r  r  r   r&  r*  r   r"  r7  r   VisitorTransformrecurse_to_childrenrX   rM   r"   r    r  r  }  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	        }t          |          dk    rS t          d |D                       rS t          j        j                  }g }g }|D ]}	 |                                }n# t           $ r d	}Y nw xY w|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  rh   r}   r  r  r   c                     g | ]	}|j         
S rM   )
is_starredr`   r&   s     r    rc   z?FlattenInListTransform.visit_PrimaryCmpNode.<locals>.<listcomp>  s    ///3///r"   F)r   rj   ri   rk   r  )r   r   r   c                 >    t          j        j        | |          S )N)r   ri   rj   rk   )r   r  r   )leftrightconjunctionr'   s     r    concatz;FlattenInListTransform.visit_PrimaryCmpNode.<locals>.concat  s+    *&*h+6+/+0	2 2 2 2r"   rQ  )rF   r  ri   r%   rk   r   	TupleNodeListNodeSetNoder   r[   r  r   r+   rj   	is_simple	Exceptionr  rE   r   r   r  r   c_bint_typer   r  )rC   r'   	eq_or_neqr   ro   condsr|   r&   is_simple_argr  rE  rt   r   rs  rD  s    `            @r    r   z+FlattenInListTransform.visit_PrimaryCmpNode  sB   4   <#K]d""KII]h&&KIIK$-)*=*3*<*3*;*= > > 	 K}!t99>>K//$///00 	K%dm44 	@ 	@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s   C..C=<C=N)	rT   rU   rV   rW   r   r   r8  r9  rX   rM   r"   r    r;  r;    s8         
A A AF )=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 rM   rM   r`   pathns      r    rc   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    777at777r"   c                     g | ]\  }}|S rM   rM   rS  s      r    rc   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    888at888r"   c                     g | ]	}|j         
S rM   r&   )r`   ts     r    rc   zIDropRefcountingTransform.visit_ParallelAssignmentNode.<locals>.<listcomp>  s    ***qQU***r"   F)rr   r%   r   r   _extract_operandro   rp   CascadedAssignmentNoder  r[   _extract_index_idrE   use_managed_ref)rC   r'   
left_namesright_namesleft_indicesright_indicesr|   statlnamesrnameslindiceslhs_nodeindex_idrindicesrhs_node	temp_argsrs  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.rQ  T)r.   r   r   r%   r   r  rE   r&   r   r3   memberr5   r   r   joinr   r   r   r   r   r   )rC   r'   namesindicesr|   	name_pathobj_nodes          r    rZ  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   r1   r   	ConstNode)rC   rl  r   r   	index_vals        r    r\  z*DropRefcountingTransform._extract_index_id6  s[     eY/00 	
IIy233 	44	9%%r"   N)rT   rU   rV   rW   r   r8  r9  rX   rm  rZ  r\  rM   r"   r    rP  rP    sZ         )=JC C CJ  :
& 
& 
& 
& 
&r"   rP  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$   )rF   r   _function_is_builtin_name_dispatch_to_handlerr   )rC   r'   r   s      r    visit_SimpleCallNodez-EarlyReplaceBuiltinCalls.visit_SimpleCallNodeR  sR    4   =--h77 	K((xCCCr"   c                     |                      |           |j        }|                     |          s|S |j        }t	          |t
          j                  s|S |j        }|                     ||||j	                  S r$   )
rF   r   r|  positional_argsr%   r   rF  r   r}  keyword_args)rC   r'   r   r   r   s        r    visit_GeneralCallNodez.EarlyReplaceBuiltinCalls.visit_GeneralCallNodeY  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)rC   r   r  r   s       r    r|  z2EarlyReplaceBuiltinCalls._function_is_builtin_namee  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  )rC   r'   r   r   kwargshandler_namehandle_calls          r    r}  z-EarlyReplaceBuiltinCalls._dispatch_to_handlero  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r7  )r   PythonCapiFunctionNoder   r   r   )rC   r'   r
  	func_typer7  s        r    _inject_capi_functionz.EarlyReplaceBuiltinCalls._inject_capi_function|  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%   r   r   r   r[   rC   function_namer'   r   expectedarg_strexpected_strs          r    _error_wrong_arg_countz/EarlyReplaceBuiltinCalls._error_wrong_arg_count       	GG*-- 	A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.0rl   r   floatr   r   )
r   	FloatNoder   r[   r  r  r   c_double_typer   
float_type)rC   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   rU  r   NoneNode)rC   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           	         t          |          dk    r|S |d         }t          |t          j        t          j        f          rqt          |j                  dk    rXt          j        |j        t          j	        t          t          |j                            t          |j                            S nt          |t          j                  r|j        rt          |j                  dk    rpt          |j                  dk    rXt          j        |j        t          j        t          t          |j                            t          |j                            S |S )zUnpack ord('X').
        r   r   rO     )r[   r%   r   r  r:  rm   r   r   r   c_long_typer>  r  r  unicode_valuer@  )rC   r'   r  r&   s       r    _handle_simple_function_ordz4EarlyReplaceBuiltinCalls._handle_simple_function_ord  s6    x==AKqkcI193FGHH 	39~~"" (G*"8c#)nn--$'	NN    # Y122 	  S):%;%;q%@%@C-..#55 (G*"7c#"34455$'(9$:$:   
 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rC   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~   ry  rl   rs   )rw   rv   r  all)gen	orig_func)r[   r%   r   GeneratorExpressionNodedef_nodegbodyru   r]   r   r   r   r   r   ReturnStatNoder   rw   r   recursively_replace_nodeInlinedGeneratorExpressionNode)rC   r'   r  is_anygen_expr_nodegenerator_bodyr  yield_expressionyield_stat_nodert   	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|}|j        }nt          |t          j                  r|}|j        }t          |          }|s|S t          j
        |j        |dt
          j                  }|D ]<\  }}	t          j        |j        ||j                  }
t          j        ||	|
           =nk|j        r|                                x}}nMt          j        |j        |j        r!|j        t(          j        t
          j        fv rdnd| j        |d	          x}}t/          j        |j        t
          j        d
          }t3          j        |j        ||d          }t          j        |j        |t9          d          d
          }t3          j        |j        t          j        |j        |g                     }|                    |                                             t/          j!        |t3          j"        |j        ||g                    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rJ   ry   __Pyx_PySequence_ListKeepNewPySequence_ListTr  F)r   r   r   r-  r  )r5   r6   needs_none_checkr   r  rq   )#r[   r%   r   ComprehensionNoder   r   r   loopr  rZ   r  r   ComprehensionAppendNodery   r   r  rl  as_listr#  r   r   r  PySequence_List_func_typer   r+   r   r   r2   r   r  r   analyse_declarationsr   r   r   )rC   r'   r  r&   	list_noder  r  r\   r  r  append_noderesult_nodelist_assign_nodesort_method	sort_nodes                  r    _handle_simple_function_sortedz7EarlyReplaceBuiltinCalls._handle_simple_function_sorted  s    x==AKqkc9677 $	-CHHY<Y<YI!IIY>??  	-M%*I5i@@# !@-8#*#46 6 6I 6F ^ ^1 /'?$()$+- - - 0Q\]]]]^ ( 	- %(KKMM1I		
 %.$@{+'*xJ4MwO`3a'a'a /.*.t%- %- %- -I	  -G$5UL L L 5H+9DB B B  -H+v1F1F"$ $ $ &H93;R9 9 9: : :	 	&&t'7'7'9'9:::/tx0@)/LMMMO O 	O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   ry  r   rR  rn   )r   r,   Tr-  rq   sum)r  r  
expr_scoper  has_local_scope)r[   r%   r   r  r  r  r]   rE   rJ   r8  r   r   r  r   r   r   r+   r   r  r   r   r  r   r  r   r  r  r  )rC   r'   r  r  r  r  r  r!  r   add_node	exec_codes              r    __handle_simple_function_sumz5EarlyReplaceBuiltinCalls.__handle_simple_function_sumT  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_min      %%dHc:::r"   c                 0    |                      ||d          S )Nr   r  r  s      r    _handle_simple_function_maxz4EarlyReplaceBuiltinCalls._handle_simple_function_max  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)rj   ri   rk   )r#  r$  r  rQ  )r[   rl  r   r  r  r   r+   r   CondExprNoder   r   r  )	rC   r'   r   ri   cascaded_nodeslast_resultarg_noder   ref_nodes	            r    r  z*EarlyReplaceBuiltinCalls._optimise_min_max  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 )NrM   r   r:   rX  )r   rF  r   _transform_list_set_genexprr   r   AsTupleNode)rC   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[   rl  r   r%   r   rG  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   rG  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   rH  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  rZ   r  r   r   r   r  ry   r   r  )rC   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_exprry   )r[   r   DictNoder   r%   r  r  rZ   rF  r   r  r   r   DictComprehensionAppendNodery   r   r  )rC   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  )rC   r'   r  r  s       r    _handle_general_function_dictz6EarlyReplaceBuiltinCalls._handle_general_function_dict  s9     x==1K&)"455 	Kr"   r$   )'rT   rU   rV   rW   r   r8  r9  rX   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  rM   r"   r    rz  rz  C  s       
 
 )=JD D D
5 
5 
5     ) ) ) )
> > > >$  7 7 7$  2> > > = = = "X "X "XH !5
 4	 	 z'@$	G	GH!J !JBO BO BOH8= 8= 8=t; ; ;; ; ;  F  	 	 	S S S
R R R
  8" " "L    r"   rz  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[   rp   )rC   rk  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)rF   r  r  r   r   r  r%   r   PyCFunctionNodeInlinedDefNodeCallNoder   r   r  can_be_inlinedreplace)rC   r'   r  r   inlineds        r    r~  z'InlineDefNodeCalls.visit_SimpleCallNode7  s    4   &**+JKK 	K$ 	K//>>(I$=>> 	K2HMDI"46 6 6 !!## 	/<<g...r"   N)	rT   rU   rV   r   r8  r9  rX   r  r~  rM   r"   r    r  r  (  s=        )=J
+ 
+ 
+    r"   r  c                      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 e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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          g          Z+d! Z, ej	        ej-         ej        d"ej
        d          g          Z.d# Z/ ej	        ej0         ej        d$ej-        d          g          Z1d% Z2 ej	        ej3         ej        d"ej
        d          g          Z4d& Z5 ej	        ej6         ej        d"ej
        d          g          Z7d' Z8 ej	        ej         ej        dej
        d          gd(d          Z9d) Z: ej	        ej
         ej        dej
        d          g          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          g          Z@ ej	        ej?         ej        d*ejA        d          g          ZBd- ZC ej	        ej         ej        d
ejD        d          gd          ZE ej	        ej         ej        d.ejF        d          gd          ZG ej	        ej         ej        dej
        d          gd          ZHej&        d/ej        d0ejI        d1ej-        d2ej0        d3ej3        d4ej6        d4ej*        d5ijJ        ZKd6hZLd7 ZM ej	        ejN         ej        d8ej
        d          g          ZOd9 ZP ej	        ejQ         ej        dej
        d          g          ZRd: ZSd; ZT ej	        ej
         ej        d<ej
        d           ej        d=ej0        d          g          ZU ej	        ej
         ej        d<ej
        d           ej        d=ej0        d           ej        d>ej*        d          g          ZV	 dd?ZW	 dd@ZX ej	        ejY         ej        d$ej
        d           ej        dAej
        d          gd          ZZdB Z[dC Z\ ej	        ejY         ej        dDej
        d           ej        d*ej        d          gd          Z] ej	        ejY         ej        dDej
        d           ej        d*ej
        d          gd          Z^dE 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        dFej
        d           ej        dGej        d           ej        dHej        d          gdI          ZadJ ZbddLZc ej	        ejY         ej        dej
        d          gd          ZddM Ze ej	        ej
         ej        d ej
        d           ej        dNej
        d           ej        dOej
        d          g          ZfdP Zg ej	        ej
         ej        d ej
        d           ej        dNej
        d           ej        dOej
        d           ej        dQej        d          g          ZhdR Zi ej	        ej
         ej        d ej
        d           ej        dNej
        d           ej        dOej
        d          g          ZjdS Zk edT ejl        ej        fD                       ZmdU ZndV ZodW ZpdX ZqdY ZrdZ Zsd[ Ztd\ Zud] Zvd^ Zwd_ Zxd` Zyda Zzdb Z{dc Z|dd Z}de Z~df Zdg Zdh Zdi Zdj Zdk Z ej	        ejQ         ej        dlej        d          g          Zdm ZeZeZeZeZeZeZeZeZeZ ej	        ej         ej        dlej        d          g          Z	  ej	        ej-         ej        dnej&        d           ej        doejQ        d          g          Zdp Z ej	        ej-         ej        dnej&        d           ej        dqej
        d           ej        drej        d          g          Zds Z ej	        ej&         ej        dnej&        d           ej        dtej
        d          g          Zdu Z ej	        ejQ         ej        dnej
        d           ej        dvej
        d           ej        dwej        d           ej        dxej        d           ej        dyej        d          gd          Zdz Zd{ Zd| Z ej	        ej         ej        dnej&        d           ej        dvej
        d           ej        dwej        d           ej        dxej        d           ej        dyej        d          gd}          Zd~ Zd Zd Z ej	        ej         ej        dnej&        d           ej        dvej
        d           ej        dwej        d           ej        dxej        d          gd          Zd Z ej	        ej&         ej        dnej&        d           ej        dve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jD        d           ej        dejD        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jD        d           ej        dej        d           ej        dejD        d          g                    Z ej	        ej&         ej        dejD        d           ej        dwej        d           ej        dej        d           ej        dejD        d           ej        dejD        d           ej        ded          g          Z ej	        ej&         ej        dej
        d           ej        dwej        d           ej        dej        d           ej        dejD        d           ej        dejD        d           ej        ded          g          ZdZd ZeZd Zd Zd 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.
        )rF   	reanalyserG   s     r    visit_PyTypeTestNodez)OptimizeBuiltinCalls.visit_PyTypeTestNodeU  s(     	4   ~~r"   c                 h    |                      |           |j        |j        j        k    r|j        S |S )z,
        Drop redundant type casts.
        )rF   r   r   rG   s     r    _visit_TypecastNodez(OptimizeBuiltinCalls._visit_TypecastNode[  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)rF   r%   rJ   r   r   r&   is_noner8  r   r   is_localis_arg)rC   r'   rJ   s      r    rK   z'OptimizeBuiltinCalls.visit_ExprStatNodef  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.
        )rF   r&   r%   r   PyTypeTestNoder   r   r   r  r   	bool_typecoerce_to_booleanr   )rC   r'   r&   s      r    visit_CoerceToBooleanNodez.OptimizeBuiltinCalls.visit_CoerceToBooleanNodev  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_floatTypeConversion.c)r   py_namer   r7  r6  )rF   r&   r%   r   CoerceFromPyTypeNoder#  r   r   r[   r   r   r   r  r   r   r
  r   PyNumber_Float_func_typer   r   r   r6  r<  r   )rC   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.
        )rF   r&   r   r   r<  r   r%   r   r!  r8  r   r   is_floatr  r   r   r   r  r`  r   r   is_unicode_charr   _optimise_numeric_cast_callr   r   _optimise_int_indexing)rC   r'   r&   rl  s       r    visit_CoerceFromPyTypeNodez/OptimizeBuiltinCalls.visit_CoerceFromPyTypeNode  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   ry  __Pyx_PyBytes_GetItemIntz&'NoneType' object is not subscriptableTbytes_indexStringTools.cr   r   r7  )r   r   r   r   r   r   r   c_char_typec_uchar_typer   r   r   r>  r#  PyBytes_GetItemInt_func_typer   r<  r  r   r   )rC   coerce_noder&   rl  r  bound_check_boolbound_check_noder'   s           r    r5  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           
   #   n   K   | ]0}|t          j        |t          j        d |d          g          fV  1dS )r&   N)r   r  r  )r`   r  s     r    	<genexpr>zOptimizeBuiltinCalls.<genexpr>  sn       "m "m
 	 
Z)'z4@@  	"m "m "m "m "m "m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   intr4  l__Pyx_truncltrunc)r  r   r,  r   r6  r  )r   r%   r   r#  r   r1   r   is_builtin_typer   rF  r[   r   r&   r   r   r   r   r_  c_py_unicode_type_pyucs4_to_numberr`  r2  r  r   
is_numericmath_h_modifierfloat_float_func_typesr   r6  r<  r   )rC   r'   r&   r   r   r/  truncls          r    r4  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.  z-1.0c                 &   |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)rH  r  rH  __Pyx_int_from_UCS4__Pyx_double_from_UCS4
int_pyucs4float_pyucs4
Builtins.c)r  r   r,  r   r6  r7  )r   r#  r   pyucs4_int_func_typepyucs4_double_func_typer   r6  r   r   r<  r   r   )rC   r'   py_type_namer/  s       r    rN  z&OptimizeBuiltinCalls._pyucs4_to_number0	  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$   rM   )rC   r'   r  r   arg_listr  s         r    _handle_functionz%OptimizeBuiltinCalls._handle_functionN	  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)r5   r6   	is_calledNr   )r   r5   r   r   r   r   r2   r   r   r1   r   analyse_as_type_attribute%_optimise_generic_builtin_method_callr   r   r   rC   analyse_c_function_callanalysedr<  )rC   r'   	type_name	attr_namer   r^  is_unbound_methodr  
type_entryr   r   	call_nodes               r    _handle_methodz#OptimizeBuiltinCalls._handle_methodQ	  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        j        dv 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   )	r[   r   r3   r5   r   rL  r   r   CachedBuiltinMethodCallNode)rC   r'   rg  r   r^  rh  r   s          r    rc  z:OptimizeBuiltinCalls._optimise_generic_builtin_method_call}	  s    
 MM	 		Qx7LQYQdK| 0 	K<!%;;;K4(,	85 5 	5r"   r5   c           	      
   |j         t          j        u r|                     |||          S t	          |          dk    r=t	          |          dk    r(t          j        |j        t                      d          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 )z1Optimize single argument calls to str().
        r   r   r  ry  __Pyx_PyStr_Str	PyStr_Strr=  __Pyx_PyObject_StrPyObject_Strr>  r   r   r7  r,  )r   r   r   _handle_simple_function_unicoder[   r   r  r   r   str_typemay_be_noner   r   r#  PyObject_String_func_typer   rC   r'   r   r  r&   r
  r7  s          r    _handle_simple_function_strz0OptimizeBuiltinCalls._handle_simple_function_str	  s    9,,,77hQQQx==A8}}!! +DHMOO]_````Kqk8w'''??$$ 
%E&2;PPLL(E&2>?SSL+HeT;L%
 
 
 	
r"   c           	         t          |          dk    r=t          |          dk    r(t          j        |j        t	                      d          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   r  ry  __Pyx_PyUnicode_UnicodePyUnicode_Unicoder=  __Pyx_PyObject_UnicodePyObject_Unicodeunicoders  )r[   r   r  r   r   r   r   r   rv  r   r   r#  PyObject_Unicode_func_typer   rx  s          r    rt  z4OptimizeBuiltinCalls._handle_simple_function_unicode	  s     x==A8}}!! ,TX]__^abbbb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)	rF   rm   r   r   r   c_format_specformat_specconversion_charrt  rG   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   rC   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        |j        r(|j        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  s        r    r  z1OptimizeBuiltinCalls._handle_simple_function_list	  s     x==AKqk+H<'$'K'47HAZ\c\m@n4n4n +*&*L
 
 
 	
r"   r  c                    t          |          dk    s|j        s|S |d         }|j        t          j        u r|                                s|S |j        t          j        u r@|                    d          |d<   t          j	        |j
        d| j        ||j                  S t          j        |j
        |t          j                  S )zDReplace tuple([...]) by PyList_AsTuple or PySequence_Tuple.
        r   r   r   PyList_AsTupler  )r&   r   )r[   r   r   r   r   rv  r   r   r   r#  r   PyList_AsTuple_func_typer  r  s        r    _handle_simple_function_tuplez2OptimizeBuiltinCalls._handle_simple_function_tuple
  s     x==AT\Kqk8w)))#//2C2C)J8w(((//35 5HQK /*D,It|5 5 5 5 (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   rQ  	PySet_Newr  r   r   r,  )r[   rl  r   rI  r   r  rE   r   rH  r   r  r  r#  PySet_New_func_typer   )	rC   r'   r   r  r   r|   r&   r  rs  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_newrX  	frozensetrs  )r   r  r   r[   r   r   r   rv  r#  PyFrozenSet_New_func_typer   r   r   rC   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           
      L   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}nj|j        t          j        u rd}d}nR|j        t          j        u rd}d}n:|j        t          j        u rd}d}n"|j        t          j        u r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        ry  r   r  0 or 1r4  r'  __Pyx_PyBytes_AsDoublepybytes_as_double__Pyx_PyByteArray_AsDouble__Pyx_PyUnicode_AsDoublepyunicode_as_double__Pyx_PyString_AsDoublepystring_as_doublePyLong_AsDoubler(  pyobject_as_doubleNrs  ) r[   r   r  r<  r   r  r   r  r%   r   r&   r   r   r  r_  rM  rN  r   r`  rO  r  r   r   r   r   r   ru  	long_typer#  PyObject_AsDouble_func_typer   r!   )rC   r'   r   r  r/  r&   
cfunc_nameutility_code_names           r    r  z2OptimizeBuiltinCalls._handle_simple_function_floatV
  sN    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...2J 4]g///*JJ1+C2J 4+Hj,5l@Q[>*;<<<W[   	r"   rm   c                    t          |          dk    r't          j        |j        ddt          j                  S t          |          dk    r|S |d         }t          |t          j                  rQ|j        j	        j
        r>t          j        |j        d| j        |j        gddt          j        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   __Pyx_PyInt_FromDoubleTrH  PyIntFromDoubler+  )r   r   r,  r7  __Pyx_PyNumber_Intr  )r[   r   r   r   r   r  r%   r   r&   r   r2  r#  PyInt_FromDouble_func_typer   r   r   PyNumber_Int_func_type)rC   r'   r   r  r/  s        r    _handle_simple_function_intz0OptimizeBuiltinCalls._handle_simple_function_int
  s"    x==A$TXS!*4*CE E E E]]aKA;h	 <== 	| )  3H68W",u!,!89JL^!_!_a a a a
 =$ 	<)> 	</.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   Fry  r   boolr  r~   )r[   r   r   r   r<  r   r"  r   r  r#  r   coerce_to_pyobject)rC   r'   r   r  r   s        r    _handle_simple_function_boolz1OptimizeBuiltinCalls._handle_simple_function_bool
  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   
memoryviewrT  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"   r  __Pyx_PyUnicode_GET_LENGTH__Pyx_PyBytes_GET_SIZE__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_strlenr=  r>  memoryviewsliceNT)nogil__Pyx_MemoryView_LenPy_SIZEz&object of type 'NoneType' has no len()rT  r   )#r[   r  r%   r   r   r&   r   r\  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_typerL  r   qualified_name_ext_types_with_pysizer   PyObject_Size_func_typer3  r   c_size_t_typer<  r   )	rC   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_typer]  r   r  r  s       r    _handle_simple_function_typez1OptimizeBuiltinCalls._handle_simple_function_type>  s[     x==AK+Hi!8   !$
(ABBBr"   c           
      6   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 ]S}	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}
|
O|j                            d          }|dk    r|
t          j        u rd	}||v r|                    |           |g}nP|	j        t          j        u rd
}||	g}n6|	j        s)t          j        |	          }	|                    |	           d}||	g}|                    t          j        |	j        || j        |d                     Ut          j        ffd	}t9          ||                              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_Py3Int_CheckPyInt_Check__Pyx_TypeCheckPyObject_IsInstanceTr  c                 z     |j         d| |          }t          j        |_        |                               |S )Nr  )r   r   rK  r   r)  )r7   r8   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"   rQ  )r[   r%   r   rF  r   r   r   	type_typer   rI  r   r+   rE   r   r   r   r   r   rL  scopeis_builtin_scopetype_check_functionint_typer8  r#  r   Py_type_check_func_typer  r   r<  r  )rC   r'   r   r  r&   typesr|   tests
test_nodestest_type_nodebuiltin_typer   r  type_check_argsr  r  rs  r  s    `               @r    "_handle_simple_function_isinstancez7OptimizeBuiltinCalls._handle_simple_function_isinstanceN  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#&*>>><SZScCcCc*7'&%//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           	      Z   t          |          dk    r|S |d         }t          |t          j                  ri|j        j        j        rVt          j        |j        |j        t          j
                                      |j        |                                           S nt          |t          j                  rt          |j                  dk    rt          j        |j        t          j        t#          t%          |j                            t%          |j                                                |j        |                                           S nt          |t          j                  r|j        rt          |j                  dk    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   r4  rO  r  )r[   r%   r   r   r&   r   r3  r  r   r   r  r<  r   r  rm   r   r@  r>  r  r  r  r  s        r    r  z0OptimizeBuiltinCalls._handle_simple_function_ord  s    x==AKqkc9788 	?w|+ ? -GSW:3I  i	4+;+;+=+=>>?? Y233 	?39~~"" (G*"7c#)nn--$'	NN    i	4+;+;+=+=>>	? # Y122 	?  ?S):%;%;q%@%@C-..#55 (G*"7c#"34455$'(9$:$:    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   r7  r   __Pyx_tp_new)%r5   r[   r   r   r   r  ri  r   r   rF  r   analyse_typesr   r  typeobj_cnamer  r   r   ConstructorSlotget_slot_functionr   cython_scoper   CPtrTyper   r  r  r  r]  r  r#  r   r   r   Pyx_tp_new_kwargs_func_typer   Pyx_tp_new_func_type)rC   r'   r   r   rh  r  r5   type_arg
args_tupleext_typetp_slotslot_func_cnamer  PyTypeObjectPtrpyx_tp_new_kwargs_func_typer7  s                   r    _handle_any_slot__new__z,OptimizeBuiltinCalls._handle_any_slot__new__  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$   rM   )rC   r'   r   r   rh  r  s         r    _handle_any_slot__class__z.OptimizeBuiltinCalls._handle_any_slot__class__	  s	    
 r"   rm  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_AppendFrE   )r   r  r   r6  r7  )
r[   r6  r   r   r   r#  r   PyObject_Append_func_typer   r!   rC   r'   r   r   rh  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  extendrQ  __Pyx_PyList_Append
ListAppendr>  |__Pyx_ListComp_AppendListCompAppend)r   r,  r   r7  r  )r[   rl  r  r   mult_factorr%   r   rG  r  r  r   r   r  _wrap_self_argr6  rI  r   r  rE   r#  r   r  r!   r  r   c_returncode_typer  )rC   r'   r   r   rh  r5   rm   r   
tuple_nodewrapped_obj
cloned_objr|   r&   r   rs  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   ByteArrayAppendr=  __Pyx_PyByteArray_AppendObjectByteArrayAppendObjectr   Fr   r  r   r7  )r[   PyByteArray_Append_func_typer)   r   r   r%   r   r   r<  r   r@  r   r   r   is_string_literalcan_coerce_to_char_literalr?  r   "PyByteArray_AppendObject_func_typer#  r   r   r6  )
rC   r'   r   r   rh  	func_namer  rm   r7  r   s
             r    &_handle_simple_method_bytearray_appendz;OptimizeBuiltinCalls._handle_simple_method_bytearray_appendv  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_pop  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   r<  r   r  r   rY  r[  numeric_type_fitscreate_to_py_utility_codeto_py_functionr  r  r  PyObject_PopIndex_func_typer>  signedr@  RawCNameExprNodec_void_typeempty_declaration_code)rC   r'   r   r   rh  r4  r5   rf  r   r/  orig_index_typeconvert_funcconversion_types                r    r5  z5OptimizeBuiltinCalls._handle_simple_method_object_pop  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_typer<  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  r7  )	r[   rE   r   r  r   r  rL  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.setdefaultrR  r   z%str bytes unicode float int long boolrQ  r   ry  __Pyx_PyDict_SetDefault
setdefaultTdict_setdefaultrU  )r[   rE   r   r  r   r  r   rL  rH  r   r   r  r   r>  rL  Pyx_PyDict_SetDefault_func_typer!   )rC   r'   r   r   rh  key_typerX  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                 <   t          |          dk    r-|                    t          j        |j                             n-t          |          dk    r|                     d||d           |S |                     ||d| j        d||dt          d          		  	        S )
z7Replace dict.pop() by a call to _PyDict_Pop().
        r   r   zdict.poprR  __Pyx_PyDict_Popr:  Tpy_dict_poprU  )	r[   rE   r   r  r   r  rL  PyDict_Pop_func_typer!   r  s        r    _handle_simple_method_dict_popz3OptimizeBuiltinCalls._handle_simple_method_dict_pop<  s     t99>>KK	*48445555YY!^^''
D$IIIK++( 9$d '66 , 8 8 	8r"   c              #     K   | ]}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                  fV  dS )op1Nop2cvalinplacezerodiv_checkr.  )r   r  rK  r  r  r   r/  )r`   ctyperet_types      r    rF  zOptimizeBuiltinCalls.<genexpr>L  s       #
 #
 #2J4JK#
 #
  	J0'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__Y      ''tXtEVWWWr"   c                 4    |                      d||||          S NSubtractrp  r  s        r    $_handle_simple_method_object___sub__z9OptimizeBuiltinCalls._handle_simple_method_object___sub__\      ''
D(DJ[\\\r"   c                 4    |                      d||||          S )NMultiplyrp  r  s        r    $_handle_simple_method_object___mul__z9OptimizeBuiltinCalls._handle_simple_method_object___mul___  rx  r"   c                 4    |                      d||||          S NEqrp  r  s        r    #_handle_simple_method_object___eq__z8OptimizeBuiltinCalls._handle_simple_method_object___eq__b      ''dHdDUVVVr"   c                 4    |                      d||||          S NNerp  r  s        r    #_handle_simple_method_object___ne__z8OptimizeBuiltinCalls._handle_simple_method_object___ne__e  r  r"   c                 4    |                      d||||          S )NAndrp  r  s        r    $_handle_simple_method_object___and__z9OptimizeBuiltinCalls._handle_simple_method_object___and__h  rs  r"   c                 4    |                      d||||          S )NOrrp  r  s        r    #_handle_simple_method_object___or__z8OptimizeBuiltinCalls._handle_simple_method_object___or__k  r  r"   c                 4    |                      d||||          S )NXorrp  r  s        r    $_handle_simple_method_object___xor__z9OptimizeBuiltinCalls._handle_simple_method_object___xor__n  rs  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:   rq  r  s        r    '_handle_simple_method_object___rshift__z<OptimizeBuiltinCalls._handle_simple_method_object___rshift__q      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__x  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__  s    %%mT8TK\]]]r"   c                 4    |                      d||||          S N
TrueDivider  r  s        r    (_handle_simple_method_object___truediv__z=OptimizeBuiltinCalls._handle_simple_method_object___truediv__  s    %%lD(DJ[\\\r"   c                 4    |                      d||||          S NDivider  r  s        r    $_handle_simple_method_object___div__z9OptimizeBuiltinCalls._handle_simple_method_object___div__  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  rq  )rC   ri   r'   r   r   rh  s         r    r  z&OptimizeBuiltinCalls._optimise_num_div  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 rn  rp  r  s        r    #_handle_simple_method_float___add__z8OptimizeBuiltinCalls._handle_simple_method_float___add__  rs  r"   c                 4    |                      d||||          S ru  rp  r  s        r    #_handle_simple_method_float___sub__z8OptimizeBuiltinCalls._handle_simple_method_float___sub__  rx  r"   c                 4    |                      d||||          S r  rp  r  s        r    '_handle_simple_method_float___truediv__z<OptimizeBuiltinCalls._handle_simple_method_float___truediv__  s    ''dHdL]^^^r"   c                 4    |                      d||||          S r  rp  r  s        r    #_handle_simple_method_float___div__z8OptimizeBuiltinCalls._handle_simple_method_float___div__  s    ''$$HYZZZr"   c                 4    |                      d||||          S r  rp  r  s        r    #_handle_simple_method_float___mod__z8OptimizeBuiltinCalls._handle_simple_method_float___mod__  s    ''T8TK\]]]r"   c                 4    |                      d||||          S r}  rp  r  s        r    "_handle_simple_method_float___eq__z7OptimizeBuiltinCalls._handle_simple_method_float___eq__  r  r"   c                 4    |                      d||||          S r  rp  r  s        r    "_handle_simple_method_float___ne__z7OptimizeBuiltinCalls._handle_simple_method_float___ne__  r  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   r~  r  r   r   c                 &    g | ]}|j         j        S rM   )r   r   r@  s     r    rc   z<OptimizeBuiltinCalls._optimise_num_binop.<locals>.<listcomp>  s    999SCH(999r"   z__%s__r   TF)r  with_none_checkr7  )r  r[   r   r   r   r  rK  optimise_numeric_binopr  r  rL  Pyx_BinopInt_func_typeslowerr   r   r   )rC   ri   r'   r   r   rh  rl  r  
func_cnamer7  
extra_argsnum_typerj  s                r    rq  z(OptimizeBuiltinCalls._optimise_num_binop  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        }|dk    rt          j	        dd          }d}	nd }d|
                                z  }	|                     |||	| j        |||g|          }
|j        j        r|
                    | j                  }
|
S )	Nr   r   istitlepy_unicode_istitler=  __Pyx_Py_UNICODE_ISTITLEzPy_UNICODE_%sr  )r[   r%   r   r   r&   r   r3  r6   r   r   upperrL  #PyUnicode_uchar_predicate_func_typer   r  r   )rC   r'   r   r   rh  ustringr  r  r7  r  	func_calls              r    _inject_unicode_predicatez.OptimizeBuiltinCalls._inject_unicode_predicate  s    	D		QKq''9#?@@ 	;#3	K()##&2$o7 7L6MML+k.?.?.A.AAM00(4C*UG'	 1 ) )	
 9  	G!44T5EFFIr"   r>  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_argumentrL  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   r-  PyUnicode_Splitsplit)r[   r  rE   r   r  r   _inject_null_for_none_inject_int_default_argumentr   r  rL  PyUnicode_Split_func_typer  s        r    #_handle_simple_method_unicode_splitz8OptimizeBuiltinCalls._handle_simple_method_unicode_split7  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_Joinrq  )r[   r  r%   r   r  r  rZ   r  r   r   r   r  ry   r   r  rL  PyUnicode_Join_func_type)rC   r'   r   r   rh  r  r  r\   inlined_genexprr  r  r  s               r    "_handle_simple_method_unicode_joinz7OptimizeBuiltinCalls._handle_simple_method_unicode_joinP  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 )Nr  endswithr   _inject_tailmatchunicode_tailmatch_utility_coder  s        r    &_handle_simple_method_unicode_endswithz;OptimizeBuiltinCalls._handle_simple_method_unicode_endswithz  s-    %%(D"3Y
*B0 0 	0r"   c           
      D    |                      ||||ddt          d          S )Nr  
startswithrQ  r  r  s        r    (_handle_simple_method_unicode_startswithz=OptimizeBuiltinCalls._handle_simple_method_unicode_startswith  s-    %%(D"3Y*B0 0 	0r"   c	           
      L   t          |          dvr|                     |d|||d           |S |                     ||dt          j        d           |                     ||dt          j        d           |                    t          j        |j        t          |          t          j
                             |                     ||d	|                                z  | j        ||||
          }	|	                    t          j        |                                           S )zReplace unicode.startswith(...) and unicode.endswith(...)
        by a direct call to the corresponding C-API function.
        r   r      ro  2-4r   r   r   PY_SSIZE_T_MAXrm   r   z__Pyx_Py%s_Tailmatchr  )r[   r  r  r   r  rE   r   r   r   r>  r@  rL  
capitalizePyString_Tailmatch_func_typer<  r   r"  r   )
rC   r'   r   r   rh  rf  r  r7  r  method_calls
             r    r  z&OptimizeBuiltinCalls._inject_tailmatch  s@   
 t99G##''999kk(JDRVX]^^^K))$:7	> 	> 	>))$:79I	K 	K 	KI%HC	NN1FH H H 	I 	I 	I 22("Y%9%9%;%;;-*D' 3 ) ) $$W%68H8H8J8JKKKr"   z-2c                 6    |                      ||||dd          S )Nfindr   _inject_unicode_findr  s        r    "_handle_simple_method_unicode_findz7OptimizeBuiltinCalls._handle_simple_method_unicode_find  s+    (((D"3VRA A 	Ar"   c                 6    |                      ||||dd          S )NrfindrQ  r  r  s        r    #_handle_simple_method_unicode_rfindz8OptimizeBuiltinCalls._handle_simple_method_unicode_rfind  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  rE   r   r   r   r>  r@  rL  PyUnicode_Find_func_typer  r   )rC   r'   r   r   rh  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  rL  PyUnicode_Count_func_typer  r   )rC   r'   r   r   rh  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   r-  PyUnicode_Replacer  )r[   r  r  r   r  rL  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 rM   )codecs
getencoder)r`   r   s     r    rc   zOptimizeBuiltinCalls.<listcomp>   s8     9 9 9  v0667 9 9 9r"   c                 >   t          |          dk     st          |          dk    r|                     d||d           |S |d         }t          |          dk    r<t          j        |j                  }|                     ||d| j        d||||g          S |                     |j        |          }||S |\  }}	}
}|rst          |t          j	                  rY	 |j
                            ||
          }t          ||          }t          j        |j        |t          j        	          S #  Y nxY w|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   PyUnicode_AsEncodedStringr9  Nr  strictr  zPyUnicode_As%sString)r[   r  r   r  r   rL  #PyUnicode_AsEncodedString_func_type_unpack_encoding_and_error_moder%   r  rm   r9  r	   r:  r   r   _find_special_codec_namePyUnicode_AsXyzString_func_type)rC   r'   r   r   rh  string_node	null_node
parametersr  encoding_nodeerror_handlingerror_handling_noderm   
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t99>>!*4844I//h ;8+k9i-PR R R
 99$(DII
KGQD-1D 		b
;	0EFF 		bb#)00>JJ
 &eX66 *;?%gN`aaaa
  	@(2266x@@J%#Z*?*?"8:"E33(O8/+@ @ @
 ++(74'-)<=	? ? 	?s   D, ,D0stringrW  r"  decode_funcc                 	   dt          |          cxk    rdk    sn |                     d||d           |S |d         }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 |                     |j        |          }
|
|S |
\  }}}}|st          j        |j        dd          }n>|j        j        s2|                    t0          j        |                                           }|r>|j        j        s2|                    t0          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)tC          j"        |          }|#                    |           t          j$        |j        d| j%        |gd          }| j&        }d}nR|	j        r|s&t          j        |j        dt          j'                  }| j(        t1          j)        t          j*        t1          j+        d|	d          t1          j+        dt0          j        d          t1          j+        dt0          j        d          t1          j+        dt0          j,        d          t1          j+        dt0          j,        d          t1          j+        d| j        d          g          | _(        | j(        }d }nB|s&t          j        |j        dt          j'                  }| j-        }|	t          j        u rd!}nd"}t          j$        |j        d#|z  |||||||g|j.        t_          j0        |d$          %          }|ddd&         D ]}tC          j1        ||          }|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@descriptor '%s' requires a '%s' object but received a 'NoneType'decoder  r9  r  r  r   ry  )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_stringdecode_bytesdecode_bytearrayz__Pyx_%sr=  r>  rQ  )2r[   r  r%   r   r&  r   r!  r"  r:   r   r&   r   r   r   r   r   r   r\  is_cpp_stringr   r   r   r   r<  r   r  r   r!  r  rD  !PyUnicode_DecodeXyz_func_ptr_typer  r   r   r  rE   r#  r  _decode_c_string_func_typer   _decode_cpp_string_func_typer  r   r  r;  _decode_bytes_func_typer   r   r   r  )rC   r'   r   r   rh  r#  r!  r"  rl  string_typer%  r  r&  r'  r(  r)  codec_cnamedecode_functionr|   helper_func_typer  rs  s                         r    "_handle_simple_method_bytes_decodez7OptimizeBuiltinCalls._handle_simple_method_bytes_decodeQ  s    SYY####!####''dEJJJK 1gk9#;<< 	$J$/K$*JO4E E1Q66k9#?@@ 	*%/K!&7-w/EFFF  ,);;V!);+; < < > > *;;@0!)
 < , , & 	{/H 	K99$(DII
KGQD-1D 	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  $@ 3  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r"   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 rM   )r  )r`   r  s     r    rc   zAOptimizeBuiltinCalls._find_special_codec_name.<locals>.<listcomp>  s0     $> $> $>() %&LLNN $> $> $>r"   )r  r  LookupError_special_codecsrq  r  )rC   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)rC   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                    t          |t          j                  r|j        }t          |t          j                  r@|j        }t          j        |j        |                                t          j
                  }nt          |t          j        t          j        f          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  rm   r:  r   as_utf8_stringr   r;  r  r0  r   r   r   r<  r   r\  )rC   r'   r  s      r    rG  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y3Y5HIJJ 
	#z((66H&
1QS S SDDY',,,H>>*"BDDTDTDVDVWWDDY  	#HH""Ht~r"   c           
      D    |                      ||||ddt          d          S )Nr>  r  r   r  str_tailmatch_utility_coder  s        r    "_handle_simple_method_str_endswithz7OptimizeBuiltinCalls._handle_simple_method_str_endswith  s-    %%(D"3UJ&, , 	,r"   c           
      D    |                      ||||ddt          d          S )Nr>  r  rQ  rK  r  s        r    $_handle_simple_method_str_startswithz9OptimizeBuiltinCalls._handle_simple_method_str_startswith  s-    %%(D"3UL&, , 	,r"   c           
      D    |                      ||||ddt          d          S )Nr7  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 )Nr7  r  rQ  rQ  r  s        r    &_handle_simple_method_bytes_startswithz;OptimizeBuiltinCalls._handle_simple_method_bytes_startswith  s-    %%(D"3Wl(". . 	.r"   rM   c           
          t          |          }|r#|r!|                     |d         |||          |d<   |	|j        }	t          j        |j        ||||	||
|j                  S )Nr   )r   r   r7  r  r6  )r  r  r   r   r#  r   r6  )rC   r'   r   r   r  rg  rh  r   r7  r   r  r  s               r    rL  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/  r1  r  r  r  r  r  r  )r8  r   r   r   r  r[   )rC   self_argr   rh  rg  s        r    r  z#OptimizeBuiltinCalls._wrap_self_arg6  s     	O 	)11R&(:; 2 = =HH  11<CCSQZ^^_aMaMaEEgijj,&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_typerY  r   )rC   r   r   r&   s       r    r  z*OptimizeBuiltinCalls._inject_null_for_noneI  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 )NrP  )r[   r  rE   r   r   r   r>  r<  r   r%   r-  special_none_cvalue)rC   r'   r   	arg_indexr   default_valuer&   s          r    r  z1OptimizeBuiltinCalls._inject_int_default_argumentT  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 Nry  )r[   r  rE   r   r   r   r#  r   )rC   r'   r   r^  r_  s        r    r  z2OptimizeBuiltinCalls._inject_bint_default_argumentb  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  )rT   rU   rV   rW   r  r  rK   r$  r   r  r  r  r.  r0  r6  r?  r   r   r  r@  rA  r5  r   c_float_typer  c_longdouble_typerQ  r4  r_  rY  rZ  rN  r  r_  rk  rc  rw  ry  r   r  rt  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  r  r  r  rK  r  r  r  r  r  r
  r  r  r  r  r!  r)  r,  r.  r>  rB  r6  r5  rM  rN  rV  rW  r]  r_  rc  rd  r  r  rr  rw  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rq  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$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_encodingsrC  r+  r   r7  r8  r:  r9  r?  &_handle_simple_method_bytearray_decoder!  r   rG  rM  rO  rS  rU  r   r#  r  rL  r  r[  r  r  r  rM   r"   r    r  r  J  s3             	 	 	   
 
 
  4z3!#J#C)BDII$   
  .& & &P $8:#7#J#GW-?FF#J#GZ-I4PP#J#NJ4I4PP!
 '$  $  $    2 "T "m "m
 &2J4LjNjk"m "m "m m m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  !5
 4!#J#E:+DdKK$! !

 
 
< "6!5#J#E:+DdKK" "
  .
 
 
 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# )#  #  # 6 6 6p 2Z1!#J#C)BDII$ 
 "6!5!#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! 
E E EN  < 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$ 8 8 8  #d #
 #
 !,j.FG#
 #
 #
 
 
X X X] ] ]] ] ]W W WW W WX X XW W WX X X[ [ [[ [ [\ \ \^ ^ ^] ] ]Y Y Y[ [ [X X X] ] ]_ _ _[ [ [^ ^ ^W W WW W W# # #N +?**>#J#GZ-FMM!+ +'
  4 /H).G).G+.G).G).G+.G).G).G)+?:+?!#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.  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[[
  $( t t tl .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dS |}d}n,t          ||          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t-          | ||                    }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)ro  rv  r  r  r  r~  r  r  r   )r  r  r  r  r   r   Fry  r  PyFloatBinopPyIntCompare
PyIntBinopr   )oporderrl  )r   __Pyx_PyFloatIntr  r  Bool)r   r   r  r%   r   r   r  r   r  r  rV  r:   rE   r   rm   NumBinopNoderi  r   r  	cdivisionr   r   r   r   )ri   r'   rl  arg0arg1	num_nodesnumval	arg_orderr2  r  r  ri  zerodivision_checkr7  r  s                  r    r  r  l  s    "I$78I$	"" 9J5554			D)	$	$ 9J555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"d(l:R:RXd	HEEEG G GLL &&&"..		J |Z99r"   unicode_tailmatchr=  bytes_tailmatchstr_tailmatchc                   @    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+e,j-        j.        Z/ xZ0S ))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                 d    t          t          |                                            || _        dS )z
        The reevaluate argument specifies whether constant values that were
        previously computed should be recomputed.
        N)superr  r@   
reevaluate)rC   r  	__class__s     r    r@   zConstantFolding.__init__  s,    
 	ot$$--///$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   rF   r   r   r  r  calculate_constant_result
ValueError	TypeErrorrd   
IndexErrorr  ArithmeticErrorrJ  	tracebacksys	print_excstdout)rC   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  )rC   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 ra  )r  r   r   r   )rC   r'   rm   s      r    
_bool_nodezConstantFolding._bool_node  s'    U!$(%OOOOr"   c                 0    |                      |           |S r$   )r  rG   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!rP  rR  r  )r  r   ri   _handle_NotNoder   r8  r  r:   r%   r   r   r   r   r>  rH  r   r@  _handle_UnaryPlusNode_handle_UnaryMinusNoderG   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}   r=  is_notis)r=  r}   r  r  c                     |j         }t          |t          j                  rL|                     |j                  }|r0t          j        |          }||_        |                     |          }|S r$   )r   r%   r   r   _negate_operatorri   copyr   )rC   r'   r   ri   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  rl   s    r    _negatez7ConstantFolding._handle_UnaryMinusNode.<locals>._negate'  s5    $$ $abb	eLr"   rP  )rm   r   longnessr:   )r   r   r%   r   r  r   rm   r:   r   rC  r   r   r  )rC   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:   rG   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  rj   r   r:   ri   rk   rG   s     r    r*  z#ConstantFolding.visit_BoolBinopNodeB  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  rm   r:   )r   r   rm   r:   )r  r:   r   r   r%   r  rj   rk   r8  r   r  rO  r   widest_numeric_typer  r  r   ri   r   r  r  r  r[   hexrH  r   strip_py2_long_suffixr   r   r>  )rC   r'   rj   rk   type1type2widest_typetarget_classr  r  rm   r   
node_values                r    visit_BinopNodezConstantFolding.visit_BinopNodeQ  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                 b   |                      |           |j        t          j        u r|S |j        j        rd|j        j        rW|j        |j        }}t          |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        ||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 )N)rm   r:   rH  ry  )r  r:   r   r   rj   r*  rk   r%   r  rH  r  r	   r   r   r:  rm   r  )rC   r'   str1str2rH  string_values         r    visit_AddNodezConstantFolding.visit_AddNode  s   d###9#;;;K=* 	rt}/N 	r$D$	 566 r:dILa;b;b r"#/D4D4P'0D4D4MMM&3 ,t/?? ,5'7 '7  -T-ABB ,HL$BVdoq q q qD)"566 r:dIL_;`;` r:&$**==="/0DdjFY"Z"ZK$.tx{\`\pqqqq ##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  rj   rl  _calculate_constant_seqrk   r%   r   r   r*  _multiply_stringr  rG   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                 n   |j         }t          |t                    s|S |                                rt          |j         t                    s|S t          |j                   dk    r|S t          }t          |t          j                  rt          }nt          |t          j
                  rI|j        't          |j        |z  |j        j                  |_        |j        j        rt          nt          }nct          |t          j                  r/|j        't          |j        |z  |j        j                  |_        nJ dt#          |          z               ||j        |z  |j        j                  |_        t          |t          j
                  r|j        |j        |_         n|j        |_         |S )N   Fzunknown string node type: %s)r:   r%   r   r   _py_string_typesr[   r
   r   r:  r	   r  r  r  rm   
is_unicoder  rH  r   )rC   r'   r#  multiplier_node
multiplierbuild_strings         r    r  z ConstantFolding._multiply_string  s   $4
*m44 	K((** 	z$:NP`/a/a 	Kt#$$s**K%k9#677 	M(LLY%9:: 	M(4,:-
:-6-8 -8) .9->-I\>>}LLY%:;; 	M&2*7+j8+4+6 +6' M84;L;LLLLL(L
*&( ( k9#788 	<[=V=b*5*CK''*5*;K'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   r>  r  )rC   r'   sequence_nodefactorrm   s        r    r  z'ConstantFolding._calculate_constant_seq  s    !Q&&=+=&&0-@@ 3VE[_`E`E`!&qqq),0))*6v5}EE 6"=#<#Lm\\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$   )rF   r%   rj   r   r  rk   rF  r  _build_fstringr   rm   r   r  )rC   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    r8|                    t          j        |t          d          d                     D|d         dk    rc|d         dk    rt          |d|dd          z  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%%%ry  r   rQ  zIncomplete format: '...%s'r   )levelFz)Too few arguments for format placeholdersasrfdoxXdoxXro  arsr   r   dr  r   )rm   r  r  z*Too many arguments for format placeholders)r   )iterrer  _parse_string_format_regexrE   r   r  r   r   nextStopIterationr?  r  FormattedValueNoder   JoinedStrNodevisit_JoinedStrNode)rC   r   r  r  r   
substringscan_be_optimisedr  format_typer&   r  r  r'   s                r    r  zConstantFolding._build_fstring  s   K  
$97CC 2	 2	A Ezz!!)"7=QUCVCVhl"m"m"mnnntt||R5D==C!="##!FaPPPP',$!!)"7=QRCSCSef"g"g"ghhhB%K4jj    HPQRRRR#(  ~ #( k))e"&'))dk.A.A',$$ F**"-crc"2K&1O"--c22 <&)KO&; D((&)O))#.. 8"%ABB"7K!!)">G3$3 '!1	 5=#=#={!\ !\ !\ !\,0# # #     $)  	4	JJJ CEQOOOO4 """dd"
 &s:>>>''---s$   *C::DDH% %
H21H2c                    |                      |           |j        pd}t          |j        t          j                  r|j        j        sd |_        |j        mt          |j        t          j                  rNt          |j        j                  }|	                                r!t	          j        |j        j
        ||          S |j        |dk    r|d }t          |j        t          j                  r|j        j        }n+t          |j        t          j                  r|j        j        }|!t	          j        |j        j
        ||          S |S )Nr  ry  )rF   r  r%   r  r   r  rm   r   r   isdigitr   r  r  )rC   r'   r  rm   s       r    r  z(ConstantFolding.visit_FormattedValueNodeA  s1   4   .5#d&	(=>> 	$tGWG] 	$#D#
4:y?P(Q(Q#!$*"233E}} a ,TZ^5Z_````#3(>(>E$*i&;<< 1
(DJ	(<== 1
0  ,TZ^5Z_````r"   c                    |                      |           t          j        g }t          j        |j        fd          D ]\  }}|rt          |          }|d         }t          |          dk    rHt          d	                    d |D                                 }t          j        |j
        ||          }|j        r|                    |           |                    |           |s,t          d          }t          j        |j
        ||          }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.
        c                 $    t          |           S r$   )r%   )vunicode_nodes    r    <lambda>z5ConstantFolding.visit_JoinedStrNode.<locals>.<lambda>^  s    S]^_amSnSn r"   r   r   r  c              3   $   K   | ]}|j         V  d S r$   rl   )r`   rm   s     r    rF  z6ConstantFolding.visit_JoinedStrNode.<locals>.<genexpr>c  s$      2W2W55;2W2W2W2W2W2Wr"   ry  r   rR  )rF   r   r  	itertoolsgroupbyr   r  r[   r   rq  r   rm   rE   r  r  )rC   r'   r   is_unode_groupr  unoderm   r  s          @r    r  z#ConstantFolding.visit_JoinedStrNodeT  s~    	4    ,*3*;DKInInInIn*o*o 	* 	*&NJ 
*!*--
"1z??Q&&)#((2W2WJ2W2W2W*W*WXXE%1%)5Z_```E; )MM%(((j)))) 		!!"%%E(PUVVVDD[[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 )NrQ  )	is_dict_literalreject_duplicatesr  r  rE   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)	rF   r  r  r[   r  r%   r   r   r  )rC   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_literalrl  r  r   r  rE   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)rF   r   r   r   r   rE   r[   r  rl  r%   r   r  r  )rC   r'   r&   r  r   r  r   s      @@@@r    visit_MergedSequenceNodez(ConstantFolding.visit_MergedSequenceNode  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)	rF   r   r?  rE   ry   rl  r  r  r  )rC   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 )Nrj   rk   FrQ  r   r   r   )rj   ri   rk   r:   Tr  )rF   rj   rk   r   r:   r   "calculate_cascaded_constant_resultr  r  rd   r  r  r  r  r  rE   r[   r   r   r   ri   r  )rC   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$  rG   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 Nrq   )rF   rv   rt   r   r:   ru   rw   rE   r   r   r   )rC   r'   rv   r  rt   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   rl  r  r   r*  as_sliced_node)rC   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  )rF   r%   r  r   r   rr   r   r   r   r   rG  r   r   rH  r  r   r  rG   s     r    visit_ComprehensionNodez'ConstantFolding.visit_ComprehensionNodeU  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  )rF   rz   rx   r%   r   SequenceNoder   rw   r   r   r   rG  r  )rC   r'   rx   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$   )rF   rt   r   r:   rw   rG   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$   )rF   r%   rJ   r   ExprNoder   rG   s     r    rK   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$   )rF   rt   r   r:   ru   rG   s     r    visit_GILStatNodez!ConstantFolding.visit_GILStatNode  sb    4   >!K>--// 
	! ~- !!% y  r"   r  )1rT   rU   rV   rW   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  r  r  r  r  r	  r  r   r&  r   r  r  r   r   rK   r$  r   r8  r9  rX   __classcell__)r  s   @r    r  r    sf         % % % % % %1 1 1@ !)9+= ()*=?O  P P P    * 	 
 
     ,  % % %: : :x* * *2* * *" " "H  &* * *	 E. E. E.N  &! ! !F     D$ $ $L  N N N`" " ": : :.  .          6 )=JJJJJr"   r  c                   H    e 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S )FinalOptimizePhaseap  
    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
    Fc                 Z    |                      |           |j        r|j        }d|_        |S )zaAvoid redundant initialisation of local variables before their
        first assignment.
        T)rF   r.  ro   lhs_of_first_assignment)rC   r'   ro   s      r    visit_SingleAssignmentNodez-FinalOptimizePhase.visit_SingleAssignmentNode  s6     	4   : 	/(C*.C'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<   n|j        r|j        j        r| j                            | j        s|                                 j        rdnd          rt1          |j        t          j                  rs|j        j        sf|j        j        rt          |j        j                  dk    s<d	}|j        t:          j        u rd
}n|j        r|j        r|j        j        j        rd
}nn|j        rg|j        }|j         s|j        j        rd
}nJ|j!        rCt          j"        t          j#        t          j$        ftK          fd|j!        D                       }|r|j&        rJ|j        rCt1          |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  z&optimize.unpack_method_calls_in_pyinitzoptimize.unpack_method_callsTFc              3   R   K   | ]!}|j         ot          |j                    V  "d S r$   )rp   r%   )r`   
assignmentnon_method_nodess     r    rF  z:FinalOptimizePhase.visit_SimpleCallNode.<locals>.<genexpr>  sV       .D .D * 'N_:jnN^3_3_/_.D .D .D .D .D .Dr"   )r   r   r   )-rF   r   r   is_cfunctionr   r   r[   r   rL  r   r  r   r   r   r   r   r]  r   r   r  r  in_loopr   is_module_scoper%   r   rF  r  r8  r   r  r   r   r  r  	ClassNodePy3ClassNoder  rC   r5   r[  r&   r  PyMethodCallNode	from_node)	rC   r'   r   r  r  r  may_be_a_methodr   r/  s	           @r    r~  z'FinalOptimizePhase.visit_SimpleCallNode  s   
 	4   ==% (	\(*: (	\},,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l 	\x}8 	\T=T=X=X|4(,(8(8(:(:(J4883>5 >5 	\
 $.)*=>> \N.\37>3L\QTUYUcUhQiQilmQmQm"&=G$555&+OO* D~ 0(.*=*J 0*/% 	D$NE' D5:+B D*/- D,5,EyGZ\e\r+s(*- .D .D .D .D.3.B.D .D .D +D +D # \	 8h&; 8&x|Y5HII8NVlN^bfbkNkNk'/|'7<<i.H.R.Rx4>PTPY /S /[ /[ \ \Dr"   c                 0    |                      |           |S r$   )rF   rG   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)rF   notnoner&   rv  rG   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.
        )rF   r&   rv  rG   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)r1  rF   )rC   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)rF   r   rv   _set_ifclause_branch_hintru   branch_hintrw   )rC   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  ru   r   rr   r[   RaiseStatNodeReraiseStatNoderD  )rC   clausestatements_noderB  non_branch_nodes
statementsnext_node_posr'   s           r    rC  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"   Nr  )rT   rU   rV   rW   r1  r*  r~  r9  r  r=  r@  r   rC  rM   r"   r    r'  r'    s          G  0 0 0d  
	 	 	           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_noderF   )rC   r'   saveds      r    rX   z#ConsolidateOverflowCheck.visit_NodeF  sS    !-*E%)D"t$$$%*D""t$$$r"   c                     |j         rL|j        rE| j        d u }|r|| _        n| j        |_        d|_         |                     |           |rd | _        n|                     |           |S r0   )overflow_checkoverflow_foldrZ  rF   )rC   r'   top_level_overflows      r    visit_NumBinopNodez+ConsolidateOverflowCheck.visit_NumBinopNodeP  s     	%4#5 	%!%!74!?! ,)-&&)-)?&&+#t$$$! .)-&t$$$r"   )rT   rU   rV   rW   rZ  rX   r`  rM   r"   r    rX  rX  =  sD                r"   rX  )M
__future__r   r  r  r  r  r  r  r   r   r   cythondeclarer  version_inforH  r   r7  r>  r  longr  r   r   r   r   r   r   Coder   r   StringEncodingr   r	   r
   Errorsr   r   ParseTreeTransformsr   r   __builtin__r   ImportError	functoolsr   r!   r   r-  r)   r.   r4   r;   r?   r=   r]   rZ   EnvTransformrf   r  r8  r;  rP  rz  NodeRefCleanupMixinr  MethodDispatcherTransformr  r  r   r  rR  rL  r  r'  CythonTransformrX  rM   r"   r    <module>rq     s   & & & & & & 				 



             % % % % % %  6v^dv&&v7 7 7 7 A!Ms|$KMw'                                           1 1 1 1 1 1 1 1 H H H H H H H H H H " " " " " " " " 1 1 1 1 1 1      !""""""" ! ! !        !&&&&&&&   JJJ7 7 7 /8.JILj-k              '-   @    u u u u u- u u upC> C> C> C> C>g* C> C> C>LI> I> I> I> I>W57G I> I> I>Xq& q& q& q& q&w7 q& q& q&hb b b b bw3 b b bJ    4g6J   D_ T _ T _ T _ T _ T76"<_ T _ T _ TDAB: B: B:J "9!89Lo!^!^ 6{67H/ZZ 4[4_oVV l> l> l> l> l>g.0@ l> l> l>^U U U U U-w/J U U Up         w6          s$   6B= =C
CC C C 