B \@sddlZddlZddlZddlmZmZmZmZmZm Z mZm Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z ddl!m"Z"m#Z#m$Z$ddl%m&Z&ddl'm(Z)ddl*Z+ddl,Z,dZ-Gd d d e.Z/d d Z0d/d dZ1ddZ2ddZ3ddZ4ddZ5ddZ6ddZ7ddZ8ddZ9dd Z:d0d"d#Z;d$d%Ze ?d*Gd+d,d,e j@ZAd-d.ZBdS)1N)configirir_utilsutilsprangerewritestypestyping)internal_prange) mk_unique_var next_labeladd_offset_to_labels replace_vars remove_dels remove_dead rename_labelsfind_topo_ordermerge_adjacent_blocksGuardExceptionrequireguardget_definition find_callnamefind_build_sequenceget_np_ufunc_typget_ir_of_code simplify_CFGcanonicalize_array_math)compute_cfg_from_blockscompute_use_defscompute_live_variables)range_iter_len)empty_inferredTc@sLeZdZdZifddZddZddZdd Zd d Zd d Z ddZ dS)InlineClosureCallPasszInlineClosureCallPass class looks for direct calls to locally defined closures, and inlines the body of the closure function to the call site. cCs||_||_||_g|_dS)N)func_irparallel_optionsswapped_processed_stencils)selfr$r%r&r)7lib/python3.7/site-packages/numba/inline_closurecall.py__init__0szInlineClosureCallPass.__init__c sd}t|jj}td}|dx|r|\}}xt|jD]\}}t|t j rB|j }|j } t| t j rB| jdkrBtt|j| } tt|j| j} t|j|||| | rd}Pt|j|||| rd}Pt|j|| | rBd}qBWq&Wtr|rt|jjt|jj} |dt| | fddD} g}xPt| d d dd D]:\}}||tt|j| |||j|j j!rLd}qLW|rt"|j|rt#|jjxt$|jj|jj%|jrʐqWt&|jj|j_|d d S)z&Run inline closure call pass. Fr#ZSTARTcallTzstart inline arraycallcsg|]}|t|jfqSr))lenbody).0k)loopsr)r* ^sz-InlineClosureCallPass.run..cSs|dS)Nr))tupr)r)r*asz+InlineClosureCallPass.run..)keyreverseZENDN)'listr$blocksitems_make_debug_printpop enumerater. isinstancerAssigntargetvalueExproprrrfunc_inline_reduction_inline_closure_inline_stencilenable_inline_arraycallrr _debug_dumpr1keyssortedappend_inline_arraycallr&r%Z comprehension_fix_nested_arrayrr arg_namesr)r(modified work_list debug_printlabelblockiinstrlhsexpr call_namefunc_defcfgZ sized_loopsvisitedr0sr))r1r*run6s^            zInlineClosureCallPass.runcCstt|jj t|dkp|dkt|jdkr8tdt|j|jddd}t|j|jj j j ||||dd S) N)reducebuiltins)r_ _functoolszEinvalid reduce call, three arguments including initial value requiredrcSs(|}t|}x|D]}|||}qW|S)N)iter)fAvr]itar)r)r* reduce_func~s  z.reduce_func)rQT) rr%Z reductionr-args TypeErrorcheck_reduce_funcr$inline_closure_callfunc_idrD __globals__)r(rQrTrUrXrYrir)r)r*rEss   z'InlineClosureCallPass._inline_reductionc Csxddlm}|j}|j}t|tjrb|jdkrbt|j|rb|jrT|j|jj7_n |jj|_dSt |dkpr|dkt ||j k|j |t |j dkstdtt|j|j d}t t|tjo|jd kt|jjjj|j}t|j} d | krt|j| } | std d | kr:t|j| } | s:td ||d| } |j| _td| |j} | g|jj|j<| |_dS)Nr) StencilFuncstencilT)rqz numba.stencil)rqnumbar3z5As a minimum Stencil requires a kernel as an argument make_function neighborhoodzXstencil neighborhood option should be a tuple with constant structure such as ((-w, w),) index_offsetszYstencil index_offsets option should be a tuple with constant structure such as (offset, )Zconstant)Z numba.stencilrpr@rAr>rGlobalnamekwsrr'rLr-rj ValueErrorrrr$rBrCrrnrDrocodedict_fix_stencil_neighborhood_fix_stencil_index_offsetsloc _definitions) r(rVrYrZrprWrXZ stencil_defZ kernel_iroptionsZfixedZsfZ sf_globalr)r)r*rGsH                z%InlineClosureCallPass._inline_stencilcCslt|j|d}tt|dg}x8|jD].}t|j|}tt|d|t|jq*Wt||d<dS)z Extract the two-level tuple representing the stencil neighborhood from the program IR to provide a tuple to StencilFunc. rtr:T)rr$rhasattrr:rLtuple)r(rZdims_build_tupleZresZ window_varZwin_build_tupler)r)r*r|s   z/InlineClosureCallPass._fix_stencil_neighborhoodcCs0t|j|d}tt|dt|j|d<dS)z Extract the tuple representing the stencil index offsets from the program IR to provide to StencilFunc. rur:T)rr$rrrr:)r(rZ offset_tupler)r)r*r}sz0InlineClosureCallPass._fix_stencil_index_offsetscCs<tt|tjo|jdkt|j|jjjj ||||ddS)Nrs)rQT) rr>rrBrCrmr$rnrDro)r(rQrTrUrZr)r)r*rFs   z%InlineClosureCallPass._inline_closureN) __name__ __module__ __qualname____doc__r+r^rErGr|r}rFr)r)r)r*r#+s =. r#cCsdtt||}|dkrtdt|ds8t|ds8tdt|drH|jn|j}|jdks`tddS)NzMReduce function cannot be found for njit analysisrz__code__zInvalid reduction functionz*Reduction function should take 2 arguments)rrryrrzr co_argcountrk)r$func_varrif_coder)r)r*rls    rlc ) s|j} |j|} | j} td} | d| d|t|dr<|jn|j}t|drR|jn|j}t|drh|j n|j }t ||}|j }t tjt |j }t||d}t|}||_ t|}t |}|t_| dt|t|}| d |t|dkst|d }i}xD|jjD]4}|j|jkr| jt|j|jd }|||j<qW| d |t ||| d t|t!| j"}|r| d|t#|t$r|t!|}ndt#|t%j&st#|t'r|(|}t#|t%j)st|j|fdd|jD}nt*d+|| dt||r|(|}| d|t#|t$rxt,j-j.t,j/_0t,j/f_1t$fdd|D}n$t#|t%j2r|j3dkst|j4}t|jt|kstt5||| dt||rrd dl6m7}y|8|||d\}} }!Wn,t9k r&|8|||d\}} }!YnXt:|||!|dd|D}"x|"D]}#|;|#qJW|<||<|!t=||g}$t%>| |j}%|j|dd|%_t?}&|%|j |&<|$@|&|%f|jd||_|j@t%A|| jtB|}'tC|| jD|&| jDj|jEkr4| |jE| jDjkr4|jE| jDjF| x>|'D]6}(||(}| |_tG||||j |(<|$@|(|fq:W| dt|| dkrx|$D]}| @|qW|S)aBInline the body of `callee` at its callsite (`i`-th instruction of `block`) `func_ir` is the func_ir object of the caller function and `glbls` is its global variable environment (func_ir.func_id.func.__globals__). `block` is the IR block of the callsite and `i` is the index of the callsite's node. `callee` is either the called function or a make_function node. `typingctx`, `typemap` and `calltypes` are typing data structures of the caller, available if we are in a typed pass. `arg_typs` includes the types of the arguments at the callsite. rmzFound closure call: z with callee = rzdefaultsclosurer3z After relabelzcallee_scopes = r)r~z var_dict = zAfter local var renamez defaults = csg|]}tj|dqS))rAr~)rConst)r/rf)r~r)r*r2(sz'inline_closure_call..z)Unsupported defaults to make_function: {}zAfter arguments rename: zcallee's closure = c3s|]}|VqdS)Nr))r/x)cellgetr)r* 8sz&inline_closure_call.. build_tuplezAfter closure rename)compilerNcSsg|]}|dr|qS)zarg.) startswith)r/Zvnamer)r)r*r2NszAfter merge in)Hscoper.rAr;rrzrr __defaults__r __closure__rr9maxrZ _max_labelrJr rminrI_get_all_scopesr-AssertionErrorZ localvarsZ_convaluesrw co_freevarsZdefiner r~rr8rjr>rrVarstrrrNotImplementedErrorformatctypesZ pythonapiZ PyCell_GetZ py_objectZrestypeZargtypesrBrCr:_replace_freevarsrrrZtype_inference_stage BaseExceptionrr<update_replace_args_withZBlockr rLJumpr_replace_returnsr@rremove_add_definitions))r$ZglblsrTrUcallee typingctxZarg_typstypemap calltypesrQrrVZ call_exprrRZ callee_codeZcallee_defaultsZcallee_closureZ callee_irZ callee_blocksZ max_labelZ min_labelZ callee_scopesZ callee_scopeZvar_dictvarnew_varrjrrr:rZ f_typemapZ f_return_typeZ f_calltypesrOrhZ new_blocksZ new_blockZ new_labelZ topo_orderrSr))rr~r*rms                              rmcsfdd}|S)Ncs*tjr&tdddd|DdS)Nz: css|]}t|VqdS)N)r)r/rr)r)r*r|sz9_make_debug_print..debug_print..)rDEBUG_INLINE_CLOSUREprintjoin)rj)prefixr)r*rRzsz&_make_debug_print..debug_printr))rrRr))rr*r;ys r;cCstjr|dS)N)rrdump)r$r)r)r*rIsrIcCs4g}x*|D]\}}|j|kr||jqW|S)z+Get all block-local scopes from an IR. )r:rrL)r9Z all_scopesrSrTr)r)r*rs  rcCsdx^|D]R\}}|tj}x<|D]4}t|jtjr$|jj}|t|ksNt |||_q$Wq WdS)z@ Replace ir.Arg(...) with real arguments from call site N) r: find_instsrr?r>rAZArgindexr-r)r9rjrSrTassignsstmtidxr)r)r*rs  rcCsx|D]x\}}|tj}xb|D]Z}t|jtjr$|jj}|t|ksNt t||tj rj|||_q$t |||j |_q$Wq WdS)zJ Replace ir.FreeVar(...) with real variables from parent function N) r:rrr?r>rAZFreeVarrr-rrrr~)r9rjrSrTrrrr)r)r*rs   rc Csx|D]\}}g}xtt|jD]}|j|}t|tjr|dt|jksVtt|j ||j |j|<|j t ||j xX|D]}|j j|j jkr|j j |_ qWq&t|tjr&t|j tjr&|j jdkr&| |q&Wq WdS)zN Return return statement by assigning directly to target, and a jump. r3castN)r:ranger-r.r>rZReturnrr?rAr~rLrr@rwrBrC) r9r@Z return_labelrSrTZcastsrUrrr)r)r*rs   &rcCs8|j}|tj}x |D]}||jj|jqWdS)zF Add variable definitions found in a block to parent func_ir. N)rrrr?r@rwrLrA)r$rTZ definitionsrrr)r)r*rs  rc Cs6d}d}d}d}d}x|t|jkr |j|}t|tjrX|rV|rV|j|jkrVd}Pnt|tjr|j}|j} t t || dkrt| j dtj r| j d}|}|} t | j} nPt|tjrt|jtj r|s|j}|j}t||} tt t|| |} i} nP|d}qWt|o|td|j| || | fS)zLook for statement like "x = numpy.array(y)" or "x[..] = y" immediately after the closure call that creates list y (the i-th statement in block). Return the statement index if found, or raise GuardException. NFrT)arraynumpyr3Zfind_array_call)r-r.r>rDelrArwr?r@rrrjrr{rxSetItemrr_find_unsafe_empty_inferredr;) r$rT array_vararray_call_indexZlist_var_dead_after_array_calllist_varrUrVrWrXZarray_stmt_index array_kwsZ array_defr)r)r*_find_arraycallsF        rc CsHtd}t||}|d|d|tt|tjo6|jdk|j}t||}|d|d|tt|tjon|jdk|j}t||}|d|d |tt|tj o|jt kt |j } d |jj g} | d kr| ||jj<t||j d d d} d |j d |fS| dkr@| ||jj<t||j d d d} t||j d d d} | | |fStdS)zzFind the iterator's actual range if it is either range(n), or range(m, n), otherwise return raise GuardException. Zfind_iter_rangezrange_iter_var = z def = Zgetiterz range_var = z range_def = r,z func_var = z func_def = )z"array comprehension"z closure ofr3rT)lhs_onlyrN)r;rrr>rrBrCrArDrvrr-rjr~rwr) r$Zrange_iter_varr&rRZrange_iter_defZ range_var range_defrrZnargsZswappingstopstartr)r)r*_find_iter_ranges0         rFc; std}tt|jdktt|j}t||j|\}} } d} d} d| krtt| dt j t || d} tt| t j o| j dkt || j} t ||} |d|d| t| t j r| j dkrt || j} tt| t j o| j d kg}x|jD]}fd d ||D}t|sq|j|}|d |x|t jD]}|j}|j}t|t j r@|j d kr@t ||j}t|t j r@|j dkr@|jdkr@t ||j}|d||| k|| kr@||||fq@WqWtt|dk|d\}}}tdd||jD}|d||jt|gBt||jt|gBkg}g}|j|j}xr|t jD]b}|j}t|t j rf|j dkrt ||j}|d|||jn|j dkrf||jqfWtt|dkot|dk|d}|d} tt|jdk|jtt|j}!|!j}"|!j}#|!j}$g}%g}&dd}'xftt|!jdD]P}(|!j|(}t|t jr|j|ks|'|j|&r|&|jn |%|qVW|d|&t t!|||})t |#t"d|$}*|)r|)ddkr| }*n|%t#||*t j$d|$d|$t |#t"d|$}+|)rv|)\},}-}.|,dkr>|-}/nt j j%t&j'|-|,|$d}/|rt|.t j(rd|._)t*|._nHt |#t"d |$}0|%t#||0t j(d!t+|$d"|$t j j,|0|fd#|$d"}/|%t#||+|/|$t |#t"d$|$}1|%t#||1t j j-|+g|$d%|$t |#t"d&|$}2t |#t"d'|$}3| r| rt |#t"d(|$}4t |#t"d|$}5|%t#||4| |$|%t#||5t j .|4| j|$|$|%t#||3t j(d)t/j0|$d"|$d|5fg} n$|%t#||3t j(d*t1|$d"|$g} |%t#||2t j j,|3|1ft2| |$d"|$x"|&D]}6|%t#||6|2|$qW|%|"|%|!_|)r|)ddkrX|j}"t|"t j3slt4|"j5}7|j|7}8|8j}$|8j6dt#||*t j j%t&j'| |)d|$d|$n|j}$|j}"|jdd}%t |#t"d+|$}9t |#t"d,|$}:|%t#||:t j$d|$d|$|%t#||9t j j%t&j7|*|:|$d|$|%t#||*|9|$|%|"|%|_xRtt|jD]@}(|j|(|krh|d-t j8|2|*|jj9d|jd.|j|(<qhW|j|j| }t|t jrt|jt j r|2|_|jg|j:|jj)<d/S)0aLook for array(list) call in the exit block of a given loop, and turn list operations into array operations in the loop if the following conditions are met: 1. The exit block contains an array call on the list; 2. The list variable is no longer live after array call; 3. The list is created in the loop entry block; 4. The loop is created from an range iterator whose length is known prior to the loop; 5. There is only one list_append operation on the list variable in the loop body; 6. The block that contains list_append dominates the loop head, which ensures list length is the same as loop length; If any condition check fails, no modification will be made to the incoming IR. Zinline_arraycallr3Ndtypegetattrz list_var = z def = r build_listcsg|]}|jkqSr))header)r/l)r\r)r*r2Asz%_inline_arraycall..zcheck loop body block r,rLz list_def = rcss|]\}}|VqdS)Nr))r/rbr)r)r*r\sz$_inline_arraycall..zpreds = Ziternextz iter_def = Z pair_firstcSs.t|tjr*x|D]}|j|jkrdSqWdS)NTF)r>rrrw)valremovedrr)r)r* is_removed}s    z%_inline_arraycall..is_removedzremoved variables: r)rAr~size)fnrWZrhsr~r Zlen_funcr!)r~r) size_tuple)r:r~r empty_funcZ dtype_modemptyunsafe_empty_inferredZ next_indexonezReplace append with SetItem)r@rrAr~T);r;rr-Zexitsnextrcrr9r>rrrrBrCrAr.Zin_loopsallrr?r@rDattrrLsetZ predecessorsrentries terminatorrr~rrrr _new_definitionrZbinopoperatorsubrvrwr r!r,rrnprrr8ZBranchrZtruebrinsertaddrrjr);r$r[r\Zloopr&Z enable_prangerRZ exit_blockrrrZ dtype_defZ dtype_mod_defZ list_var_defZlist_append_stmtsrSZin_visited_loopsrTrrWrXrZZlist_defZappend_block_labelZ append_blockZ append_stmtZpredsZ iter_varsZiter_first_varsZ loop_headerZiter_defZiter_varZiter_first_varZ loop_entryrrr~stmtsrrrUr index_varsize_varrrZrange_func_defZsize_valZ len_func_varsize_tuple_varrrZ dtype_mod_varZ dtype_varrZblock_idZblkZnext_index_varrr))r\r*rMs                   (                      rMcCsVttt|tjo|jdk|j}t||}tt|tjt d|j |j tkS)Nr,r) rrr>rrBrCrDrrvr;rA)r$rXrZ callee_defr)r)r*rs rcsjt}ttddD}t|j|fddfddfdd}xBtjD]4}j|}x$|jD]}t ||r|j |qWqxWd S) zLook for assignment like: a[..] = b, where both a and b are numpy arrays, and try to eliminate array b by expanding a with an extra dimension. cSsg|]}|tfqSr))r)r/rSr)r)r*r2sz%_fix_nested_array..csP|}td||t|tjrHtt|r4|S|jdkrH|jSt dS)zFind numpy array definition such as arr = numba.unsafe.ndarray.empty_inferred(...). If it is arr = b[...], find array definition of b recursively. find_array_defgetitemN) rr;r>rrBrrrCrAr)ZarrZarr_def)rr$r)r*rs     z)_fix_nested_array..find_array_defcsztd}xfD]X\}}|j}|j}t}x:tt|D](}||} t| tj r@| | j j | j |kr@g} x|D]} | j |ks| j |kr| j j|kr|| j d| | q||| j dt| j } t| tjr^| j} t|td| }t| j | }t||| }g}||d||||||d||_| |q|tq|W| Sq@WqWtdS)zDouble check if all variables in varlist are defined before expr is used. Try to move constant definition when the check fails. Bails out by raising GuardException if it can't be moved. fix_dependenciesz already definedz not yet definedrN)r;r:rr.rrr-r>rr?rr@rwrAdefmaprLrrr~rr rextendr)rXZvarlistrRrSrTrr.ZdefinedrUinstZ new_varlistrZvar_defr~rZ new_constZ new_vardefnew_body)r9r$livemapusedefsr)r*r&sD            z+_fix_nested_array..fix_dependenciescstt|tjtt|jtjtd}|d||j}|}|d|t|j}|d|tt|tj |j dkrt|j}tt|tj tt |t|j d}tt|tj o|j dk|d|fd d |j D}|d |t|j d}tt|tj o |j dk|d |||}|j |7_ d |_ t|dd|_|j|_|jd=|jd=|jd=|jd=dS)aFor assignment like lhs[idx] = rhs, where both lhs and rhs are arrays, do the following: 1. find the definition of rhs, which has to be a call to numba.unsafe.ndarray.empty_inferred 2. find the source array creation for lhs, insert an extra dimension of size of b. 3. replace the definition of rhs = numba.unsafe.ndarray.empty_inferred(...) with rhs = lhs[idx] fix_array_assignzfound SetItem: zfound lhs_def: zfound rhs_def: rrrz dim_def = csg|]}t|ddqS)T)r)r)r/r)r$r)r*r2msz?_fix_nested_array..fix_array_assign..z extra_dims = zsize_tuple_def = rT)rrDrjZvarargrx)rr>rrrArr;r@rrBrCrrjr:rZ_kws)rrRrWZlhs_defZrhs_defZdim_defZ extra_dimsZsize_tuple_def)rrr$r)r*rSs@          z+_fix_nested_array..fix_array_assignN) r9rrr{rJr rrr.rr)r$r[Z empty_deadmaprrSrTrr))r9rrr$rrr*rNs--   rNcCs|g|j|j<tj|||dS)N)rAr@r~)rrwrr?)r$rrAr~r)r)r*rsrzafter-inferencecs0eZdZdZfddZddZddZZS)RewriteArrayOfConstszThe RewriteArrayOfConsts class is responsible for finding 1D array creations from a constant list, and rewriting it into direct initialization of array elements without creating the list. cs$|j|_tt|j|f||dS)N)rsuperrr+)r(Zpipelinerjrx) __class__r)r*r+szRewriteArrayOfConsts.__init__cCs6t|dkrdS||_tt|||j|||_|jdkS)NrF)r- crnt_blockr_inline_const_arraycallrr)r(r$rTrrr)r)r*matchs  zRewriteArrayOfConsts.matchcCs|j|j_|jS)N)rrr.)r(r)r)r*applys zRewriteArrayOfConsts.apply)rrrrr+rr __classcell__r)r))rr*rs rc s>td|jfdd}Gdddt}|}x|jD]}t|tjr,t|jtjr|jj |j kr|j |j j |j |qDnt|jtjr |j} | jdkr|dd| jD|_|j j g|_ |j |qDn@| jd kr | kr |j } t||j | |j |j |jr d |_qDnt|tjr |j} | |jkr\|j |qDn| |j kr |j | |j | |j ||j gkr g} xX|j D]N}t|tjr|j j |jkst|tjr|j|jkrq| |qW| |_ g|_d |_qD|j |||rD|qDW|jr:|j Sd S) a|Look for array(list) call where list is a constant list created by build_list, and turn them into direct array creation and initialization, if the following conditions are met: 1. The build_list call immediate preceeds the array call; 2. The list variable is no longer live after array call; If any condition check fails, no modification will be made. Zinline_const_arraycallc stt|}t|o(|ddko(|ddkt|jdj|k|j}tt|tjo`|j dk|j }|jd}|j} d|d|| j } t |\} } t | } ttd|}ttd|}tj}t|d}||j<||j<|t|tj| |d ||t|tjj|g|d |t| }ttd |}ttj}||fd |i}||j<|t|tjd tj|d |ttd|}tjt|j<tdt|}|t|||ttd|}||j<t | }|dkrd}tj!|||}|t|||tjj"|||gi|d }t#$| |||<|t|||xt%| D]x}ttd|}tj}||j<|t|t|||t&||| ||}t#$tj'| || |<||q|W|(|dS)zCheck to see if the given "array_var" is created from a list of constants, and try to inline the list definition as array initialization. Extra statements produced with be appended to "stmts". r3rrrzinline array_var = z list_var = rr)r~)r:r~rrrz $np_g_varrz $np_typ_varboolZbool_rT))rrrrjrwZ return_typer>rZArrayCompatiblendimr~rrr-rrr ZintpZUniTuplerLrrrBrZDTyperrrZresolve_function_typervZmiscZModulerrr,r Z signaturerrZnoner) rrXr list_varsdelsZcallnameZret_typer~rZ array_typrseq_rrrZsize_typZsize_tuple_typZnptyperZfntyZsigZg_np_varZg_npZtyp_varZ dtype_strZnp_typ_getattrZ empty_callrUrZ index_typsetitem)rcontextrRr$rrr)r* inline_arraysp                      z-_inline_const_arraycall..inline_arrayc@s(eZdZdZddZddZddZdS) z&_inline_const_arraycall..Statez This class is used to hold the state in the following loop so as to make it easy to reset the state of the variables tracking the various statement kinds cSs(g|_g|_g|_g|_g|_d|_dS)NF)r dead_vars list_itemsrrrP)r(r)r)r*r+s z/_inline_const_arraycall..State.__init__cSsg|_g|_g|_g|_dS)zV Resets the internal state of the variables used for tracking N)rr r r)r(r)r)r*resetsz,_inline_const_arraycall..State.resetcstfdd|DS)z Returns True if the list being analysed is used between the build_list and the array call. csg|]}|jjkqSr))rwr)r/r)r(r)r*r2,szH_inline_const_arraycall..State.list_var_used..)anyr)r(rr))r(r* list_var_used'sz4_inline_const_arraycall..State.list_var_usedN)rrrrr+r rr)r)r)r*States rrcSsg|] }|jqSr))rw)r/rr)r)r*r2<sz+_inline_const_arraycall..r,TN)r;robjectr.r>rr?rArrwrrLr@rrBrCr r:r rrrPrr rr) rTr$rrrr rstaterrXZarr_varZ removed_varr.r))rrrRr$rrr*rsh\&                r)NNNNN)F)CrZpytypesrrrrrrrrrr Z numba.parforr Znumba.ir_utilsr r r rrrrrrrrrrrrrrrrZnumba.analysisrrr Znumba.targets.rangeobjr!Znumba.unsafe.ndarrayr"rrrrrHrr#rlrmr;rIrrrrrrrrMrrNrZregister_rewriteZRewriterrr)r)r)r*sF( T  /    2 n x