
    Ǆg4m                       d dl 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m
Z
mZmZmZmZmZ d dlmZ d dlmZmZmZ d dlmZmZmZmZ d dlZd ad Z G d d	      Z 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,d Z-d Z.d Z/i Z0d Z1d Z2d Z3i Z4d Z5i Z6d Z7d Z8d  Z9d! Z:	 	 dkd"Z;dkd#Z<i Z=d$ Z>g Z?d% Z@e?j                  e@       d& ZBg ZCd' ZDd( ZEi ZFi ZGd) ZH	 	 dld*ZId+ ZJd, ZKd- ZLd. ZMi ZNd/ ZOi ZP	 dmd0ZQd1 ZRdmd2ZSdmd3ZTi ZUdnd4ZVi ZWdmd5ZXd6 ZYd7 ZZd8 Z[g d9Z\d: Z]i Z^dmd;Z_d< Z`d= Zad> Zbd? Zc G d@ dAed      ZedB ZfdC ZgdD ZhdmdEZii ZjdehfdFZkdG ZldH Zm	 	 dodIZndJ ZodK ZpdL ZqdM ZrdN ZsdO ZtdP ZudQ ZvdR ZwdS ZxdT ZydU ZzdV Z{dW Z|dX Z}dY Z~dZ Zd[ Zd\ Zd] Zd^ Zd_ Zd` Zda ZdpdbZdc Zdd Zde Zdf Zdg Zdh Zdi Zdj Zy)q    N)
_Intrinsic)typestypingiranalysispostprocrewritesconfig)	signature)compute_live_mapcompute_use_defscompute_cfg_from_blocks)TypingErrorUnsupportedErrorNumbaPendingDeprecationWarningCompilerErrorc                 B    | dz   t        t              z   }t        dz   a|S )N.   )str_unique_var_count)prefixvars     [/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/numba/core/ir_utils.pymk_unique_varr      s&    
3,./
/C)A-J    c                        e Zd ZddZd Zd Zy)	_MaxLabelc                     || _         y N_value)selfvalues     r   __init__z_MaxLabel.__init__$   s	    r   c                 D    | xj                   dz  c_         | j                   S )Nr   r!   )r#   s    r   nextz_MaxLabel.next'   s    q{{r   c                 :    t        || j                        | _        y r    )maxr"   )r#   newvals     r   updatez_MaxLabel.update+   s    &$++.r   N)r   )__name__
__module____qualname__r%   r'   r+    r   r   r   r   #   s    /r   r   c                 <    d}	 | t        |      z   }||vr|S |dz  })zl Get a new var name with a given prefix and
        make sure it is unused in the given variable table.
    r   r   )r   )r   	var_tablecurr   s       r   get_unused_var_namer3   3   s5     C
s3xiJq	 r   c                  *    t         j                         S r    )_the_max_labelr'   r/   r   r   
next_labelr6   ?   s      r   c	                 N   g }	d}
t         j                  }t        |t              rt	        |      dk(  r|d   }t        |||||	      }nt	        |      }
t        j                  |t        d      |      }|r;t         j                  j                  t         j                  |
      ||j                  <   |D cg c]  }t        |||||	       }}t        j                  j                  ||      }t        j                  |||      }|	j                  |       |}t         j                  j                  t         j                  |
      }t!        |d      r|j#                  | ||||||||||	      S t        j                  |t        d      |      }|r0t         j$                  j'                  t(              ||j                  <   t        j*                  dt(        |      }t        j                  |||      }t        j                  j-                  |d|      }t        j                  |t        d      |      }|r&t/        t(        j0                        ||j                  <   t        j                  |||      }t3        |      }t        j                  |t        d	      |      }|r,t         j4                  j7                  |      ||j                  <   t        |t         j8                  t         j:                  f      r=|j<                  d
k7  r.t        j>                  ||      }t        j                  |||      }n?|dk(  rd}t        j                  j-                  |||      }t        j                  |||      }t        j                  jA                  |||gd|      }|rl||j                     jC                  | |t         j4                  j7                  |      gi       }|jD                  dk(  r|jG                  d      n||_$        |||<   |jD                  dk(  rc|jG                  d      }t        j                  |t        d      |      }|r|jG                  d      ||j                  <   t        j                  |||      } t        j                  j-                  |d|      }!t        j                  |t        d      |      }"|r&t/        t(        jJ                        ||"j                  <   t        j                  |!|"|      }#t        j                  jA                  |"|gd|      }$|r$||"j                     jC                  | |gi       ||$<   t        j                  |$||      }%|	jM                  |||| |#|%g       |	S t        j                  |||      }&|	jM                  ||||&g       |	S c c}w )zgenerate an array allocation with np.empty() and return list of nodes.
    size_var can be an int variable or tuple of int variables.
    lhs_typ is the type of the array being allocated.
    r   r   z
$tuple_var__allocate__	$np_g_varnpemptyz$empty_attr_attrz$np_typ_var boolbool_r/   FClayoutz$empty_c_varasfortranarrayz$asfortran_array_attr)'r   intp
isinstancetuplelenconvert_size_to_varr   Varr   
containersUniTuplenameExprbuild_tupleAssignappendhasattrr8   miscModulenumpyGlobalgetattrget_np_ufunc_typr;   r   	functionsNumberClass
NPDatetimeNPTimedeltaunitConstcallget_call_typerB   copy_return_typerC   extend)'	typingctxtypemap	calltypeslhssize_vardtypescopeloclhs_typoutndimssize_typ	tuple_vars	new_sizes
tuple_calltuple_assigng_np_varg_npg_np_assignempty_attr_callattr_varattr_assign	dtype_strtyp_vartypename_consttyp_var_assignnp_typ_getattr
alloc_callcacempty_c_typempty_c_varempty_c_assignasfortranarray_attr_callafa_attr_varafa_attr_assignasfortranarray_callasfortranarray_assignalloc_assigns'                                          r   mk_allocr   C   s    CEzzH(E"x=A{H*8WeS#NH MEumL&A3GI*/*:*:*C*CJJ+'	' #+, -QSI ,I ,,,Y<J99ZC@LJJ|$ H''00UCHw'##
 	
 vve];7=H!&!2!25!999T5#&D))D(C0Kggooh=Ovve]+=>DH!1%++!>))OXs;KE
IffUM-8#>G % ; ;E B 	55++U->->?@

bXXi5NYY~wDNfI9cB>7C@h7(;REJhmm$22%//"="=e"DErK  '~~4 $LLL4!( 	 !$	*~~ll#l.ffUM.$A3G(/C(@GK$$%:{C@ $&77??8=Ms#S vve]3J%KSQ)9%:N:N)OGL%%&))$<lCP ggll<+CP-4\5F5F-G-U-UK="..I)* !#		*=sC H

Knn#%:< 	= J yyS#6

KnlKLJw,s   5V"c                 X   t        | t              r}t        j                  |t	        d      |      }|rt
        j                  ||j                  <   t        j                  t        j                  | |      ||      }|j                  |       |S t        | t        j                        sJ | S )Nz$alloc_size)rE   intr   rI   r   r   rD   rL   rO   r]   rP   )rg   rd   ri   rj   nodesnew_sizesize_assigns          r   rH   rH      s    (C 66%}!=sC%*ZZGHMM"ii3 73G[!h'''Or   c                     t         j                  j                  j                  D ]  \  }}|| k(  s|c S  t         j                  j
                  j                  D ]  \  }}|| k(  s|c S  t        d| d      )z7get type of the incoming function from builtin registryztype for func z
 not found)r   npydeclregistryglobals	templatesbuiltin_registryRuntimeErrorfunckvs      r   rW   rW      sv    ..))11 A9H ""33;; A9H '|
<<r   c                    t        j                  |t        d      |      }t        t              | |j
                  <   t        j                  dt        |      }t        j                  |||      }	t        | |||||      \  }
}t         j                  j                  ||d|      }| |j
                     j                  t        j                         t        j                  gt!        |      z  i       ||<   t        j                  |t        d      |      }t        j"                  j%                  t        j                        | |j
                  <   t        j                  |||      }t         j                  j'                  ||      }t)        t        j*                  t        j,                        ||<   t        j                  |t        d      |      }t        j"                  j/                  t        j                        | |j
                  <   t        j                  |||      }t        j                  |t        d      |      }t        j"                  j/                  t        j                        | |j
                  <   t        j                  |||      }t        j0                  d|      }t        j2                  ||      }|
|	||||gz   |_        |S )zpmake a block that initializes loop range and iteration variables.
    target label in jump needs to be set.
    z$range_g_varranger/   z$range_c_varz	$iter_var$phi)r   rI   r   get_global_func_typr   rL   rU   rO   _mk_range_argsrM   r^   r_   r   Contextr   rD   rG   	iterators	RangeTypegetiterr   range_iter64_typerange_state64_typeRangeIteratorTypeJumpBlockbody)rd   startstopstepre   ri   rj   g_range_varg_rangeg_range_assign	arg_nodesargs
range_callrange_call_varrange_call_assign	iter_calliter_variter_call_assignphi_var
phi_assignjump_headerrange_blocks                         r   mk_range_blockr      s   
 &&n =sCK 3E :GKii,GYYwS9N$WeT4LOItk4S9J#K$4$45CC5::,T2B8Ij VVE=#@#FN#(??#<#<UZZ#HGN 		*ncB4I$U%<%<%*%=%=?Iivve];7=H"__>>uzzJGHMMyyHc:ffUM&137G!OO==ejjIGGLL8Wc2J''"c"K((5#&K N4E$4j+$O OKr   c                 D   g }t        |t        j                        r|}nt        |t              sJ t        j                  |t	        d      |      }| rt
        j                  | |j                  <   t        j                  t        j                  ||      ||      }|j                  |       |dk(  r
|dk(  r||gfS t        |t        j                        r|}	nt        |t              sJ t        j                  |t	        d      |      }	| rt
        j                  | |	j                  <   t        j                  t        j                  ||      |	|      }
|j                  |
       |dk(  r||	|gfS t        |t        j                        r|}nt        |t              sJ t        j                  |t	        d      |      }| rt
        j                  | |j                  <   t        j                  t        j                  ||      ||      }|j                  |       ||	||gfS )Nz$range_stopr   r   z$range_startz$range_step)rE   r   rI   r   r   r   rD   rL   rO   r]   rP   )rd   r   r   r   ri   rj   r   
g_stop_varstop_assigng_start_varstart_assign
g_step_varstep_assigns                r   r   r      s   E$
$$$$VVE=#?E
',zzGJOO$iis 3ZE[!zdaizl""% %%%%ffUM.$A3G(-

GK$$%yy%!5{CH\"qy{J///$
$$$$VVE=#?E
',zzGJOO$iis 3ZE[!;
J777r   c                     t         j                  j                  j                  D ]  \  }}|| k(  s|c S  t	        dj                  |             )z2get type variable for func() from builtin registryzfunc type not found {})r   r   r   r   r   formatr   s      r   r   r     sL    ""33;; A9H /66t<
==r   c                    t        j                  |t        d      |      }t        j                  j                  t        j                  t        j                        | |j                  <   t         j                  j                  ||      }t        t        j                  j                  t        j                  t        j                        t        j                        ||<   t        j                  |||      }t        j                  |t        d      |      }t        j                  | |j                  <   t         j                  j                  ||      }	t        j                  |	||      }
t        j                  |t        d      |      }t        j                  | |j                  <   t         j                  j                  ||      }t        j                  |||      }t        j                  |t        d      |      }t        j                  | |j                  <   t        j                  |||      }t        j                   |dd|      }t        j"                  ||      }||
|||g|_        |S )zqmake a block that is a loop header updating iteration variables.
    target labels in branch need to be set.
    z$iternext_varz$pair_first_varz$pair_second_varr   r   )r   rI   r   r   rJ   PairrD   booleanrL   rM   iternextr   r   rO   
pair_firstpair_secondBranchr   r   )rd   r   re   ri   rj   iternext_variternext_calliternext_assignpair_first_varpair_first_callpair_first_assignpair_second_varpair_second_callpair_second_assign	phi_b_varphi_b_assignbranchheader_blocks                     r   mk_loop_headerr   !  s   
 66%!?EL!&!1!1!6!6

EMM"#GLGG$$Wc2M(JJMM	 		 !Im
 ii|SAOVVE=1B#CSIN#(::GN gg((s;O		/>3GffUM2D$EsKO$)MMGO  !ww**<=#3_cJumF3S9I#jjGINN99^Y<LYYB4F88E3'L(*;+\6CLr   c                     i }| D ]?  }|j                  dd      j                  dd      j                  dd      }||vsJ |||<   A |S )zXreturns a dictionary for conversion of variable names to legal
    parameter names.
    ___$r   )replace)varnamesvar_mapr   new_names       r   legalize_namesr   F  s`     G  ;;sD)11#s;CCCMw&&&  Nr   c                 *    d }i }t        | ||       |S )z<create a mapping from variable names to their ir.Var objectsc                 $    | || j                   <   | S r    rL   )r   namevars     r   get_name_var_visitz.get_name_var_table.<locals>.get_name_var_visitT  s    
r   )
visit_vars)blocksr   r   s      r   get_name_var_tabler   R  s      Gv)73Nr   c                 n    i }|j                         D ]  \  }}||k7  s|||<    d }t        | ||       y)zCreplace variables (ir.Var to ir.Var) from dictionary (name -> name)c                     t        | t        j                        sJ | j                  |v rGt        j                  | j                  || j                     | j
                        } | j                  |v rG| S r    )rE   r   rI   rL   ri   rj   )r   namedicts     r   replace_namez'replace_var_names.<locals>.replace_named  sX    #rvv&&&hh("&&HSXX$6@C hh("
r   N)itemsr   )r   r   new_namedictlrr   s         r   replace_var_namesr   \  sF     L   16LO 
 v|\2r   c                    t        | t        j                        sJ | j                  |j	                         v r|| j                     j                  | j                  k7  sJ || j                     }t        j                  |j
                  |j                  |j                        } | j                  |j	                         v r| S r    )rE   r   rI   rL   keysri   rj   )r   vardictnew_vars      r   replace_var_callbackr   l  s    c266"""
((glln
$sxx %%121#((#ffW]]GLL'++> ((glln
$ Jr   c                     i }|j                         D ]  \  }}||j                  k7  s|||<    t        | t        |       y)zEreplace variables (ir.Var to ir.Var) from dictionary (name -> ir.Var)N)r   rL   r   r   )r   r   new_vardictr   r   s        r   replace_varsr   u  sE     K 1;KN v+[9r   c                 &    t        | t        |       y r    )visit_vars_stmtr   )stmtr   s     r   replace_vars_stmtr    s    D.8r   c                 $    t        | t        |      S r    )visit_vars_innerr   )noder   s     r   replace_vars_innerr    s    D"6@@r   c                 j    | j                         D ]   }|j                  D ]  }t        |||        " y)zWgo over statements of block bodies and replace variable names with
    dictionary.
    N)valuesr   r   )r   callbackcbdatablockr   s        r   r   r     s=      4JJ 	4DD(F3	44 r   c                 |   t         j                         D ]  \  }}t        | |      s || ||        y  t        | t        j                        r9t        | j                  ||      | _        t        | j                  ||      | _        y t        | t        j                        rt        | j                  ||      | _	        y t        | t        j                        rt        | j                  ||      | _        y t        | t        j                        rt        | j                  ||      | _        y t        | t        j                        rt        | j                  ||      | _        y t        | t        j                        rt        | j                  ||      | _        y t        | t        j                         rJt        j"                  d | j                  | j$                        }t        |||      }|j                  | _        y t        | t        j&                        r9t        | j                  ||      | _        t        | j(                  ||      | _        y t        | t        j*                        rUt        | j                  ||      | _        t        | j(                  ||      | _        t        | j                  ||      | _        y t        | t        j,                        r9t        | j                  ||      | _        t        | j.                  ||      | _        y t        | t        j0                        rUt        | j                  ||      | _        t        | j2                  ||      | _        t        | j                  ||      | _        y t        | t        j4                        rUt        | j                  ||      | _        t        | j.                  ||      | _        t        | j                  ||      | _        y t        | t        j6                        r+| j8                  D cg c]  }t        |||       c}| _        y 	 y c c}w r    )visit_vars_extensionsr   rE   r   rO   r  targetr$   ArgrL   ReturnRaise	exceptionr   condr   DelrI   rj   DelAttrattrSetAttrDelItemindexStaticSetItem	index_varSetItemPrintr   )r   r  r	  tfr   xs          r   r   r     sF   %++- 1dAdHf% $		"&t{{HfE%djj(FC
P O 
D"&&	!$TYY&A	L K 
D"))	$%djj(FC
H G 
D"((	#)$..(FKD C 
D"))	$$TYY&A	@ ? 
D"''	"&t{{HfE< ; 
D"&&	! ffT4::txx0sHf5XX
0 / 
D"**	%&t{{HfE$TYY&A	* ) 
D"**	%&t{{HfE$TYY&A	%djj(FC
" ! 
D"**	%&t{{HfE%djj(FC
  
D"**	+&t{{HfE)$..(FK%djj(FC
  
D"**	%&t{{HfE%djj(FC
%djj(FC
  
D"((	#DHIINq%a6:N	  	
	 Os   P9c           
      N   t        | t        j                        r	 || |      S t        | t              r| D cg c]  }t	        |||       c}S t        | t
              r$t        | D cg c]  }t	        |||       c}      S t        | t        j                        rH| j                  j                         D ])  }t	        | j                  |   ||      | j                  |<   + | S t        | t        j                        rt	        | j                  ||      | _
        | S c c}w c c}w r    )rE   r   rI   listr  rF   rM   _kwsr   Yieldr$   )r  r  r	  nargs        r   r  r    s    $f%%	D$	?CD! Hf5DD	D%	 TJ&q(F;JKK	D"''	" 99>># 	PC-diinhODIIcN	P K 
D"((	#%djj(FC
K EJs   D(D"c                    i }| j                         D ]/  \  }}d}|j                  rR|j                  d   }|j                  D ]4  }t        j                         D ]  \  }}t        ||      s |||      }	 6 t        |t        j
                        r:t	        j
                  |j                  |z   |j                        |j                  d<   t        |t        j                        rSt	        j                  |j                  |j                  |z   |j                  |z   |j                        |j                  d<   ||||z   <   2 |S )z>add an offset to all block labels and jump/branch targets
    Nr   )r   r   add_offset_to_labels_extensionsrE   r   r   r  rj   r   r  truebrfalsebr)
r   offset
new_blocksr   bterminstTr  f_maxs
             r   add_offset_to_labelsr1    s    J #16666":D 0;AAC 0DAq!$* !$00 dBGG$v!5txx@AFF2JdBII&499dkkF.B#'<<&#8$((DAFF2J!"
1v:# r   c                    d}| j                         D ]t  \  }}d }|j                  rY|j                  d   }|j                  D ];  }t        j                         D ]"  \  }}t        ||      s ||      }||kD  s!|}$ = ||kD  ss|}v |S )Nr   r   )r   r   find_max_label_extensionsrE   )	r   	max_labelr   r,  r-  r.  r/  r  r0  s	            r   find_max_labelr5    s    I 16666":D .5;;= .DAq!$* !$ 9,(-I	.. y=I r   c                 n   t        | t        |       dz         } i }t        |       }t               }d}|D ]  }|||<   |dz  } |D ]  }| |   }d}|j                  r|j                  d   }t        |t        j                        r:t        j                  ||j                     |j                        |j                  d<   t        |t        j                        rSt        j                  |j                  ||j                     ||j                     |j                        |j                  d<   ||||   <    |S )zFmakes the labels in range(0, len(blocks)), useful to compare CFGs
    r   r   Nr   )r1  r5  find_topo_orderdictr   rE   r   r   r  rj   r   r  r(  r)  )	r   r+  
topo_orderl_mapidxr  t_noder,  r-  s	            r   flatten_labelsr=  
  s    "&.*@1*DEFJ (JFE
C aq  &6N6666":DdBGG$t{{!3TXX>AFF2JdBII&499eDKK.@#(#6BAFF2J$%
5=!& r   c                     | j                         D ]H  }g }|j                  D ].  }t        |t        j                        r|j                  |       0 ||_        J y)zremove ir.Del nodesN)r  r   rE   r   r  rP   r   r
  new_bodyr   s       r   remove_delsrA  '  sW     JJ 	&DdBFF+%	& 
 r   c                    | j                         D ]l  }g }|j                  D ]R  }t        |t        j                        r%t        |j
                  t        j                        rB|j                  |       T ||_        n y)zremove ir.Arg nodesN)r  r   rE   r   rO   r$   r  rP   r?  s       r   remove_argsrC  2  sk     JJ 	"D$		*z$**bff/MOOD!	" 
 r   c                     d}t        | j                  | j                  | |||      r'd}t        | j                  | j                  | |||      r'|r&t        j                  |       }|j                          yy)zS Performs dead code elimination and leaves the IR in a valid state on
    exit
    FTN)remove_deadr   	arg_namesr   PostProcessorrun)func_irrd   	alias_maparg_aliasesdo_post_proc	post_procs         r   dead_code_eliminationrN  >  sq    
 Lw~~w'8'8'7 +/ w~~w'8'8'7 +/ **73	 r   c                 ^   t        |       }t        |       }t        || |j                  |j                        }t        |       \  }	}
||t        | |||      \  }}t        j                  dk\  r\t        d|       t        d|       t        d|       t        d|       t        d|j                         t        d|j                         t        |j                               }d}| j                         D ]  \  }}|j                  j                         D ch c]  }|j                   }}t        j                  d	k\  rt        d
||       |j!                  |      D ]0  \  }}t        j                  d	k\  rt        d|||          |||   z  }2 |t#        |||	|||||      z  } |S c c}w )zdead code elimination using liveness and CFG info.
    Returns True if something has been removed, or False if nothing is removed.
    r   zargs:z
alias map:zarg_aliases:z	live_map:zusemap:zdefmap:F   zremove_dead processing blockzsucc live_map)r   r   r   usemapdefmapget_call_tablefind_potential_aliasesr
   DEBUG_ARRAY_OPTprintsetr   r   
terminator	list_varsrL   
successorsremove_dead_block)r   r   rI  rd   rJ  rK  cfgusedefslive_map
call_tabler   	alias_setremovedlabelr
  r   livesout_blk_datas                      r   rE  rE  M  s    "&
)Cv&GVW^^W^^LH"6*MJK/!7g8?"A	;"gtlI&nk*k8$i(i(INN$%IG Mu!&!1!1!;!;!=>A>>!!Q&0%?!nnU3 	'NGU%%*ow0ABXg&&E	' 	$UE:{%.	7GM 	MM N ?s   F*c           
         d}| j                   g}	t        | j                  dd       D ];  }
t        j                  dk\  rt        d|
       t               }||z  }|D ]
  }|||   z  } ||z  |z  }t        |
      t        v rCt        t        |
         } ||
||||||      }
|
!t        j                  dk\  rt        d       d}t        |
t        j                        r|
j                  }|
j                  }|j                  |vr/t        |||      r"t        j                  dk\  rt        d       d}t        |t        j                         r;|j                  |j                  k(  r"t        j                  dk\  rt        d       d}at        |
t        j"                        r0|
j                  |vr"t        j                  dk\  rt        d       d}t        |
t        j$                        r:|
j                  j                  }||vr t        j                  dk\  rt        d       t        |
      t&        j(                  v r2t&        j(                  t        |
         } ||
      \  }}||z  }||z  }n||
j+                         D ch c]  }|j                   c}z  }t        |
t        j                        rt        |
j                  t        j,                        r[|
j                  j+                         D ch c]  }|j                   }}j                  |vr7|j/                  |j                         n|j/                  j                         |	j1                  |
       > |	j3                          |	| _        |S c c}w c c}w )zremove dead code using liveness info.
    Mutable arguments (e.g. arrays) that are not definitely assigned are live
    after return of function.
    FNr   rP  r[  zStatement was removed.T)rX  reversedr   r
   rU  rV  rW  typeremove_dead_extensionsrE   r   rO   r  r$   rL   has_no_side_effectrI   r  r  r   ir_extension_usedefsrY  rM   removerP   reverse)r
  rc  r_  rK  rJ  r`  rI  rd   ra  r@  r   alias_livesinit_alias_livesr   lives_n_aliasesr  rf   rhsrL   def_funcusesdefsrhs_varss                          r   r[  r[  x  s    G   !HCR) D!!Q&%t,e 9,! 	(A9Q<'K	(+-; ://&tDz2AT5/;	7D|))Q.23 dBII&++C**Cxxu$);**6))Q.23#rvv&388sxx+?))Q.23 dBFF#zz&))Q.23dBJJ';;##D?*))Q.23:66644T$Z@H!$JD$TMETMEdnn&67aff77E$		*djj"''204

0D0D0FG1GHGxxx/SXX.LL*IDJ EJN 8  Hs   N 9Nc                 J    t        |      dk(  r|dd  dt        gk(  r|d   dvS y)N   r   randomr   >   seedshuffleF)rG   rT   )rq  rc  	call_lists      r   remove_dead_random_callr|    s3    
9~y}50AA|#666r   c                    ddl m}m} ddlm} t        | t        j                        rJ| j                  dk(  r:| j                  j                  }||vs||   g k(  ry||   }|dt        gk(  s|t        gk(  s||dt        gk(  sq|dt        gk(  sf|d	t        gk(  s[||j                  gk(  sK||gk(  sE|d
t        gk(  s:|dt        gk(  s/||j                  gk(  s|dt         gk(  s|t"        gk(  s
|t$        gk(  ryt        |d   t&              r%|d   j(                  dk(  s|d   j(                  dk(  ryddlm} ddlm}	 t        |d   |      r|d   j2                  }
|
|	k(  ryt4        D ]  } || ||      s y yt        | t        j                        r'| j                  dk(  r| j6                  j                  |vS t        | t        j8                        ryt        | t        j                        r| j                  dk(  ryy)za Returns True if this expression has no side effects that
        would prevent re-ordering.
    r   )array_analysisparfor)pranger^   Fr;   stencillogrh   r  pndindexceilTempty_inferredunsafe_empty_inferred)CPUDispatcher)dot_3_mv_check_argsinplace_binopr   )numba.parforsr~  r  numba.misc.specialr  rE   r   rM   opr   rL   rT   slicenumba
wrap_indexinternal_prangemathr)   r   r   _namenumba.core.registryr  numba.np.linalgr  py_funcremove_call_handlersrf   r#  )rq  rc  r_  r~  r  r  	func_namer{  r  r  r  r  s               r   rj  rj    s    5)#rwwCFFf$4HHMM	J&*Y*?2*Ey)	'5))% )U++%''5)).3344&!(E***e,,&0011&$'##1z2|!!%55|!!%<<57ilM2l**G--% 	AeY'	 #rwwCFFo$=ww||5((#rxx #rwwCFFl$:r   c                    t        | t        j                        r| j                  dk(  r| j                  j
                  }||vs||   g k(  ry||   }|t        gk(  s5|dt        gk(  s*|dt        gk(  s|dt        gk(  s|t        gk(  s
|t        gk(  ryt        D ]  } || ||      s y y| j                  dk(  s| j                  dk(  ryt        | t        j                        ryy)	z Returns True if every time this expression is evaluated it
        returns the same result.  This is not the case for things
        like calls to numpy.random.
    r^   Fr  r;   r  Tr   r   )rE   r   rM   r  r   rL   r  rT   r  r)   r   is_pure_extensionsr#  )rq  rc  r_  r  r{  r  s         r   is_purer  
  s    
 #rww66VI
*j.Cr.I"9-IeW$eU^+gu--fd^+cU"cU"'  S%+  VVy CFFj$8#rxx r   c                     | dk(  r|dv ryy)NrT   )r;   TFr/   )module_namer  s     r   is_const_callr  &  s    g	!r   c                 F    | |vr| S t        t        ||                }|d   S )Nr   )sortedr!  )r   rJ  	v_aliasess      r   get_canonical_aliasr  0  s,    	tIaL)*IQ<r   c           
      ^   |i }|t        fd|D              }t        |j                        |_        g d}| j	                         D ]  }|j
                  D ]  }t        |      t        v rt        t        |         }	 |	|||||       t        |t        j                        sO|j                  }
|j                  j                  }t        |      r~t        |
t        j                        r'||
j                  k7  rt!        ||
j                  ||       t        |
t        j"                        r?|
j$                  dk(  s|
j$                  dv r"t!        ||
j                  j                  ||       t        |
t        j"                        r1|
j$                  dk(  r"t!        ||
j&                  j                  ||       t        |
t        j"                        r?|
j$                  dk(  r0|
j(                  dv r"t!        ||
j                  j                  ||       t        |
t        j"                        rW|
j$                  dk(  rH|
j(                  dvr:|
j                  j                  |v r"t!        ||
j                  j                  ||       t        |
t        j"                        sI|
j$                  d	k(  sZt+        t,        ||
      }|p|\  }}|t.        v rt.        |   } |||
j0                  ||       |d
k(  r)||v r%t!        ||
j0                  d   j                  ||       t        |t        j                        s||v st!        ||j                  ||         t3        j4                  |      }|D ].  }||   D ]  }||xx   ||   z  cc<    ||   D ]
  }||   ||<    0 ||fS )zCfind all array aliases and argument aliases to avoid remove as deadc              3   <   K   | ]  }t        |      r|  y wr    )is_immutable_type).0ard   s     r   	<genexpr>z)find_potential_aliases.<locals>.<genexpr>=  s     O1B1g1N!Os   )ravel	transposereshapecastgetitemstatic_getitemr  rV   )r/  ctypesflat)shaper^   rT   r   )rW  build_definitionsr   _definitionsr  r   rh  alias_analysis_extensionsrE   r   rO   r$   r  rL   r  rI   
_add_aliasrM   r  rf   r  guardfind_callnamealias_func_extensionsr   r`   deepcopy)r   r   rd   rI  rJ  rK  np_alias_funcsblinstrr  exprrf   fdeffnamefmod
alias_funcold_alias_mapr   ws     `                r   rT  rT  7  s    	OTOO -W^^<G6Nmmo ,KWW +	KEE{77-d5k:%wKH%+{{ll''$S'2dBFF+TYYsDIIy+FtRWW-477f3DGG<<sDJJOOYLdBGG,O1KsDHHMM9kJtRWW-$''Y2F II)@@sDJJOOYLtRWW-$''Y2F IIY6 JJOO{:sDJJOOYLdBGG,F1B wGD
 | "&KE444%:4%@
"3		9kJw5N+B"3		!(9(99kR!$/E^4K"3		9kJW+	K,K^ MM),M (q! 	)AaLIaL(L	)q! 	(A$Q<IaL	(( k!!r   c                     ||v r|j                  |        y ||vrt               ||<   | |vrt               || <   ||   j                  |        ||    j                  |       y r    )addrW  )rf   rq  rJ  rK  s       r   r  r  }  sj    
k  i UIcNi UIcN#3#3
r   c                     || |vry||    }t        |t        j                  t        j                  j                  t        j
                  j                  f      ry|t        j                  k(  ryy)NFT)rE   r   Numberscalars_NPDatetimeBaser   r   string)r   rd   typs      r   r  r    s]    #W,
#,C#emm&C&C113 4
ELLr   c                 *   t        |       }|j                         }t        | ||      }|\  }}}}}	d}
t        j                  |	      }|
|k7  r| j                         D ]o  }||k(  r	|j                  |      D cg c]  \  }}|	 }}}|	|d      j                         ||<   |D ]  }||xx   |	|   z  cc<    ||   ||   ||   z
  z  |	|<   q |}
t        j                  |	      }|
|k7  rt        j                  dk\  rt        d|	       ||	fS c c}}w )zcompute copy propagation information for each block using fixed-point
     iteration on data flow equations:
     in_b = intersect(predec(B))
     out_b = gen_b | (in_b - kill_b)
    Nr   r   zcopy propagate out_copies:)
r   entry_pointinit_copy_propagate_datar`   r  r   predecessorsr
   rU  rV  )r   rd   r\  entryc_data
gen_copies
all_copieskill_copies	in_copies
out_copies	old_point	new_pointrb  i_dpredecsps                    r   copy_propagater    sJ    "&
)COOE &feW=FCI@Z[)ZIj)I
y
 [[] 	LE~&)&6&6u&=>UQq>G>)'!*5::<Ie 2% JqM1 2 ",E!2$-e$4{57I$I"KJu	L 	MM*-	 y
  "*J7j   ?s   :Dc                    t        | |      \  }}t               }|j                         D ]  \  }}|||   z  } i }|j                         D ]z  \  }	}
t               ||	<   |D ]c  \  }}|||	   v s|||	   v r||	   j                  ||f       |
D ch c]  \  }}|	 }}}f|
vsE||v s||v sN||	   j                  ||f       e | | j	                         D ci c]  }||j                          }}t               ||<   i }| j	                         D ]  }	||	   ||	   ||	   z
  z  ||	<    ||   ||<   |||||fS c c}}w c c}w )zHget initial condition of copy propagation data flow for each block.
    )get_block_copiesrW  r   r  r   r`   )r   r  rd   r  
extra_killr  r   rp   r  rb  gen_setrf   rq  assignedr  r  s                   r   r  r    s   
 .fg>J
J  " $1jm#
$K$**, 
3w UE" 	3HCj''3*U2C+CE"&&Sz2 -44S4H4c
')C8OE"&&Sz2	3
3 06{{}=!JOO%%=I=uIeJ H'. )% 0;u3E EG
5H #5)Ju
KJGG 5 >s   D<
Ec                    i }i }| j                         D ]W  \  }}i }t               ||<   |j                  D ]  }t        j                         D ]|  \  }}	t	        ||      s |	||      \  }
}|
D ]
  \  }}|||<    i }|j                         D ]+  \  }}||vr	||vr|||<   ||v s||   j                  |       - |}||xx   |z  cc<   ~ t	        |t        j                        s|j                  j                  }t	        |j                  t        j                        r-|j                  j                  }||   ||   k(  r||k7  r|||<   t	        |j                  t        j                        r|j                  j                  dk(  r|j                  j                  j                  }||   }t	        |t        j                         sl|t        j"                  k(  sY||   j                  |       i }|j                         D ].  \  }}||k7  r
||k7  r|||<   ||k(  s||   j                  |       0 |}||   j                  |        t        |j                               }|||<   Z ||fS )z2get copies generated and killed by each block
    r  )r   rW  r   copy_propagate_extensionsrE   r  r   rO   r  rL   r$   rI   rM   r  rf   r   r  r  )r   rd   block_copiesr  rb  r
  assign_dictr   r/  r  r  kill_setrf   rq  new_assign_dictr   r   in1_varin1_typ	block_cpss                       r   r  r    sz    LJ 2(uE
5JJ ,	+D1779 21dA&()$(8%GX$+ /S+.C(/ ')O + 1 1 3 51H,(1B12OA.=&u-11!4	5
 #2Ku%1%2 $		*kk&&djj"&&1**//C s|ws|3s
+.C( djj gg'+/::==O+K"jjnn11G%g.G&w=&%,,6"5)--g6*,$/$5$5$7 9DAq G|W56 2 G| *5 1 5 5a 8	9
 '65!%%c*Y,	+Z ))+,	'Ue2(f ##r   c           
      j   |g }| j                         D ]  \  }}||   D 	ci c]  \  }}	|||	    }
}}	|j                  D ]  }t        |      t        v r t        t        |         } |||
||||       nBt	        |t
        j                        rt        |j                  |
      |_        nt        ||
       t        |||       t        j                         D ]  \  }}t	        ||      s |||      \  }}|D ]  \  }}||v s||   |
|<    |
j                         j                         D ])  \  }}	||v s|	j                  |v s|
j                  |       +  t	        |t
        j                        rt	        |j                  t
        j                        r|j                   j                  }|j                  j                  }||k7  r~||   ||   k(  r||v r	||   |
|<   n|
j                  |d       g }|
j                         D ]&  \  }}|j                  |k(  s|j#                  |       ( |D ]  }|
j                  |d        t	        |t
        j                        s#t	        |j                  t
        j                        rI|j                   j                  }|
j                  |d       g }|
j                         D ]&  \  }}|j                  |k(  s|j#                  |       ( |D ]  }|
j                  |d         |j%                  |
j                                 |S c c}	}w )zEapply copy propagation to IR: replace variables when copies availableN)r   r   rh  apply_copy_propagate_extensionsrE   r   rO   r  r$   r  fix_setitem_typer  r`   rL   poprI   r  rP   rb   )r   r  name_var_tablerd   re   save_copiesrb  r
  r   r   var_dictr   r  r/  r  r  rf   rq  lhs_killr   r   s                        r   apply_copy_propagater  $  s     5-u5>u5EFTQA~a((FFJJ 1	*DDz<<3DJ?$.Y5 D")),/

HE
!$1T7I61779 ,1dA&()$(8%GX$+ @S.0,:3,?HSM@ !) 5 5 7 ,1=AFFh,>$LLO,, $		*z$**bff/Mkk&&jjoo#: s|ws|3~8M(6s(; S$/!H ( 0 /166S=$OOA./ & . Q-.4+0:4::rvv0Nkk&&S$'$NN, +DAqvv} *+ " *ALLD)*a1	*d 	8>>+,k5-n m Gs   L/c                    t        | t        j                  t        j                  f      sy|| j                  j
                     }||    j                  d   }t        |t        j                  j                        r$t        |t        j                  j                        sy|j                  dk(  rX|j                  dk7  rI|j                  |j                        }|||    j                  d   ||    j                  d   f||    _        y)zCopy propagation can replace setitem target variable, which can be array
    with 'A' layout. The replaced variable can be 'C' or 'F', so we update
    setitem call type reflect this (from matrix power test)
    Nr   ArA   r   rP  )rE   r   r  r  r  rL   r   r   npytypesArrayrB   r`   )r   rd   re   t_typs_typ	new_s_typs         r   r  r  f  s    
 dRZZ)9)9:;DKK$$%EdO  #ENN  ")3NN  *" 	||su||s2JJellJ3	dO  #dO  # %	$ r   c                    t         j                  dk\  rt| j                  }|dk(  r|n|| _        | j                  j                  }t        d|d|j                  dd             | j                          t        d       || _        yy)zqDebug print function IR, with an optional blocks argument
    that may differ from the IR's original blocks.
    r   NzIR z: P   -z(----------------------------------------)r
   rU  r   func_idfunc_qualnamerV  centerdump)rI  titler   	ir_blocksrL   s        r   dprint_func_irr    so     "NN	&,n&,,eT*222s;<h" #r   c                      t               g t                fd j                                j                          S )z{find topological order of blocks such that true branches are visited
    first (e.g. for_break test in test_dataflow).
    c                 :   | vrj                  |        j                  |    }|    j                  d   }t        |t        j
                        r|j                  |j                  g}|D ]  }| |fj                  vs |        j                  |        y y )Nr   )
r  _succsr   rE   r   r   r)  r(  _back_edgesrP   )	r  succs	last_instdest_dfs_recr   r\  
post_orderseens	       r   r  z!find_topo_order.<locals>._dfs_rec  s    tHHTNJJt$Et))"-I)RYY/"**I,<,<= #$<s6TN# d# r   )r   rW  r  rm  )r   r\  r  r  r  s   ``@@@r   r7  r7    sM     {%f-J5D
$ 
$ S__r   c                    |i }|i }|rt        |       }nt        | j                               }t        |      D ]  }t        | |   j                        D ]  }t        |t        j                        r@|j                  j                  }|j                  }t        |t        j                        r(|j                  dk(  rg ||j                  j                  <   t        |t        j                        r|j                  dk(  r{||v r7||   j                  |j                         |||j                  j                  <   ||v r<||   }	||	   j                  |j                         |	||j                  j                  <   t        |t        j                         rI||v r||   j                  |j                         ||v r#||   }	||	   j                  |j                         t        |t        j"                        rI||v r||   j                  |j                         ||v r#||   }	||	   j                  |j                         t        |t        j$                        rX||v r-||   j                  |j                         |||j                  <   ||v r#||   }	||	   j                  |j                         t&        j)                         D ]  \  }
}t        ||
      s ||||          ||fS )zAreturns a dictionary of call variables and their references.
    r^   rV   )r7  r!  r   rg  r   rE   r   rO   r  rL   r$   rM   r  r   rP   r  rU   FreeVarrI   call_table_extensionsr   )r   r_  reverse_call_tabletopological_orderingorderrb  r.  rf   rq  call_varr/  r  s               r   rS  rS    s   
 
!'V[[]#% $<VE]//0 #	<D$		*kk&&jjc277+&0@02Jsxx}}-c277+)0Cj("3..sxx8=@*399>>:00#5c#:"8,33CHH==E*399>>:c299-j("3..syy900#5c#:"8,33CII>c2::.j("3..syy900#5c#:"8,33CII>c266*j("3..sxx87:*388400#5c#:"8,33CHH=-335 <1dA&dJ(:;<C#	<$<J )))r   c                 ,   |i }| j                         D ]  }|j                  D ]  }t        |t        j                        r|j
                  j                  }|j                  }t        |t        j                        r|j                  dk(  r|j                  ||<   t        |t        j                        r)t        |j                  t              r|j                  ||<   t        j                         D ]  \  }}t        ||      s |||          |S )z>returns a dictionary of tuple variables and their values.
    rN   )r  r   rE   r   rO   r  rL   r$   rM   r  r   r]   rF   tuple_table_extensions)r   tuple_tabler
  r.  rf   rq  r/  r  s           r   get_tuple_tabler    s      )JJ 
	)D$		*kk&&jjc277+-0G'*yyK$c288,CIIu1M'*yyK$.446 )1dA&dK()
	)) r   c                     t               }t        | t        j                  t        j                  t        j
                  f      r%|j                  | j                  j                         |S r    )	rW  rE   r   rO   r  r  r  r  rL   )r   writess     r   get_stmt_writesr    sC    UF$BJJ0@0@AB

4;;##$Mr   c                    t        |       }d}| j                         D ]/  \  }}t        |j                  d   t        j
                        s.|}1 |dk7  r"|j                  |       |j                  |       i }t        |d      }|D ]  }|j                         ||<    | j                         D ]  }|j                  }t        |t        j                        r||j                     |_        t        |t        j                        sX||j                     |_        ||j                      |_         i }	| j                         D ]  \  }
}||
   }||	|<    |	S )zrename labels of function body blocks according to topological sort.
    The set of labels of these blocks will remain unchanged.
    r   T)rm  )r7  r   rE   r   r   r  rl  rP   r  r  r  rX  r   r  r   r(  r)  )r   r9  return_labelr   r,  	label_map
all_labelsrb  r-  r+  r   	new_labels               r   rename_labelsr#    sG    !(J L 1affRj")),L r,','I
D1J ,%>>+	%, ]]_ 3||dBGG$#DKK0DKdBII&#DKK0DK$T\\2DL3 J "1aL	 !
9" r   c                     t               } fd}t        t        | j                                     }t	               }|D ]  } |   j
                  d   }|j                  |      }d}|D ]V  \  }	}
 |	   }t        |j
                  d   t        j                        r#t        j                  |      |j
                  d<   Ud}X |s|j                  |        |D ]  } |=  t                t               S )z@transform chains of blocks that have no loop into a single blockc                     |    }t        |j                        dk(  xr' t        |j                  d   t        j                        S Nr   r   )rG   r   rE   r   r   )rb  r
  r   s     r   find_single_branchz(simplify_CFG.<locals>.find_single_branch-  s7    u5::!#L
5::a="))(LLr   r   Tr   F)r   r!  filterr   rW  r   r  rE   r   r   r`   r  merge_adjacent_blocksr#  )r   r\  r'  single_branch_blocksmarked_for_delrb  r.  r  delete_blockr  qr
  s   `           r   simplify_CFGr.  )  s     "&
)CM  '96;;= IJUN% &e}!!!$''." 	%FQ1IE%**R."''2!%4

2$	% u%&   5M&!  r   )minr)   sumprodmeanr   stdcumsumcumprodargmaxargminargsortnonzeror  c           	      x   | j                   }i }t        |      }|D ]  }||   }g }	|j                  D ]  }
t        |
t        j
                        rt        |
j                  t        j                        r|
j                  j                  }|
j                  }|j                  dk(  rs|j                  t        v r`t        ||j                  j                     t        j                  j                        r$|
j                  }|j                  }|||<   |j                   }|j"                  }t	        j$                  |t'        d      |      }t        j(                  j+                  t,              ||j                  <   t	        j.                  dt,        |      }t	        j
                  |||      }||_        |	j1                  |       |g| j2                  |j                  <   t5        t,        |j                        }t7        |      }|j9                  |       |||<   |j                  dk(  r|j:                  j                  |v r||j:                  j                     }|j9                  |      }|j<                  d t?        |j<                         }|j@                  D ci c]  \  }}|||j                      }}}||j:                  j                     jC                  |||j                     gtE        |      z   |      ||<   |g|j<                  z   |_        |	j1                  |
        |	|_         y c c}}w )NrV   r9   r:   r^   )#r   r7  r   rE   r   rO   r$   rM   r  rL   r  r  arr_mathr   r  r  ri   rj   rI   r   rR   rS   rT   rU   rP   r  rV   rW   r  r   r   rG   kwsr_   r!  )rI  rd   re   rc   r   saved_arr_argr9  rb  r
  r@  r   rf   rq  arrri   rj   rt   ru   rv   r   func_typold_sigargtypsrL   r   kwtypss                             r   canonicalize_array_mathrC  J  s    ^^FM (J +uJJ '	"D$		*z$**bgg/Nkk&&jjFFi'CHH,@&#CIINN3U^^5I5IK**C))C),M#&IIE''C!vve];-GMH-2ZZ->->u-EGHMM*99T5#6D"$))D(C"@K (CIOOK0;?&G((7"5#((3D/5HKK$#+GCL66V#(F'6C'mmC0G &ll>CM:GCF77KadGAFFO3KFK%,SXX]]%;%I%I!GCHH$5#6g#F&PIcN #usxx/CHOOD!O'	"P 
W+X  Ls   L6
c                 j   |
t               }| j                         D ]  }|j                  D ]  }t        |t        j
                        r;|j                  |j                  j                  |j                  j                  f       t        |t        j                        r;|j                  |j                  j                  |j                  j                  f       t        |t        j                        r|j                  j                  }|j                  }t        |t        j                        rJ|j                  dk(  r;|j                  |j                  j                  |j                  j                  f       t        |t        j                        re|j                  dk(  rV|j                  }|t!        |      r|j                  j                  }|j                  |j                  j                  |f       t"        j%                         D ]  \  }}t        ||      s |||          |S )z8returns a set of arrays accessed and their indices.
    r  r  )rW  r  r   rE   r   r  r  r  rL   r  r  r  rO   r$   rM   r  is_slice_indexarray_accesses_extensionsr   )	r   accessesr
  r.  rf   rq  r  r/  r  s	            r   get_array_accessesrH    s    5 &JJ 	&D$

+dkk..

@A$ 0 01dkk..0C0CDE$		*kk&&jjc277+)0CLL#))..#))..!ABc277+:J0JIIE}u(= # 2 2LL#))..%!891779 &1dA&dH%&!	&&( Or   c                 x    t        | t              ryt        | t              r| D ]  }t        |t              s y y)z0see if index is a slice index or has slice in itTF)rE   r  rF   )r  r  s     r   rE  rE    s:    %% 	A!U#	 r   c                 0   t        |       }t               }t        | j                               D ]  }||v r| |   }t        |j	                  |            }	 t        |      dk7  r7|d   d   }||v rDt        |j                  |            }t        |j	                  |            }t        |      dk7  s|d   d   |k7  r| |   }|j                  j                          |xj                  |j                  z  c_        | |= |j                  |       |} y r&  )
r   rW  r!  r   rZ  rG   r  r   r  r  )	r   r\  ra  rb  r
  r
  r6   preds
next_blocks	            r   r)  r)    s   
!&
)CeGfkkm$ GuS^^E*+5zQq!JW$))*56E
34E5zQ%(1+"6
+J JJNNJJ*//)Jz"KK
#E+ r   c                 X   |si S i }i }|D ]  \  }}|j                  d      r|j                  j                  d      s4|j                  |vsCt        dj                  |            }|||j                  <   |||<   |j	                  |j                        }|||<    t        | |       |S )zS
    restores variable names of user variables after applying copy propagation
    r   z${})
startswithrL   r   r   r  r   )	r   r  rd   rename_dictvar_rename_mapr  r,  r   r  s	            r   restore_copy_var_namesrQ    s     	KN 
$A S!aff&7&7&<45FF+4M$U\\!_5H"*K'(N8$++aff%C #GH
$ fk*r   c                    t        | j                  |      \  }}t        | j                        }t        | j                  ||||      }t	        | j                  ||      }d|vri |d<   |d   j                  |       t        j                  dk\  rt        | d       t        | j                  | j                  | |       t        | j                        | _        t        j                  dk\  rt        | d       y y )NrP  r   zafter copy propzafter simplify)r  r   r   r  rQ  r+   r
   rU  r  rE  rF  r.  )	rI  rd   re   metadatain_cpsr   r  r  rP  s	            r   simplifyrU    s    w~~w7IFA'7N&K ,GNNKQNx')+H%&%%n5"w 12 1 17GD!'..1GN"w 01 #r   c                       e Zd Zy)GuardExceptionN)r,   r-   r.   r/   r   r   rW  rW    s    r   rW  c                     | st         y)z?
    Raise GuardException if the given condition is False.
    NrW  )r  s    r   requirerZ    s      r   c                 2    	  | |i |S # t         $ r Y yw xY w)z
    Run a function with given set of arguments, and guard against
    any GuardException raised by the function by returning None,
    or the expected return results if no such exception was raised.
    NrY  )r   r   kwargss      r   r  r    s)    T$V$$ s   
 	c                 P    	  | j                   |fi |S # t        $ r t        w xY w)zm
    Same as func_ir.get_definition(name), but raise GuardException if
    exception KeyError is caught.
    )get_definitionKeyErrorrW  )rI  rL   r\  s      r   r^  r^    s4    
%w%%d5f55 s    %c                    |t        j                  t              }| j                         D ]  }|j                  D ]  }t        |t        j                        rM|j                  j                  }|j                  |g       }|g k(  r|||<   |j                  |j                         t        |      t        v s|t        t        |         } |||         |S )zBuild the definitions table of the given blocks by scanning
    through all blocks and instructions, useful when the definitions
    table is out-of-sync.
    Will return a new definition table if one is not passed.
    )collectionsdefaultdictr!  r  r   rE   r   rO   r  rL   getrP   r$   rh  build_defs_extensions)r   definitionsr
  r.  rL   
definitionr  s          r   r  r    s     !--d3 
%JJ 		%D$		*{{''(__T26
#(2K%!!$**-Dz22)$t*5$$		%
% r   c                    t        t        |t        j                        xr |j                  dk(         |j
                  } || |      }g }d}	 t        |t        j                  t        j                  f      rwg d}d}	|D ]0  }
t        |j                  |
      st        |j                  |
      }	 n |	rt        |	t              st        |j                  |	       |j                  }t        |t              r|j                  }t        |d      r|j                   }|du}|xr |dk(  xs |j#                  d      }|r*t        t$        |	      r|t        t$        |	      k(  r|dgz  }nt        t$        j&                  |	      r%|t        t$        j&                  |	      k(  r|ddgz  }nG|rE|j                  |       n3|j(                  j*                  }|dk(  rd	}|d
k7  r|j                  |       nt        |t        j                        r|j                  dk(  rq|j                  }|j                  |j,                         |r>|j.                  |v r0||j.                     }t        |t0        j2                        s|d   |fS  || |      }n$|dj5                  t7        |            |fS t        b|d   dj5                  t7        |dd             fS )az  Try to find a call expression's function and module names and return
    them as strings for unbounded calls. If the call is a bounded call, return
    the self object instead of module name. Raise GuardException if failed.

    Providing typemap can make the call matching more accurate in corner cases
    such as bounded call on an object which is inside another object.
    r^   N)rL   r  r,   r-   rT   znumpy.rx  builtin_function_or_methodbuiltinmodulerV   r   r   r   )rZ  rE   r   rM   r  r   rU   r  rQ   r$   rV   r   rW  rP   r   _defnr-   rN  rT   rx  	__class__r,   r  rL   r   rS   joinrg  )rI  r  rd   definition_findercallee
callee_defattrsobjr   r$   keydef_valmod_namemod_not_nonenumpy_toplevel
class_namer  s                    r   r  r  4  s    JtRWW%;$''V*;<YYF"7F3JE
C
j299bjj"9: 1DE :++S1#J$4$4c:E 
5# 6$$LL &&G ':.!--w-"--  (t3". #E#+w#6 $D&.&9&9(&C  #wue'<#wue'<<gY&EellE2#wu||U'CCh00E!LL*$..77
!==!*J)LL,
BGG,)1K""CLL)388w.chh'!#u||4 8S=(*7C8J xx0#55  { | 8SXXhuQRy1222r   c                    t        t        |t        j                               t	        | |      }t        t        |t        j
                               g d}t        |j                  |v        |j                  |j                  fS )zCheck if a variable is constructed via build_tuple or
    build_list or build_set, and return the sequence and the
    operator, or raise GuardException otherwise.
    Note: only build_tuple is immutable, so use with care.
    )rN   
build_list	build_set)rZ  rE   r   rI   r^  rM   r  r   )rI  r   var_def	build_opss       r   find_build_sequencer~    s_     JsBFF#$Wc*GJw():IGJJ)#$=='**$$r   c                     t        t        |t        j                               t	        | |      }t        t        |t        j
                  t        j                  t        j                  f             |j                  S )zvCheck if a variable is defined as constant, and return
    the constant value, or raise GuardException otherwise.
    )	rZ  rE   r   rI   r^  r]   rU   r  r$   )rI  r   r|  s      r   
find_constr    sO     JsBFF#$Wc*GJw299bjj ABC==r   c                 T   ddl m} t        | d      r| j                  }n3t        | d      r| j                  }nt        dj                  |             t        ||      }	t        |	j                         t        |	j                  t        j                               |	_	        t        |	j                  j                               }
t        j                  |
       t!        |	j                        }i }|j#                         D ]  \  }}t%        |      ||<    t'        |	j                  |       |ru|j)                  |||	|d      \  }}}}|D cg c]  }|j+                  d      s| }}|D ]  }|j-                  |        |j                  |       |j                  |       |	S c c}w )a  
    Compile a function or a make_function node to Numba IR.

    Rename variables and
    labels to avoid conflict if inlined somewhere else. Perform type inference
    if typingctx and other typing inputs are available and update typemap and
    calltypes.
    r   )typed_passescode__code__zfunction type not recognized {}Narg.)
numba.corer  rQ   r  r  NotImplementedErrorr   get_ir_of_coderA  r   r1  r5   r'   r)   r   r+   r   r   r   r   type_inference_stagerN  r  )mk_funcglblsrc   	targetctxarg_typsrd   re   r  r  f_irr4  r1   new_var_dictrL   r   	f_typemapf_return_typef_calltypesr   vnamerF  r  s                         r   compile_to_numba_irr    sw    (w||	*	%!"C"J"J7"STT%&D 't{{N4G4G4IJDKDKK$$&'I)$ #4;;/IL__& 1	c*40T1dkk<0 3?3T3T9dHd4<0	=+q )2NuU5E5Ef5MUN	N 	AMM!	y!%K Os   F%#F%c           
          | j                   j                  dd      j                  dd      }d| d| d| d| d| 
}i }t        |||        |d	          }| |_        | j                   |_        |S )
a   
    Creates a function from a code object. Args:
    * fcode - the code object
    * func_env - string for the freevar placeholders
    * func_arg - string for the function args (e.g. "a, b, c, d=None")
    * func_clo - string for the closure args
    * glbls - the function globals
    <r   >zdef closure():
z
	def (z):
		return (z
)
	return closure)co_namer   execr  r,   )	fcodefunc_envfunc_argfunc_clor  sanitized_co_name	func_textrj   r  s	            r   _create_function_from_code_objr    s     --c37??SI#H: .+,AhZ 8  (z *./1I CE3IAAJAJHr   c                    t        |j                        }dj                  t        |      D cg c]  }d|z  	 c}      }dj                  t        |      D cg c]  }d|z  	 c}      }dj                  t        |j                        D cg c]  }d|z  	 c}      }t        |||||       }ddlm j                  |      } G fdd	t              }	 |	|      j                  }
t        j                  j                  d
|
       i }ddl}|j                  j                   j#                  ||j                  j$                  j'                  d      |      }|j)                          ddlm} ddlm}  |       } |       }|j3                  |
       |j3                  |
       t5        j6                  |      }|j)                  d       |S c c}w c c}w c c}w )zG
    Compile a code object to get its IR, ir.Del nodes are emitted
    
z	c_%d = None,c_%dzx_%dr   compilerc                       e Zd Z fdZy)%get_ir_of_code.<locals>.DummyPipelinec                    j                         | _        d | j                  _        d | j                  _        d | j                  _        || j                  _        d | j                  _        d | j                  _        d | j                  _        y r    )		StateDictstaterc   r  r   rI  rd   return_typere   )r#   r  r  s     r   r%   z.get_ir_of_code.<locals>.DummyPipeline.__init__  sf    !++-DJ#'DJJ #'DJJ "DJJO!%DJJ!%DJJ%)DJJ"#'DJJ r   N)r,   r-   r.   r%   r  s   r   DummyPipeliner    s    	(r   r  zbefore-inferenceNF)ReconstructSSA)PreLowerStripPhisT)rG   co_freevarsrm  r   co_argcountr  r  r  run_frontendobjectr  r	   rewrite_registryapplynumba.core.inline_closurecallcoreinline_closurecallInlineClosureCallPasscpuParallelOptionsrH  numba.core.untyped_passesr  numba.core.typed_passesr  run_passr   rG  )r  r  nfreer  r  r  r  r  r   r  r  swappedr  inline_passr  r  reconstruct_ssaphistriprM  r  s                      @r   r  r    s    !!"EyyuU|D!/A-DEHxxU5\:!:;HxxU53D3D-EF!FGH&uh(',	.A $			q	!B	( 	( "##E##$6>G(**//EE
EJJNN**517<KOO 99$&O "HU#e&&r*IMM$Ic E:Fs   GGGc                    | j                   D ]r  }t        |t        j                        st        |j                  t        j
                        sC|j                  j                  }|t        |      k  sJ ||   |_        t y)z,
    Replace ir.Arg(...) with variables
    N)r   rE   r   rO   r$   r  r  rG   )r
  r   r   r;  s       r   replace_arg_nodesr    se     

 #dBII&:djj"&&+I**""CT?#?cDJ	#
 r   c                    | j                         D ]P  }|j                  s|j                  }t        |t        j
                        s8|j                  j                          |j                  j                         }t        |t        j                        r=t        |j                  t        j                        r|j                  j                  dk(  sJ d       |j                  j                  t	        j                  |j                  j                  ||j                               |j                  j                  t	        j                  ||j                               S y)zN
    Return return statement by assigning directly to target, and a jump.
    r  zinvalid return castN)r  r   rX  rE   r   r  r  rO   r$   rM   r  rP   rj   r   )r   r  r  r
  r   	cast_stmts         r   replace_returnsr     s      ?zzdBII&JJNN

(Iy"))4y8OO&&&0I3HI 1 JJbii	(=(=vtxxPQJJbgglDHH=>?r   c                    |d   j                   }|d   j                  }t        j                  |t	        d      |      }	t
        j                  j                  t              ||	j                  <   t        j                  dt        |      }
t        j                  |
|	|      }t        j                  j                  |	| |      }t        j                  |t	        d      |      }t        |      }|||j                  <   t        j                  |||      }t        j                  j                  ||d|      }|D cg c]  }||j                      }}|j!                  ||i       }|||<   t        j                  |||      }|||gS c c}w )Nr   r9   r:   z$np_attr_attrr/   )ri   rj   r   rI   r   r   rR   rS   rT   rL   rU   rO   rM   rV   rW   r^   r_   )func_as_strr   rf   r   rc   rd   re   ri   rj   rt   ru   rv   np_attr_callrx   func_var_typry   np_callr  	arg_typesr?  	np_assigns                        r   gen_np_callr  3  sB   GMME
q'++C vve];7=H"ZZ..u5GHMM99T5#&D))D(C0K77??8[#>Lvve]?;SAH#D)L)GHMM))L(C8Kggll8T2s3G*./Q/I/)))YCH!Ig		'3,Ii00	 0s   9Fc                 V    t        | d       |j                  D ]  }t        d|        y )N:z    )rV  r   )rb  r
  r   s      r   
dump_blockr  J  s)    	%

 fdr   c                 L    | j                         D ]  \  }}t        ||        y r    )r   r  )r   rb  r
  s      r   dump_blocksr  O  s%     !u5% !r   c                 t    t        | t        j                        xr t        | dd      xr | j                  dv S )z3true if expr is unary or binary operator or getitemr  F)unarybinopr  r  r  )rE   r   rM   rV   r  )r  s    r   is_operator_or_getitemr  S  s;    tRWW% \dE*\[[]r   c                 2    t        |       xs t        |       S )z8stmt is getitem assignment or setitem (and static cases))
is_getitem
is_setitemr   s    r   is_get_setitemr  Y  s    d/z$//r   c                     t        | t        j                        xr> t        | j                  t        j                        xr | j                  j
                  dv S )z6true if stmt is a getitem or static_getitem assignmentr  )rE   r   rO   r$   rM   r  r  s    r   r  r  ^  sC    tRYY' ?4::rww/?

!>>@r   c                 V    t        | t        j                  t        j                  f      S )z/true if stmt is a SetItem or StaticSetItem node)rE   r   r  r  r  s    r   r  r  d  s    dRZZ)9)9:;;r   c                    t        |       rE| j                  j                  dk(  r| j                  j                  S | j                  j                  S t        |       r2t        | t        j                        r| j                  S | j                  S y)z?get index variable for getitem/setitem nodes (and static cases)r  N)	r  r$   r  r  r  r  rE   r   r  r  s    r   index_var_of_get_setitemr  h  sg    $::==I%::###::'''$dBJJ'::>>!r   c                 0   t        |       r=| j                  j                  dk(  r|| j                  _        y || j                  _        y t        |       r*t        | t        j                        r|| _        y || _        y t        dj                  |             )Nr  z0getitem or setitem node expected but received {})r  r$   r  r  r  r  rE   r   r  
ValueErrorr   )r   	new_indexs     r   set_index_var_of_get_setitemr  x  st    $::==I%(DJJ#,DJJ 	D	dBJJ'"DJ&DNKRR  	r   c                     t        | t              sy| j                  }t        |      dk7  s|d   t        k7  ryt        | d      syt        | dd      }t        |t              syt        d |D              S )z check if c is a namedtuple classFr   r   _make_fieldsNc              3   <   K   | ]  }t        |t                y wr    )rE   r   )r  r  s     r   r  z&is_namedtuple_class.<locals>.<genexpr>  s     2az!S!2s   )rE   rh  	__bases__rG   rF   rQ   rV   all)cbasesfieldss      r   is_namedtuple_classr    sj    aKKE
5zQ%(e+1gQ	4(Ffe$26222r   c                    | j                   }| j                  }t        j                  ||      }|j	                  |      }| j                  t        j                  |||             |D 	cg c]  }	|j                  |	       }
}	t        j                  j                  ||
d|      }|j	                  |      }| j                  t        j                  |||             t        |      D ]`  \  }}|j                  |      }t        j                  j                  ||d|      }| j                  t        j                  |||             b | j                  t        j                  ||             | S c c}	w )	zFill *newblock* to call *callee* with arguments listed in *inputs*.
    The returned values are unwrapped into variables in *outputs*.
    The block would then jump to *label_next*.
    r$   rj   rj   r  r$   rj   r/   )r   r   r<  rj   N)r$   r  r  rj   r  rj   )ri   rj   r   r]   	make_temprP   rO   	get_exactrM   r^   	enumerater  r   )newblockro  
label_nextinputsoutputsri   rj   fnfnvarrL   r   callexprcallresr  rl   r  r  s                    r   fill_block_with_callr    s5   
 NNE
,,C	C	(BOOO$EOOBIIU"#>?.45dEOOD!5D5ww||Trs|CHoo#o&GOOBIIWH#FGG$ J3%''((wa37S ) B		wCHI	J OOBGG:378O 6s   -E9c           	         | j                   }| j                  }t        |      D cg c]  \  }}t        j                  |||       }}}t        ||      D ]D  \  }}	t        j                  |||      }
| j                  t        j                  |
|	|             F | j                  t        j                  ||             | S c c}}w )z
    Fill a new block *block* that unwraps arguments using names in *inputs* and
    then jumps to *label_next*.

    Expected to use with *fill_block_with_call()*
    )rL   r  rj   )ri   rL   rj   r  r  )
ri   rj   r  r   r  ziprI   rP   rO   r   )r
  r  r  ri   rj   r  r   r   anameavaltmps              r   fill_callee_prologuer	    s     KKE
))C "&)+1 FF, +D +64( Atff5u#6RYYc3?@A 
LL
45L+s   "Cc                 ~   | j                   }| j                  }|D cg c]  }|j                  |       }}t        j                  j                  ||      }|j                  |      }| j                  t        j                  |||             | j                  t        j                  ||             | S c c}w )z
    Fill a new block *block* to prepare the return values.
    This block is the last block of the function.

    Expected to use with *fill_block_with_call()*
    r   )r   rj   r  r  r  )
ri   rj   r  r   rM   rN   r  rP   rO   r  )r
  r  ri   rj   rL   valstupexprtups           r   fill_callee_epiloguer    s     KKE
))C3:;4EOOO&;D;gg!!#!6G
//c/
"C	LL#W#>?	LL#./L <s   B:c                 h   t        | |      }t        |t        j                  t        j                  f      r|j
                  S t        |t        j                        r>|j                  dk(  r/t        | |j
                        }	 t        ||j                        }|S t        # t        $ r t        w xY w)zhCheck if a variable is a global value, and return the value,
    or raise GuardException otherwise.
    rV   )r^  rE   r   rU   r  r$   rM   r  find_outer_valuerV   r  AttributeErrorrW  )rI  r   dfnprev_valvals        r   r  r    s     #
&C#		2::./yy#rwwCFFi$7#GSYY7	!(CHH-CJ   	!  	!s   B! !B1c                 	   g }| j                   D ]h  }||v st        ||   t        j                  j                        s0||   j
                  dkD  sCdj                  |      }t        || j                         | j                  j                         D ]  }|j                  t        j                        D ]  }t        |j                  t        j                        r|j                  j                   dk(  rl|j                  }t#        |dd      }|$t#        |dd      d}	d}
n|j$                  }	d	|	z  }
nd
}	d}
d|	d|
d}t        ||j                  j                        t        |j                  t        j&                  t        j(                  f      r|j                  }t#        |dd      }|d}t        |t*        j,                        r"|t.        j0                  t.        j2                  hv }|st#        |dd      dk(  }|r|j5                  |j                         t        |j                  t        j                        rF|j                  j                   dk(  r,|j                  j6                  dk(  r|j                  j                  j8                  }t        ||   t        j:                        r| j=                  |      }t?        t@        | |      }|re|d   dk(  r]t#        tB        |d         }tC        jD                  |tB        jF                        s$tC        jD                  |tB        jH                        r|jK                  d      rdndj                  |      }tM        dj                  |      |j                        t        |j                  t        j&                        r||jN                  j8                     }d}t#        |dd      s*t        |t        jP                  t        jR                  f      r1tM        |||j                  j8                  |fz  |j                        t        |j                  t        jT                        s| jV                  rd}t        ||j                          tY        |      dkD  r=d}dj[                  |D cg c]  }|j]                          c}      }t        ||z        yc c}w ) a&  
    Helper function to walk IR and raise if it finds op codes
    that are unsupported. Could be extended to cover IR sequences
    as well as op codes. Intended use is to call it as a pipeline
    stage just prior to lowering to prevent LoweringErrors for known
    unsupported features.
    i  a'  Tuple '{}' length must be smaller than 1000.
Large tuples lead to the generation of a prohibitively large LLVM IR which causes excessive memory pressure and large compile times.
As an alternative, the use of a 'list' is recommended in place of a 'tuple' as lists do not suffer from this problem.make_functionr  Nr  z$<creating a function from a closure>r<   z(%s) z<could not ascertain use case>zUNumba encountered the use of a language feature it does not support in this context: z (op code: make_function not supported). If the feature is explicitly supported it is likely that the result of the expression z'is being used in an unsupported manner.r$   Fr  gdb_internalrV   viewr   rT   r   r   z'{}' zZ'view' can only be called on NumPy dtypes, try wrapping the variable {}with 'np.<dtype>()'r  zThe use of a %s type, assigned to variable '%s' in globals, is not supported as globals are considered compile-time constants and there is no known way to compile a %s type as a constant.	reflectedz0The use of generator expressions is unsupported.av  Calling either numba.gdb() or numba.gdb_init() more than once in a function is unsupported (strange things happen!), use numba.gdb_breakpoint() to create additional breakpoints instead.

Relevant documentation is available here:
https://numba.readthedocs.io/en/stable/user/troubleshoot.html#using-numba-s-direct-gdb-bindings-in-nopython-mode

Conflicting calls found at:
 %sr  )/rF  rE   r   rJ   rK   countr   r   rj   r   r  
find_instsr   rO   r$   rM   r  rV   r  rU   r  pytypesFunctionTyper  gdbgdb_initrP   r  rL   r  r^  r  r  rT   
issubdtypeintegerfloatingrN  r   r  DictTypeListTyper#  is_generatorrG   rm  	strformat)rI  rd   	gdb_callsarg_namemsgblkr   r  r  user  foundr   dfcntyvardescrr  bufs                      r   raise_on_unsupported_featurer2    s    I %% 5wgh')9)9)B)BC8""T)R
 SYRXYaRb  #3445 ~~$$& S:NN299- R	:D$**bgg.::==O3**C #35D' #3	48D"HC#%D"&,,C#*S=D>! !$(C +3

?? $**ryy"**&=>jjc7D1; c7#7#78EIIu~~#>>E#C"5GE$$TXX. $**bgg.::==I-$**//V2K****//C!'#,<  //4B}gr:Bbew.$UBqE2!,,R? % 0 0U^^ D$%(^^C%8rgnnS>QH%Jx(dhh8 8 $**bii0T[[--.: BU3rENNENN#CD%cR",E&E488TT $**bhh/8L8LH&s99eR	:S:l 9~2 ii	:1:;sSy))  ;s   #Sc           	      z   |j                         D ]  \  }}|j                  s|j                  d      s%| j                  }|j	                  d      d   }| j
                  j                  }t        |t        j                        rdnd}d}d|d|d	|d
|}	t        j                  t        |	|              y )Nr  r   r   r!  rW  zrhttps://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-reflection-for-list-and-set-typeszR
Encountered the use of a type that is scheduled for deprecation: type 'reflected z' found for argument 'z' of function 'z'.

For more information visit r  )r   r  rN  rj   splitr  r   rE   r   Listwarningswarnr   )
rI  rd   rL   r/  rj   r%  r  tynameurlr)  s
             r   warn_deprecatedr:  j  s    MMO Lb<<v&kkjjoa(55#-b%**#=5$ !'UC9 <ScJK!Lr   c                 |     g  fd |      }|&|j                   }D ]  }t        ||d      }|r y |S y)ac  
    This returns the python function that is being getattr'd from a module in
    some IR, it resolves import chains/submodules recursively. Should it not be
    possible to find the python function being called None will be returned.

    func_ir - the FunctionIR object
    node - the IR node from which to start resolving (should be a `getattr`).
    c                 d   t        | dd      dk(  r@j                  d| j                         	 j                  | j                        }  |       S t        | t        j                  t        j                  f      r&t        | j                  t        j                        r| S y # t
        $ r Y y w xY w)Nr  FrV   r   )rV   insertr  r^  r$   r_  rE   r   rU   r  r  
ModuleType)modrI  getattr_chainresolve_mods    r   rA  z-resolve_func_from_module.<locals>.resolve_mod  s    3e$	1  CHH-,,SYY7 s##bii45#))W%7%78
  s   B# #	B/.B/NF)r$   rV   )rI  r  r?  defnr  r@  rA  s   `    @@r   resolve_func_from_modulerC    sV     M d
C
yy 	A4E*D	
 Kr   c                     | j                   j                         D ]R  }|j                  t        j                        D cg c]  }| }}|s2d|d   z  }t        ||d   j                         yc c}w )z8
    Enforce there being no ir.Del nodes in the IR.
    zIllegal IR, del found at: %sr   r  N)r   r  r  r   r  r   rj   )rI  r*  r  delsr)  s        r   enforce_no_delsrF    si     ~~$$& 6>>"&&12a22047:Ca55	62s   	A1c                     | j                   j                         D ]E  }|j                  d      D cg c]  }| }}|s%d|d   z  }t        ||d   j                         yc c}w )z=
    Enforce there being no ir.Expr.phi nodes in the IR.
    phi)r  zIllegal IR, phi found at: %sr   r  N)r   r  
find_exprsr   rj   )rI  r*  r  phisr)  s        r   enforce_no_phisrK    sg     ~~$$& 6>>U>34a44047:Ca55	64s   	A$c                 t    t        | j                         D ch c]  }|j                   c}      dk(  S c c}w )zGCheck the given mapping of ir.Block for containing a single scope.
    r   )rG   r  ri   )r   r*  s     r   legalize_single_scoperM    s,     V]]_5c		56!;;5s   5c                     t        |        t        |        t        j                  |       }|j	                  d|j
                         y)z4
    This checks that the IR presented is legal
    T)extend_lifetimesN)rK  rF  r   rG  rH  dbg_extend_lifetimes)rI  flagsrM  s      r   check_and_legalize_irrR    s:     GG&&w/IMM$)C)CMDr   c           	      X   | j                   }t        |j                        }g }|j                  D ]e  }	 |j                  |      }t        |t        j                        r|j                  |j                         Kd|z  }t        || j                         dj                  t        |      D cg c]  \  }}d||fz   c}}      }	dj                  t        |      D cg c]  }d|z  	 c}      }
t        |j                         }d}|j"                  }|j                  | j$                        }|t        |t&              r4|D cg c]  }|j                  |      j                   }}t'        |      }n=|j(                  D cg c]  }|j                  |      j                   }}t'        |      }t        |      }||z
  }dj                  t        |      D cg c]
  }d	||   z   c}      }|r?t        |      D cg c]  }|||z      d
|    }}|dz  }|dj                  |      z  }|j*                  j,                  j.                  }t1        ||	||
|      S # t        $ r d|z  }t        || j                        w xY wc c}}w c c}w c c}w c c}w c c}w c c}w )z
    Converts a code object from a `make_function.code` attr in the IR into a
    python function, caller_ir is the FunctionIR of the caller and is used for
    the resolution of freevars.
    z\Cannot capture a constant value for variable '%s' as there are multiple definitions present.r  zbCannot capture the non-constant value associated with variable '%s' in a function that may escape.r  z
	c_%d = %sr  r  r   z%sz = z, )r  rG   r  r^  r_  r   rj   rE   r   r]   rP   r$   rm  r  r   r!  co_varnamesr  defaultsrF   r   r  r   __globals__r  )code_obj	caller_irr  r  freevarsr  freevar_defr)  r  r  r  rT  n_kwargs	n_allargskwarg_defaultsdkwarg_defaults_tupnargsr  kw_constr  s                        r   convert_code_obj_to_functionrb    s    MME!!"E H 5	5#2215K
 k288,OOK--.BDEFCcx||445  yyYx=PQTQ-1a&0QRHxxU5\:!:;Hu(()K H!!I--h.?.?@N!ne,<JKq))!,22KAK!&q )..0 ))!,22 0A 0!&q)* Exx%,GQQ0GHH"8_. "-QY!79KA9NO . .DDIIh'' ""..E *%8X*/1 1_  	579:;Ccx||44	5 R: L0 H.s/   I$1J
"J	"J"JJ"J'$&J
c                    i }| j                         D ]9  }|j                  }|j                  D ]  }|j                         D ]  }|||<   	  ; | j                         D ]e  }|j                  }|j	                         D ]D  \  }}|j
                  |j                  vs|j                  j                  |j
                  |       F g y)aa  Fixes the mapping of ir.Block to ensure all referenced ir.Var are
    defined in every scope used by the function. Such that looking up a variable
    from any scope in this function will not fail.

    Note: This is a workaround. Ideally, all the blocks should refer to the
    same ir.Scope, but that property is not maintained by all the passes.
    N)r  ri   r   rY  r   rL   	localvarsdefine)r   used_varr*  ri   r.  r   s         r   fixup_var_define_in_scoperg  	  s     H}} %		HH 	%D~~' % $%	%% }} 6		!) 	6ICxxu.&&sxx5		66r   c                    | j                   }||u r| S |j                  j                  j                         D ]A  }|j                  |j                  vs|j                  j                  |j                  |       C || _         | S )z5Transfer the ir.Block to use the given ir.Scope.
    )ri   rd  _conr  rL   re  )r
  ri   	old_scoper   s       r   transfer_scoperk  &	  st     IE""''..0 2885??*OO""388S12 EKLr   c                 6    t        | t        j                        S r    )rE   r   	EnterWithr  s    r   is_setup_withrn  6	  s    dBLL))r   c                 6    t        | t        j                        S r    )rE   r   
Terminatorr  s    r   is_terminatorrq  :	  s    dBMM**r   c                 6    t        | t        j                        S r    )rE   r   r  r  s    r   is_raisers  >	  s    dBHH%%r   c                 6    t        | t        j                        S r    )rE   r   r  r  s    r   	is_returnru  B	  s    dBII&&r   c                 6    t        | t        j                        S r    )rE   r   PopBlockr  s    r   is_pop_blockrx  F	  s    dBKK((r   )NNN)NNr    )NNT)NNNNN)rQ  znumba.core.compiler.Flags)rT   r  r   r  ra  r6  r  numba.core.extendingr   r  r   r   r   r   r	   r
   numba.core.typing.templatesr   numba.core.analysisr   r   r   numba.core.errorsr   r   r   r   r`   r   r   r   r5   r3   r6   r   rH   rW   r   r   r   r   r   r   r   r   r   r  r  r  r   r   r  r'  r1  r3  r5  r=  rA  rC  rN  rE  ri  r[  r  r|  rP   rj  r  r  r  r  r  r  rT  r  r  r  r  r  r  r  r  r  r  r7  r  rS  r  r  r  r#  r.  r;  rC  rF  rH  rE  r)  rQ  rU  	ExceptionrW  rZ  r  r^  r  rd  r  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r	  r  r  r2  r:  rC  rF  rK  rM  rR  rb  rg  rk  rn  rq  rs  ru  rx  r/   r   r   <module>r~     s         + N N N 15 5. .  	/ 	/ 	!pf	="J$8N>"J	3 :9A  0f( #% ,  ":	 <@&*#P  Tn  
   3 4.`  8    FJGKD"L
"!J HJ  8$z #%  &*@D2#8  4*r  *"J!8 
2l  8B220	Y 		.  )- K3Z% CG?C,\.6p	?&1.
!]0
@<  3$6(&&x*vL*!H66<EA1H64 *+&')r   