
    qh                    $   d dl mZmZ d dlZd dlZd dlmZ d dlZd dlm	Z	m
Z
 d dlmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZmZmZmZmZ d dlm Z  d dl!m"Z" d d	l#m$Z$m%Z% d d
l&m'Z' d dl(m)Z)  edd      Z* G d de+      Z, G d de,      Z-d Z.y)    )
namedtupledefaultdictN)partial)Constant	IRBuilder)typingutilstypesir	debuginfofuncdesc
generatorsconfigir_utilscgutilsremoverefctpasstargetconfig)LoweringErrornew_error_contextTypingErrorLiteralTypingErrorUnsupportedErrorNumbaDebugInfoWarning)default_mangler)Environment)compute_use_defsmust_use_alloca)get_func_body_first_lineno)get_registered_loc_notify_VarArgItem)varargindexc                       e Zd ZdZddZed        Zd Zd Zd Z	d Z
d	 Zd
 Zd ZddZddZddZd Zd Zd Zd Zd Zd Zd dZd Zd Zd Zdej8                  ddfdZd Zd Zy)!	BaseLowerz
    Lower IR to LLVM
    Nc                    || _         || _        t        j                  |j                  j                               | _        || _        |j                  | _        || _        t        j                  j                         | _        | j                   j                  | j                  j                        | _        t!        j"                  | j                        | _        i | _        i | _        i | _        t-        | j                  j/                               | _        d| _        |j5                  | j$                  | j                        | _        | j6                  j8                  r| j6                  j:                  nt<        j>                  }| jA                         | _!        | j                  jD                  } || j                  |j2                  jF                  ||      | _        tI               | _%        | jM                          y )N)environmentfndesc)modulefilepathcgctxdirectives_only)'libraryr(   r	   	SortedMapblocksitemsfunc_irgenerator_infometadatar   ConfigStacktop_or_noneflagscreate_ir_moduleunique_namer)   r   from_fndescenvblkmappending_phisvarmapminkeysfirstblkloc	subtargetcontextenable_debuginfo	DIBuilderr   DummyDIBuilder_compute_def_locationdefn_locdbg_directives_onlyfilenamer   _loc_notify_registryinit)selfrC   r-   r(   r1   r3   dibuilderclsr,   s           M/var/www/html/engine/venv/lib/python3.12/site-packages/numba/core/lowering.py__init__zBaseLower.__init__   s   oognn&:&:&<=%44 !--99;
 ll33DKK4K4KL **4;;7 DKK,,./
 ((TXX04 ) =
  <<88 ..&55 	
 224**88%T[[/6{{/C/C,36EG %>$?! 			    c                 .    | j                   j                  S N)rC   	call_convrM   s    rO   rT   zBaseLower.call_convO   s    ||%%%rQ   c                      y rS    rU   s    rO   rL   zBaseLower.initS   s    rQ   c                 2   | j                   y| j                  j                  | j                        | _         | j                  j	                  | j                        | _        | j
                  j                  | _        | j
                  j                  | _        y)ze
        Init the Python API and Environment Manager for the function being
        lowered.
        N)	pyapirC   get_python_apibuilderget_env_managerenv_managerenv_bodyenv_ptrenvargrU   s    rO   
init_pyapizBaseLower.init_pyapiV   sn    
 ::!\\00>
  <<77E((11&&..rQ   c                    | j                   j                  j                  | j                   j                  j                  dz         }| j                  j
                  r| j                   j                  j                  }t        |      }|,|dz
  }| j                   j                  j                  |      }|S d| j                   j                  j                   d}t        j                  t        |             |S )N   z$Could not find source for function: z+. Debug line information may be inaccurate.)r1   rA   with_linenolinerC   rD   func_idfuncr   warningswarnr   )rM   rH   fnoptional_lnooffsetmsgs         rO   rG   zBaseLower._compute_def_locationd   s     <<##//0@0@0E0E0IJ<<((%%**B5b9L'%)<<++77? 	 >,,..334 5,, 3C89rQ   c                    d| _         | j                  j                  | j                  j                  | j
                  j                  | j
                  j                  | j
                  j                  | j                  j                         | j                  j                  j                  }| j                  j                  xr | j                  j                   }|rd|vr|j                  d       yyy)z4
        Called before lowering all blocks.
        N)functionqualnameargnamesargtypesre   alwaysinlinenoinline)rY   r   mark_subprogramr[   ro   r(   rp   argsrr   rH   re   
attributesr6   rI   add)rM   rw   
full_debugs      rO   	pre_lowerzBaseLower.pre_lowerw   s     
&&0E0E040D0D040@0@040D0D,0MM,>,>	 	' 	@ \\**55
ZZ))P$**2P2P.P
.
:NN:& ;:rQ   c                 z    | j                   j                          | j                  D ]  }|j                           y)z5
        Called after all blocks are lowered
        N)r   finalizerK   close)rM   notifys     rO   
post_lowerzBaseLower.post_lower   s2     	!// 	FLLN	rQ   c                      y)z1
        Called before lowering a block.
        NrW   rM   blocks     rO   	pre_blockzBaseLower.pre_block       rQ   c                      y)z0
        Called after lowering a block.
        NrW   r   s     rO   
post_blockzBaseLower.post_block   r   rQ   c                     | j                   j                  | j                  ||||| j                  j                  j
                         y )NrA   	func_name)rT   return_dynamic_user_excr[   r1   rf   r   )rM   	exc_classexc_argsnb_typesrA   s        rO   return_dynamic_exceptionz"BaseLower.return_dynamic_exception   s;    ..LL)Xxt||33== 	/ 	
rQ   c                     | j                   j                  | j                  |||| j                  j                  j
                         y)z+Propagate exception to the caller.
        r   N)rT   return_user_excr[   r1   rf   r   rM   r   r   rA   s       rO   return_exceptionzBaseLower.return_exception   s;     	&&LL)Xt||33== 	' 	
rQ   c                     | j                   j                  | j                  |||| j                  j                  j
                         y)z5Set exception state in the current function.
        r   N)rT   set_static_user_excr[   r1   rf   r   r   s       rO   set_exceptionzBaseLower.set_exception   s;     	**LL)Xt||33== 	+ 	
rQ   c                     | j                   j                  | j                        }| j                   j                  | j                  |       y)z7Emit a pointer to hold the Environment object.
        N)rC   get_env_namer(   declare_env_globalr)   )rM   envnames     rO   emit_environment_objectz!BaseLower.emit_environment_object   s4     ,,++DKK8''W=rQ   c                    | j                          | j                  #d | _        | j                  | j                         n| j                  |       | _        | j                  j                  | _        | j                  j                  |        | j                  j                  |        | j                  j                  r| j                  j                  |        t        j                  r*t        j                  | j                  | j                         | j                   j"                  rB| j                  6t%        j&                  | j(                  | j                   | j                         | j                   j+                  | j                  | j,                         | j,                  j/                  | j                         y )N)rC   r(   )r   r2   genlowerlower_normal_functionr(   GeneratorLowergentypelower_init_funclower_next_funchas_finalizerlower_finalize_funcr   	DUMP_LLVMr	   	dump_llvmr)   rC   
enable_nrtr   remove_unnecessary_nrt_usagero   post_loweringr-   add_ir_modulerU   s    rO   lowerzBaseLower.lower   s+   $$&& DM&&t{{3 //5DM==00DLMM))$/MM))$/||))11$7OODKK5 <<""t':':'B88AE@DM
 	""4;;= 	""4;;/rQ   c                     | j                   j                  | j                  | j                  j                  | j
                        | _        | j                  S rS   )rT   decode_argumentsr[   r(   rr   ro   fnargsrU   s    rO   extract_function_argumentsz$BaseLower.extract_function_arguments   s?    nn55dll6:kk6J6J6:mmE {{rQ   c                 h   | j                  |       | j                          | j                         }t        j                  | j
                        5  | j
                  j                  |       | j
                  j                  | j                  | j                            ddd       y# 1 sw Y   yxY w)z/
        Lower non-generator *fndesc*.
        N)
setup_functionr   lower_function_bodyr   suspend_emissionr[   position_at_endbranchr;   r@   )rM   r(   entry_block_tails      rO   r   zBaseLower.lower_normal_function   s     	F# 	'')335
 ''5 	<LL(()9:LLDMM :;	< 	< 	<s   AB((B1c                 J   | j                   D ]/  }d|z  }| j                  j                  |      | j                  |<   1 | j	                          | j
                  j                  }| j                  dj                  | j                  j                               t        | j                   j                               D ]T  \  }}| j                  |   }| j
                  j                  |       | j                  d|        | j                  |       V | j                          |S )zP
        Lower the current function's body, and return the entry block.
        zB%sz# function begin: {0}z# lower block: )r/   ro   append_basic_blockr;   rz   r[   basic_blockdebug_printformatr(   r8   sortedr0   r   lower_blockr   )rM   rl   bnamer   r   bbs         rO   r   zBaseLower.lower_function_body   s    
 kk 	JFFNE"&--"B"B5"IDKK	J 	<<33077KK##% 	& $DKK$5$5$78 	$MFEV$BLL((,vh78U#		$
 	rQ   c                 @   | j                  |       |j                  D ]a  }|j                  | _        t        t        | j                        }t        d|| j                  |      5  | j                  |       ddd       c | j                  |       y# 1 sw Y   xY w)z(
        Lower the given block.
        rA   zlowering "{inst}" at {loc})instrA   errcls_N)r   bodyrA   r   r   r   
lower_instr   )rM   r   r   defaulterrclss       rO   r   zBaseLower.lower_block
  s     	uJJ 	&DxxDH#Mtxx@M"#?d'+xxH &%& &	& 	& &s   &BB	c                 P   | j                   rR| j                  j                  | j                  | j                   j                  | j
                  | j                  |       | j                  j                  | j                  | j                  | j
                  | j                  |       y)zP
        Create CPython wrapper(s) around this function (or generator).
        )release_gilN)r   rC   create_cpython_wrapperr-   gendescr:   call_helperr(   )rM   r   s     rO   r   z BaseLower.create_cpython_wrapper  s     ==LL//040E0E04$:J:J<G 0 I 	++DLL$++,0HHd6F6F8C 	, 	ErQ   c                     | j                   rt        d      | j                  j                  | j                  | j
                  | j                  | j                         y)z8
        Create C wrapper around this function.
        z(generator as a first-class function typeN)r   r   rC   create_cfunc_wrapperr-   r(   r:   r   rU   s    rO   r   zBaseLower.create_cfunc_wrapper$  sE     =="#MNN))$,,*.((D4D4D	FrQ   c                    | j                   j                  | j                  |      | _        | j                  j
                  r<| j                  j                  }d|vr"|j                  d       |j                  d       | j                  j                  d      | _	        t        | j                        | _        | j                  j                  | j                        | _        y )Nrs   optnonert   entry)rC   declare_functionr)   ro   r6   dbg_optnonerw   rx   r   entry_blockr   r[   rT   init_call_helperr   )rM   r(   attrsets      rO   r   zBaseLower.setup_function-  s    55dkk6J::!!mm..GW,I&J'==;;GD !1!12>>::4<<HrQ   c                 4    | j                   j                  |   S rS   )r(   typemap)rM   varnames     rO   typeofzBaseLower.typeof9  s    {{""7++rQ   rA   returnc                 H    | j                   D ]  }|j                  |        y)z[Called when a new instruction with the given `loc` is about to be
        lowered.
        N)rK   r~   )rM   rA   
notify_objs      rO   
notify_loczBaseLower.notify_loc<  s'     33 	#Jc"	#rQ   c                     t         j                  rA| j                  j                  | j                  d| j
                  j                   d|        y y )Nz
DEBUGJIT [z]: )r   	DEBUG_JITrC   r   r[   r(   rp   )rM   rm   s     rO   r   zBaseLower.debug_printC  sD    LL$$
4;;+?+?*@C5IK rQ   c                 d   t        j                  |      | j                  j                  |   f}| j                  j                         | j                  |      f}t        j                  t         j                  g| }| j                  j                  t        |      } || j                  |       y)zHelper to emit ``print(msg, varname)`` for debugging.

        Parameters
        ----------
        msg : str
            Literal string to be printed.
        varname : str
            A variable name whose value will be printed.
        N)r
   literalr(   r   rC   get_dummy_valueloadvarr   	signaturenoneget_functionprintr[   )rM   rm   r   argtysrv   sigimpls          rO   print_variablezBaseLower.print_variableH  s     MM#KK(

 LL((*LL!
 uzz3F3||((4T\\4 rQ   rS   )NN)F) __name__
__module____qualname____doc__rP   propertyrT   rL   ra   rG   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Locr   r   r   rW   rQ   rO   r$   r$      s    /b & &/&',




>0<<" 2EF
I,#bff # #K
!rQ   r$   c                        e Zd Zej                  Z fdZed        Zd Z fdZ	d Z
d Zd Zd Zd	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d&d Z%d! Z&d" Z'd&d#Z(d$ Z)d% Z* xZ+S )'Lowerc                 B    t         |           | j                          y rS   )superrL   _find_singly_assigned_variable)rM   	__class__s    rO   rL   z
Lower.initc  s    ++-rQ   c                 z    | j                   y| j                   j                  xr | j                   j                   S )a  Flags that the SROA like optimisation that Numba performs (which
        prevent alloca and subsequent load/store for locals) should be disabled.
        Currently, this is conditional solely on the presence of a request for
        the emission of debug information.F)r6   r   rI   rU   s    rO   _disable_sroa_like_optzLower._disable_sroa_like_opth  s3     ::zz##JDJJ,J,J(JJrQ   c                 b   | j                   }|j                  }t               }| j                   j                  j                  sYt        |      }t        |      }t        t              }|j                  j                         D ]   \  }}|D ]  }	||	   j                  |        " t        t              }
|j                  j                         D ]   \  }}|D ]  }	|
|	   j                  |        " |D ]  }	|	|vst        ||	         dk(  st        |
|	         dk(  s,||	   \  }| j                  |   j                  t        j                        }|D cg c]  }|j                   j"                  |	k(  r| }}t        |      dk(  s|j                  |	        || _        i | _        y c c}w )Nrc   r   )r1   r/   setrf   is_generatorr   r   r   defmapr0   rx   usemaplen
find_instsr   Assigntargetname_singly_assigned_vars_blk_local_varmap)rM   r1   r/   savuse_defsalloca_varsvar_assign_mapblkvlvarvar_use_mapdefblkassign_stmtsstmtassignss                  rO   r   z$Lower._find_singly_assigned_variables  s   ,,e||##00'/H)&1K )-N#??002 1R 1C"3'++C011
 &c*K#??002 .R .C$((-..
 & )k)c.2E.F!.K;s+,1 $2##6'+{{6':'E'Ebii'P4@ #?D&*kk&6&6#&= $( #? #?w<1,GGCL) &)"!##?s   "F,c                    ddl m} t        t        |   |       || _        || j                  k(  r| j                  | j                     }| j                  j                  |       t               }| j                  j                         D ]P  }|j                  t        j                        D ],  }|j                   |vs|j#                  |j                          . R |D ]%  }| j%                  |      }| j'                  ||       ' |j)                  d      D ]  }t+        j,                  t*        j.                  | j0                  |j2                        }	|	?t5        |	t        j6                        sZ|	j                   |j8                  u sst5        |j:                  t        j<                        s| j                  |j:                  j>                     }
d|
i| j                  _          y  y )Nr   )ehcall)opr  )!numba.core.unsafer  r   r   r   _cur_ir_blockr@   r;   r[   r   r   r/   valuesr   r   Delvaluerx   r   _alloca_var
find_exprsr   guardget_definitionr1   rg   
isinstanceGlobalexception_check
terminatorBranchtruebr_in_try_block)rM   r   r  r   	all_namesxr  fetyper  defn	targetblkr   s              rO   r   zLower.pre_block  s   (eT$U+"DMM!
 T]]+BLL((,I++- /))"&&1 /Awwi/!agg.// " /T*  v./ $$$/ 	D>>''tyyD JtRYY$?::!3!33!%"2"2BII>$(KK0@0@0G0G$H	 7?	5J2	rQ   c                 <    	 | j                   `y # t        $ r Y y w xY wrS   )r[   r$  AttributeErrorr   s     rO   r   zLower.post_block  s#    	* 		s    	c                 *   | j                   j                  | j                  | j                  j                         | j                  | j                         | j                  t        |             t        |t        j                        r| j                  |j                  j                        }| j                  ||      }d }t        |j                  t        j                         rS| j                   j                  | j                  | j"                  j                         |j                  j$                  dz   }| j'                  ||j                  j                  |       y t        |t        j(                        r| j+                  |j,                  j                        }| j.                  |j0                     }| j.                  |j2                     }| j                  |j,                  j                        }| j4                  j7                  | j                  ||t8        j:                        }	|	j<                  t>        j                  jA                  d      k(  sJ d|	j<                  z         | j                  jC                  |	||       y t        |t        jD                        r5| j.                  |j                     }
| j                  jG                  |
       y t        |t        jH                        r5| jJ                  r| jL                  jO                  |        y | j+                  |j                  j                        }| j                  |j                  j                        }| jP                  jR                  }t        |t8        jT                        r)| jV                  jY                  | j                  |||       y ||k(  sJ dj[                  ||             | j4                  j]                  | j                  ||      }| jV                  j_                  | j                  |       y t        |t        j`                        ry t        |t        jb                        r| jP                  jd                  |   }|J 	 | j4                  jg                  d|      }| j+                  |j                  j                        }
| j+                  |j                  j                        }| j                  |j                  j                        }| j4                  j7                  | j                  |||jh                  d         } || j                  |
|j$                  |f      S t        |t        jp                        r| js                  |       y t        |t        jt                        rO| jP                  jd                  |   }|J | jm                  |j                  |j$                  |j                  |      S t        |t        jv                        rO| jP                  jd                  |   }|J | jm                  |jx                  |jz                  |j                  |      S t        |t        j|                        r| j+                  |j                  j                        }
| j+                  |j$                  j                        }| j                  |j                  j                        }| j                  |j$                  j                        }| jP                  jd                  |   }|J t~        j                  }| j4                  j                  j                  |      }|j                  | j4                  j                  |jh                  i       }| j4                  jg                  ||      }||jh                  d   k(  sJ | j4                  j7                  | j                  |||jh                  d         } || j                  |
|f      S t        |t        j                        r| j                  |j                         y t        |t        j                        r5| j+                  |j                  j                        }
| j+                  |j                  j                        }| jP                  jd                  |   }| j                  |j                  j                        }| j                  |j                  j                        }|J |jh                  d   |k(  sJ | j4                  j                  |j                  |      }| j4                  j7                  | j                  |||jh                  d         } || j                  |
|f      S t        |t        j                        r| j                  |       y t        |t        j                        r| j                  |       y t        |t        j                        r| j                  |       y t        |t        j                        r| j                  |       y tk        t=        |            # tj        $ r5 | jm                  |j                  |jn                  |j                  |      cY S w xY w)Nrc   )argidxzcond is not i1: %sz)type '{}' does not match return type '{}'static_setitem   r   )Qr   mark_locationr[   rA   re   r   r   strr  r   r   r   r  r  lower_assignr  ArgrH   r"   storevarr"  r   condr;   r#  falsebrrC   castr
   booleantypellvmliteIntTypecbranchJumpr   Returnr2   r   return_from_generatorr(   restypeOptionalrT   return_optional_valuer   get_return_valuereturn_valuePopBlockStaticSetItem	calltypesr   rv   NotImplementedErrorlower_setitem	index_varPrintlower_printSetItemStoreMapdctkeyDelItemoperatordelitemtyping_contextresolve_value_typeget_call_typer  delvarSetAttrget_setattrattrDynamicRaiselower_dynamic_raiseDynamicTryRaiselower_try_dynamic_raiseStaticRaiselower_static_raiseStaticTryRaiselower_static_try_raise)rM   r   tyvalr-  r5  trflcondtypredr  otyretvalr   r   r  valuetyr"   targettyindextyr  fnopcallsigs                          rO   r   zLower.lower_inst  s   $$T\\488==A!T#dBII&T[[--.B##B-CF $**bff-,,T\\4==;M;MN))A-MM#t{{//M?bii(<<		/DT[[)BT\\*B[[0F<<$$T\\4OD99 3 3A 66 3%		136LL  r2.bgg&[[-FLL'bii(""33D9,,tzz/C++djjoo.C$$B"enn-44T\\2sCP9 M;BB3KM9\\224<<SIFNN''f=bkk*b../--d3I(((G||001A9M
 dkk&6&67TZZ__5++djjoo6))$,,w*3..*;=DLL64::u*EFFbhh'T"bjj)--d3I(((%%dkk4::tzz&/1 1 bkk*--d3I(((%%dhh$**iPPbjj)\\$++"2"23FLL1E{{4;;#3#34Hkk$**//2G--d3I(((!!B<<..AA"ED((++Y^^RG <<,,T7;Dy~~a0000LL%%dllE7&/nnQ&79E vuo66bff%KK

#bjj)\\$++"2"23FLL1E--d3I{{4;;#3#34Hkk$**//2G(((>>!$000<<++DIIyAD LL%%dllE7&/nnQ&79E vuo66boo.$$T*b001((.bnn-##D)b//0''- &d4j11c ' A))$++t~~*.**iA AAs    i ;jjc                 D   | j                  |j                        }| j                  |j                        }| j                  |j                        }| j                  |j                        }| j                  |j                        }	| j                  |j                        }
t        j                  }| j
                  j                  j                  |      }|j                  | j
                  j                  |j                  i       }| j
                  j                  ||      }t        |t        j                        r3| j
                  j                  | j                  |||j                         }n0t        j"                  } ||       ||j                  d         k(  sJ | j
                  j                  | j                  ||
|j                  d         }| j
                  j                  | j                  ||	|j                  d         } || j                  |||f      S )Nr   rc   r/  )r   r  r   rR  setitemrC   rT  rU  rV  rv   r   r  r
   rA  r7  r[   r9  	unliteral)rM   
target_varrJ  	value_varr   r  r  r"   rl  rk  rm  r  rn  ro  r   uls                   rO   rI  zLower.lower_setitemS  s   joo.Y^^,Y^^,;;z/++inn-++inn-||**==bA$$LL''
 ||((w7 h/\\&&t||VX'/}}6F Bh<2innQ&7#8888!!$,,w"+.."35!!$,,w"+.."35 DLL65%"899rQ   c                 &    | j                  |       y rS   )rb  rM   r   s     rO   r^  zLower.lower_try_dynamic_raiser  s     	##D)rQ   c                    |j                   }g }g }|D ]  }t        |t        j                        rI| j	                  |j
                        }| j                  |j
                        }| j                  ||       nd }|}|j                  |       |j                  |        | j                  |j                  t        |      t        |      | j                         y Nr   )r   r  r   Varr   r  r   increfappendr   r   tuplerA   )rM   r   r   rv   r   exc_argtyprd  s           rO   r\  zLower.lower_dynamic_raisew  s    == 
	G'266*kk',,/ll7<<0C%OOC KK
	 	%%dnneDk&+Ho488 	& 	ErQ   c                     |j                   | j                  d | j                         y | j                  |j                   |j                  | j                         y ry  )r   r   rA   r   rw  s     rO   r`  zLower.lower_static_raise  sD    >>!!!$DHH!5!!$..$--TXX!NrQ   c                     |j                   | j                  d | j                         y | j                  |j                   |j                  | j                         y ry  )r   r   rA   r   rw  s     rO   rb  zLower.lower_static_try_raise  sD    >>!t2t~~t}}$((KrQ   c                    |j                   }t        |t        j                  t        j                  t        j
                  f      rE| j                  j                  | j                  ||j                         }| j                  ||       |S t        |t        j                        r| j                  ||      S t        |t        j                        rr| j                  |j                        }| j                  |j                        }| j                  j!                  | j                  |||      }| j                  ||       |S t        |t        j"                        r9t%        j&                  | j                        5  | j                  d|j                  z         }t        |t(        j*                        r|j                   }| j                  j,                  }	|	j/                  |      }
| j                  j                  | j                  |
|      }| j                  j!                  | j                  ||
|      }nA| j0                  |j2                     }| j                  j!                  | j                  |||      }| j                  ||       |cd d d        S t        |t        j4                        r&| j7                  ||      }| j                  ||       |S t9        t;        |      |      # 1 sw Y   xY w)Nzarg.)r  r  r   Constr  FreeVarrC   get_constant_genericr[   r{  Expr
lower_exprrz  r   r  r   r7  r3  r   r   r
   OmittedrT  !resolve_value_type_prefer_literalr   r"   Yieldlower_yieldrH  r9  )rM   rc  r   r  resrd  ri  argtypyvaltyctxvaltyconsts               rO   r2  zLower.lower_assign  s2   

ebhh		2::>?,,33DLL"49KKACKKC Jrww'??2u--rvv&,,uzz*C++ejj)C,,##DLL#sB?CKKC Jrvv& ++DLL9  FUZZ$78eU]]3!KKE LL77E!CCEJE LL==eUE ,,++DLL%KC++ekk2C,,++DLL#ubICB$% ( rxx(""2u-CKKC J!$u+u553 s   =DK,,K5c                    | j                   j                  |j                     }|j                  |u sJ t	        j
                  | ||j                        }|j                          | j                  |j                  j                        }| j                  |j                  j                        }| j                  j                  }| j                  j                  | j                   |||      }| j                  j#                  | j                   ||      }	| j$                  j'                  | j                   |	       |j)                          | j                  j+                  | j                   |d       S rS   )r2   yield_pointsr"   r   r   
LowerYield	live_varslower_yield_suspendr   r  r  r   r   
yield_typerC   r7  r[   rC  rT   rD  lower_yield_resumer  )
rM   rettyr   ypyrd  r  actual_rettypyretrj  s
             rO   r  zLower.lower_yield  s     --djj9ww$!!$BLL9	ll4::??+kk$**//*// ||  sCG ..LL-

 	##DLL&9 	
||00udKKrQ   c                 T     j                   j                  j                        |j                  }|j                  }|j
                  }|j                  } j                  |j                        } j                  |j                        }	 j                  |j                        } j                  |j                        } j                  j                  |    j                   j                   j                  ||j                  d         } j                   j                   j                  ||	j                  d         } fd}
 fd} |t        |      t        |      f||f      }| |
|      S  |t        |      |	f||f      }| |
|      S  ||t        |      f||f      }| |
|      S j!                   j                   j                  j                  i       } j                   j#                  |      } | j                  ||f      } |
|      S )Nr   rc   c                 h    j                   j                  j                  | j                        S rS   )rC   r7  r[   return_type)r  restyrM   r   s    rO   cast_resultz&Lower.lower_binop.<locals>.cast_result  s/    <<$$T\\3%.%:%:EC CrQ   c                    t        d |D              ry 	 t        t        j                        r(j	                  j
                  j                  | i       }n t        j                  j                  g|  }	 j
                  j                  |      } |j                  |      S # t        $ r Y y w xY w# t        $ r Y y w xY w)Nc              3   @   K   | ]  }|t         j                  u   y wrS   )r   	UNDEFINED).0as     rO   	<genexpr>z=Lower.lower_binop.<locals>.try_static_impl.<locals>.<genexpr>  s     31$3s   )anyr  r
   FunctionrV  rC   rT  r   r   r  r   r   r[   rH  )tysrv   
static_sigstatic_implr  rM   r   s       rO   try_static_implz*Lower.lower_binop.<locals>.try_static_impl  s    3d33b%..1!#!1!1$,,2M2M25r";J "(!1!1)2G2G!N#!NJ"ll77JG"4<<66	  
 ' s$   A"B( 9.B7 (	B43B47	CC)rC   rT  rU  lhsrhs
static_lhs
static_rhsr   r  r   r(   rG  r7  r[   rv   _lit_or_omittedrV  r   )rM   r  exprr  r  r  r  r  ltyrtyr  r  r  r   r   r   s   `` `           @rO   lower_binopzLower.lower_binop  s    \\((;;B?hhhh__
__
kk#((#kk#((#ll388$ll388$ KK))$/	llc3	q8IJllc3	q8IJ	C
	" Z(/**EF$
 ?s##Z(#.
 ?s##/*-.*
 ?s## t||::INNBO||((S14<<#s,3rQ   c                 "   | j                  |j                        }| j                  |j                        }t        j                  }| j                  j
                  j                  |      }	|	j                  | j                  j
                  |j                  i       }
| j                  j                  |	|
      }||f}| j                  |j                        | j                  |j                        f}t        |||j                        D cg c].  \  }}}| j                  j                  | j                  |||      0 }}}} || j                  |      }| j                  j                  | j                  ||j                  |      S c c}}}w rS   )r   r  rR  getitemrC   rT  rU  rV  rv   r   r   zipr7  r[   r  )rM   r  r  r  r"   r   basevalindexvalr  rn  ro  r   argvalsargtypsavatftcastvalsr  s                      rO   lower_getitemzLower.lower_getitem*  sN   ,,uzz*<<

+||**==bA$$LL''
 ||((w7H%;;uzz*;;uzz*, '*'7*3..':; ;"B LL%%dllBB? ; ; 4<<*||  s!*!6!6!&( 	(	;s   3F
c                    t        |t              r|| j                  |j                  j                        |j
                     }| j                  j                  | j                  |j                  j                        |j
                        }n6| j                  |j                        }| j                  |j                        }| j                  j                  | j                  |||      S )zh
        Cast a Numba IR variable to the given Numba type, returning a
        low-level value.
        )r  r    r   r!   r  r"   r[   extract_valuer   rC   r7  )rM   r  rc  vartyrd  s        rO   	_cast_varzLower._cast_var@  s    
 c;'KK

0;E,,,,T\\#**//-J-0YY8C KK)E,,sxx(C||  sE2>>rQ   c                 
    |rf j                  |j                        }t        |t        j                        sJ |t        t        |            D cg c]  }t        ||       c}z   }j                  }|J|rt        d|      t        |j                        D 	
cg c]  \  }	}
 j                  |	|
       }}	}
|S  fd} fd} fd}t        j                  ||t        |      |||      }|S c c}w c c}
}	w )Nz+unsupported keyword arguments when calling c                 B    j                  |j                  |          S rS   )r  rv   )r"   paramr  rM   r   s      rO   normal_handlerz,Lower.fold_call_args.<locals>.normal_handler`  s    ~~c9>>%+@AArQ   c                 l    j                   j                  j                  j                  |    |      S rS   )rC   r  r[   rv   )r"   r  defaultrM   r   s      rO   default_handlerz-Lower.fold_call_args.<locals>.default_handlerc  s0    ||88LL).."7B BrQ   c                    j                   |    }t        |t        j                        sJ |       t	        ||      D cg c]  \  }}j                  ||       }}}t        j                  j                  |      S c c}}w rS   )	rv   r  r
   	BaseTupler  r  r   make_anonymous_structr[   )	r"   r  vars
stararg_tyr  sigtyr  rM   r   s	          rO   stararg_handlerz-Lower.fold_call_args.<locals>.stararg_handlerg  s}    &^^E2
!*eoo>J
J>,/j,AC(c5 ..e4 C C44T\\6JJCs   B )r   r  r  r
   r  ranger   r    pysigrH  r  rv   r  r   fold_argumentsdict)rM   fntyr   pos_argsr!   kw_args	tp_varargir  r  r  r  r  r  r  s   ` `            rO   fold_call_argszLower.fold_call_argsN  s    FKK0Ii999,1#i.,A#C'( $/vq#9 #C CH =)?C+F G G *-Xy~~)FH%3 ~~c51 HG H, 'BBK ++E,4d7m,:,;,;	=G
 ?#CHs   C:"C?c                    | j                   j                  |   }|j                  t        j                  k(  sJ | j
                  j                  j                  t              }t        |j                        }t        |j                        }t        t        |            D ]I  }||j                  v s|j                  |   }t        |t              s2t        j                   |      ||<   K t#        j$                  |j                  g| }|j'                  |j(                        }| j+                  ||||j,                  i       }	| j
                  j/                  t        |      }
 |
| j0                  |	       y)z$
        Lower a ir.Print()
        )r  N)r(   rG  r  r
   r   rC   rT  rU  r   listrv   r  r   constsr  r1  r   r   r   replacer  r  r!   r   r[   )rM   r   r   r  pos_tysr  r  r  	fixed_sigr  r   s              rO   rL  zLower.lower_printu  s#    kk##D)%**,,,||**==eD sxx.		?s8}% 	6ADKKAeS)!&u!5GAJ		6 $$S__?w?	%%CII%6	%%dC4;;K||((	:T\\7#rQ   c                 2   | j                   j                  |   }| j                  dj                  |             t	        |j
                  t        j                        r| j                  j                         S | j                  |j                  j                        }t	        |t        j                        r| j                  |||      }nt	        |t        j                        r| j!                  |||      }nt	        |t        j"                        r| j%                  |||      }not	        |t        j&                        r| j)                  |||      }nAt	        |t        j*                        r| j-                  |||      }n| j/                  |||      }|O|j
                  t        j0                  k(  r| j                  j                         }nt3        d| j4                        | j                  j7                  | j8                  ||j
                  |      S )Nz# lower_call: expr = {0}z2non-void function returns None from implementation)rm   rA   )r(   rG  r   r   r  r  r
   PhantomrC   r   r   rg   r  ObjModeDispatcher_lower_call_ObjModeDispatcherExternalFunction_lower_call_ExternalFunctionExternalFunctionPointer#_lower_call_ExternalFunctionPointerRecursiveCall_lower_call_RecursiveCallFunctionType_lower_call_FunctionType_lower_call_normalvoidr   rA   r7  r[   )rM   r  r  r   r  r  s         rO   
lower_callzLower.lower_call  s   KK))$/	3::4@Ai++U]];<<//11{{499>>*dE33444T4KCe44533D$	JCe;;<::dI'C e11200tYGCe001//dIFC ))$i@C
 ;$$

2ll224#L 
 ||  sI4I4I!&( 	(rQ   c           	         ddl m} | j                          | j                  j	                         }|j
                  D cg c]  }|j                   }}|D cg c]  }| j                  |       }}|D cg c]  }| j                  |       }	}t        |	|      D ]  \  }
}| j                  ||
        t        ||	      D cg c],  \  }}| j                  j                  ||| j                        . }}} || j                        j                  ||      }| j                  j                  ||      }t        j                   | j"                  |      }| j"                  j%                  |      5 \  }}|5  |D ]  }| j                  j'                  |        | j                  j)                  |       | j*                  j-                  | j"                         d d d        |5  | j                  j/                  |j0                  j2                  |      }|j4                  }| j                  j'                  |       |D ]  }| j                  j'                  |        t7        |j8                        r|j9                          | j                  j)                  |       | j"                  j;                  |j<                        5  | j*                  j-                  | j"                         d d d        |cd d d        cd d d        S c c}w c c}w c c}w c c}}w # 1 sw Y   BxY w# 1 sw Y   ?xY w# 1 sw Y   nxY w	 d d d        y # 1 sw Y   y xY w)Nr   )ObjModeUtils)numba.core.pythonapir  ra   rY   
gil_ensurerv   r  r   r   r  r{  from_native_valuer]   load_dispatchercall_function_objargsr   is_nullr[   if_elsedecrefgil_releaserT   
return_excto_native_value
dispatcheroutput_typesr  callablecleanupif_thenis_error)rM   r  r  r   r  	gil_stater  rq   rr   	argvaluesvrc  atypavalargobjscalleeret_objhas_exceptionthenorelseobjnativeoutputs                          rO   r  z#Lower._lower_call_ObjModeDispatcher  s   5JJ))+	$(II.qAFF..,45qDKKN55.67T\\!_7	7H- 	EArKKA	 &)9%=?!tT :://d040@0@B ? ?
 djj)99$I**2267Cg>]]""=1 '	^dF  	8" +CJJ%%c*+ 

&&y1 ))$,,7	8  33OO00   

!!'*" +CJJ%%c*+ FNN+NN$ 

&&y1 \\))&//: <NN--dll;< 1 '	 '	! /57
?	8 	8B< <+  '	 '	 '	sm   LL6L1L2M
8A#L
M
%CL4&L(*	L43	M
L%	 M
(L1-L44L=	9M

Mc                    | j                  d       | j                  |||j                  |j                  |j                        }t        j                  |j                  |j                  j                  |j                  j                        }| j                  j                  | j                  j                  |      }| j                  j                  | j                  ||j                  |      S )Nz# external function)r   r  rv   r!   kwsr   ExternalFunctionDescriptorsymbolr   r  rC   declare_external_functionr[   r)   call_external_functionrr   )rM   r  r  r   r  r(   rg   s          rO   r  z"Lower._lower_call_ExternalFunction  s    ./%%)TYYTXX
 44KK--txx}}>||55LL)||22LL$
 	
rQ   c                    | j                  d       | j                  |||j                  |j                  |j                        }| j                  |j                  j                        }|j                  rS| j                          | j                  j                         }g }g }t        |j                  j                  |j                  |      D ]  \  }	}
}|	t        j                  k(  r\| j!                  |
|       | j                  j#                  |
|| j$                        }|j'                  |       |j'                  |       v|j'                  |        | j(                  j+                  | j,                  |||j.                        }|D ]  }| j                  j1                  |        | j                  j3                  |       |S | j(                  j+                  | j,                  |||j.                        }|S )Nz## calling external function pointer)r   r  rv   r!   r  r   rg   r  requires_gilra   rY   r  r  r   r
   ffi_forced_objectr{  r  r]   r|  rC   call_function_pointerr[   cconvr  r  )rM   r  r  r   r  pointerr  
newargvalspyvalsexptypgottypr  r  r  s                 rO   r  z)Lower._lower_call_ExternalFunctionPointer
  s   >?%%)TYYTXX
 ,,tyy~~.OO

--/IJF(+DHHMM9>>,3)5 ,$ U444KK-**66d&6&6C %%c*MM#&%%d+, ,,44gz4::C  '

!!#&' JJ""9- 
 ,,44gw

C 
rQ   c                 t   | j                  |||j                  |j                  |j                        }|j	                  |j                        }| j
                  j                  xs t        }| j                  j                  } ||j                  |j                  ||j                        }| j                  j                  j                  j                  |      r4| j
                  j!                  | j                  | j                  ||      }	|	S | j
                  j#                  | j                  |||      }	|	S )N)abi_tagsuid)r  rv   r!   r  get_overloadsrC   manglerr   r(   r'  rp   r(  r[   ro   r  
startswithcall_internalcall_unresolved)
rM   r  r  r   r  rec_ovr*  r'  mangled_namer  s
             rO   r  zLower._lower_call_RecursiveCall7  s    %%)TYYTXX
 ##INN3,,&&9/;;''v	(0fjjB <<  %%00>,,,,dkk9gC 
 ,,..lIwC 
rQ   c                    | j                  d       t        j                  |      }|j                  |      s$t	        d| dt        j
                  |             | j                  |||j                  |j                  |j                        }| j                  |j                  |j                  j                  ||      S )Nz## calling first-class function typez%mismatch of function types: expected z	 but got )r   r
   rr  check_signaturer   r  r  rv   r!   r  )_Lower__call_first_class_function_pointerftyperg   r  )rM   r  r  r   r   r  s         rO   r  zLower._lower_call_FunctionTypeL  s    >?ooi(##I."!F)E,>,>s,C+DFG G %%#tyy$++txx
 77JJ		W
 	
rQ   c           	      ~   | j                   }| j                  }| j                  |      } t        j                  | j                  |            |||      }|j                  }	d| |	_        |}
t        j                  ||
j                  |j                              }|j                  t        j                  ||	      d      }|5 \  }}|5  | j                  |||      }|j                  ||      }|j                  ||       ddd       |5  |
j                   j#                  |j                  |j$                        j'                         }|j)                  |	|      }|
j                   j+                  |||j                  |j$                  |      \  }}t        j,                  ||j.                        5  |j                   j1                  ||       ddd       |j                  ||       ddd       ddd       |j3                  |      S # 1 sw Y   xY w# 1 sw Y   IxY w# 1 sw Y   ;xY w# 1 sw Y   ?xY w)a  
        Calls a first-class function pointer.

        This function is responsible for calling a first-class function pointer,
        which can either be a JIT-compiled function or a Python function. It
        determines if a JIT address is available, and if so, calls the function
        using the JIT address. Otherwise, it calls the function using a function
        pointer obtained from the `__get_first_class_function_pointer` method.

        Args:
            ftype: The type of the function.
            fname: The name of the function.
            sig: The signature of the function.
            argvals: The argument values to pass to the function.

        Returns:
            The result of calling the function.
        r  jit_addr_of_FlikelyN)rC   r[   r   r   create_struct_proxyr   jit_addrr  alloca_onceget_value_typer  r  r  (_Lower__get_first_class_function_pointerr  storerT   get_function_typerv   
as_pointerbitcastcall_functionif_unlikelyr  return_status_propagateload)rM   r3  fnamer   r  rC   r[   fstructstructr:  ctxres_slotif_jit_addr_is_nullr  r  func_ptrr  lltystatuss                      rO   #__call_first_class_function_pointerz)Lower.__call_first_class_function_pointer[  s   & ,,,,,,u%@,,T[[-?@WG
 ??&ug.&&w'*'9'9#//'JL &ooOOGX. . 
 ! 	-NT6 -BB5#'ll8W5c8,	-  -}}66OOHH *,  #??8T:!mm99Xs' ((&//B O%%==gvNOc8,-	-( ||H%%'- - O O- -	- 	-sU   H38H
H3B'H'6HH'-H3H	H3H$ H''H0	,H33H<c           	      h   ddl m} | j                  j                  |      }| j	                  |      }| j
                  j                  |dd|z        }t        j                  | j
                  |d|z        }| j
                  j                  t        j                  | j
                  |      d      5 \  }	}
|	5  | j                          | j                  j                         }| j
                  j                  |dd	|z        } || j                  | j
                  ||d
      }| j
                  j                  t        j                  | j
                  |      d      5  | j                  t         | df| j"                         d d d        | j                  j%                  |      }| j
                  j'                  | j
                  j)                  ||      |       | j                  j+                  |       | j                  j-                  |       d d d        |
5  | j
                  j'                  | j
                  j)                  ||      |       d d d        d d d        | j
                  j/                  |      S # 1 sw Y   xY w# 1 sw Y   yxY w# 1 sw Y   DxY w# 1 sw Y   HxY w)Nr   )lower_get_wrapper_addressz
addr_of_%s)r  z
fptr_of_%sFr7  rc   zpyaddr_of_%signore)failure_modez function address is null)r   rA   ) numba.experimental.function_typerQ  rC   r<  r   r[   r  r   r;  r  r  ra   rY   r  r  r   RuntimeErrorrA   long_as_voidptrr>  rA  r  r  rE  )rM   r3  rF  r   rQ  rM  rG  addrfptrr  r  r  pyaddraddr1addr2s                  rO   "__get_first_class_function_pointerz(Lower.__get_first_class_function_pointer  s]   N||**51,,u%||))'1/;u/E * G ""4<<(4(>@\\!!d3 "  	K!/$ 2! JJ113	33Q'51 4 3 2LL$,,!)+ \\))e<U * L &))$%*G+D"E!G HH * && 

2259""4<<#7#7t#DdK

!!%(

&&y1-2.  K""4<<#7#7d#CTJK5	K8 ||  &&& &2 2.K K5	K 	KsV   4J(:B(J"'J	BJ
J("7JJ(J	JJ	J(J%	!J((J1c                    | j                  dj                  |             | j                  dj                  |             t        |t        j                        r|j
                  j                  }n3| j                  |||j                  |j                  |j                        }|j                  }|7ddlm}  ||      }|j                  j                  }|j                  ||      }	n| j                   j                  ||      }	|j"                  r4| j%                  |j
                  j&                        }
|
gt)        |      z   } |	| j*                  || j,                        }|S )Nz# calling normal function: {0}z# signature: {0}r   )resolve_dispatcher_from_str)r   r   r  r
   r  rg   rv   r  r!   r  r  numba.core.target_extensionr^  targetdescrtarget_contextr   rC   recvrr   r  r  r[   rA   )rM   r  r  r   r  tnamer^  disphw_ctxr   the_selfr  s               rO   r  zLower._lower_call_normal  s   9@@FG+229=>dE334iinnG))iDKKG O.u5D%%44F&&tY7D<<,,T9=D?? ||DIINN3Hj4=0G4<<$((3
rQ   c                 $   |j                   dk(  r| j                  |||j                        S |j                   dk(  rk| j                  |j                  j
                        }|j                  r| j                  |||j                        S | j                  |||j                        S |j                   dk(  r+| j                  |j                  j
                        }| j                  |j                  j
                        }| j                  j                  j                  |j                        }| j                  j                  |   }| j                  j                  ||      }| j                  j!                  | j"                  |||j$                  d         } || j"                  |g      }	| j                  j!                  | j"                  |	|j&                  |      }	|	S |j                   dk(  r| j)                  ||      }	|	S |j                   dk(  r| j                  |j                  j
                        }| j                  |j                  j
                        }
| j                  j+                  | j"                  ||
      }	| j-                  ||	       |	S |j                   dk(  r| j                  |j                  j
                        }| j                  |j                  j
                        }
| j                  j/                  | j"                  ||
      }	| j-                  ||	       |	S |j                   dv r| j                  |j                  j
                        }| j                  |j                  j
                        }
| j                  j                  |   }| j                  j                  |j                   |      }|j$                  \  }| j                  j!                  | j"                  ||
|      } || j"                  |f      }	| j                  j!                  | j"                  |	|j&                  |      }	|	S |j                   d	k(  rW| j                  |j                  j
                        }| j                  |j                  j
                        }
t1        |
t2        j4                        r>| j                  j!                  | j"                  ||
|
j6                        }|
j6                  }
t1        |
t2        j8                        r|
|k(  sJ | j-                  |
|       |S |
j:                  j<                  }| j                  j?                  |      }t3        j@                  |t2        jB                        }tE        jF                  |
j:                  |
      }| j                  j                  d
|      }tE        jF                  ||
j:                        }| j                  j                  d|      } || j"                  |f      }tI        |jJ                        D ]  } || j"                  |f      }| j                  j/                  | j"                  ||      }tM        jN                  | j"                  | j"                  jQ                  |            5  | jS                  tT        | jV                         d d d        | j                  j+                  | j"                  ||      }| j"                  jY                  |||      }  || j"                  |f      }| j                  j/                  | j"                  ||      }tM        jN                  | j"                  |      5  | jS                  tT        | jV                         d d d        | j[                  |
j:                  |       |S |j                   dk(  r| j                  |j                  j
                        }| j                  |j                  j
                        }
t1        |t2        j\                        rw| j                  j!                  | j"                  ||
|j^                        }| j                  ja                  | j"                  ||j^                        }	| j-                  ||	       |	S | j                  jc                  |
|jd                        }| j                  j                  jg                  |
|jd                        }|| j                  ji                         S  || j                  | j"                  |
||jd                        }	| j                  j!                  | j"                  |	||      }	|	S |j                   dk(  rtE        jF                  || j                  |j                  j
                        tk        |jl                              }	 | j                  j                  d|      } || j"                  | j                  |j                  j
                        |jl                  f      S |j                   dk(  rtE        jF                  || j                  |j                  j
                        | j                  |jl                  j
                              }| j                  j                  d|      } || j"                  | j                  |j                  j
                        | j                  |jl                  j
                        f      S |j                   dk(  rB| j                  j                  |   }| js                  |||j                  |jl                  |      S |j                   dk(  r|jt                  D cg c]  }| j                  |j
                         }}|jt                  D cg c]  }| j                  |j
                         }}tw        |||      D cg c].  \  }}}| j                  j!                  | j"                  |||      0 }}}}| j                  jy                  | j"                  ||      }| j-                  ||       |S |j                   dk(  r|jt                  D cg c]  }| j                  |j
                         }}|jt                  D cg c]  }| j                  |j
                         }}t1        |t2        jz                        rtw        ||j2                  |      D cg c].  \  }}}| j                  j!                  | j"                  |||      0 }}}}| j                  jy                  | j"                  t3        j|                  |j2                        |      }| j-                  ||       |S tw        ||      D cg c]7  \  }}| j                  j!                  | j"                  |||j~                        9 }}}| j                  j                  | j"                  ||      S |j                   dk(  r|jt                  d d d   } | D cg c]  }| j                  |j
                         }}| D cg c]  }| j                  |j
                         }}tw        ||      D cg c]7  \  }}| j                  j!                  | j"                  |||j~                        9 }}}| j                  j                  | j"                  ||      S |j                   dk(  r|jt                  } g g }"}!g g }$}#| D ]  \  }%}&| j                  |%j
                        }'| j                  |%j
                        }(| j                  |&j
                        }| j                  |&j
                        })|!j                  |'       |"j                  |       |#j                  |(       |$j                  |)        | j                  j                  | j"                  |t        tw        |#|$            t        tw        |!|"                  S |j                   dk(  r| j                  |j                  j
                        }| j                  |j                  j
                        }
| j                  j!                  | j"                  ||
|      }| j-                  ||       |S |j                   dk(  rt        d      |j                   dk(  r| j                  j                  |      S |j                   dk(  r| j                  j                  |      S |j                   | j                  j                  v r, | j                  j                  |j                      | |      }	|	S to        |      # 1 sw Y   
xY w# 1 sw Y   	xY w# tn        $ rR |jp                   | j                  j                  |   }| js                  |||j                  |jp                  |      cY S w xY wc c}w c c}w c c}}}w c c}w c c}w c c}}}w c c}}w c c}w c c}w c c}}w )Nbinopinplace_binopunaryr   r  
pair_firstpair_second)getiteriternextexhaust_iterrm  rn  r   getattrstatic_getitemtyped_getitemr  build_tuple
build_list	build_setr&   	build_mapr7  phizPHI not strippednullundef)Hr  r  rj   r   r  r  mutableimmutable_fnr   r  rC   rT  rU  r(   rG  r   r7  r[   rv   r  r  rk  r{  rl  r  r
   rA  r9  r  iterator_typer  get_constant_undefPairr8  r   r   r  countr   rC  not_r   
ValueErrorrA   insert_valuer  BoundFunctionthisget_bound_functionget_getattrrZ  resolve_getattrr   r  r"   rH  rJ  r  r0   r  
make_tupleLiteralListTupledtypert  ru  r|  rv  r  r   get_constant_nullspecial_ops)*rM   r  r  r  rd  r  func_tyr   r   r  rc  ftycastvalitemtytuppairtygetiter_siggetiter_impliternext_sigiternext_impliterobjr  pairis_validitemcastedattrtyitemvalsitemtystotyfromtyr  r0   r?   r  	key_typesvalue_typeskr
  rP  keytypevaltypes*                                             rO   r  zLower.lower_expr  s5   77g##E499WW'++dhhmm,C{{''tTWW== ''tT5F5FGGWW,,tzz/C++djjoo.Cll11DDTWWMG--d3I<<,,Wi@D,,##DLL#sINN1<MNCt||cU+C,,##DLL#$-$9$95BCJWW//%.CJWW$,,tzz/CTZZ__-B,,))$,,R@CKKs#JWW%,,tzz/CTZZ__-B,,**4<<bACKKs#JWW//,,tzz/CTZZ__-B--d3I<<,,TWWi@DNNESll''c2sCGt||gZ0C,,##DLL#y7L7L$)+CJWW&,,tzz/CTZZ__-B"enn-ll''c2rwwGWW "eoo.U{"{B$
%%00F,,11%8CZZ6F **2+;+;R@K<<44Y5@BL!++FB4D4DEL LL55j6BDM"4<<#8G4::& 	>$T\\G:><<33DLL48&B(()-):):8)DF D))*$(()CD ||..t||/3V=ll//T1=	> !z:D||//04f>H$$T\\8< @%%jdhh%?@ KK(('2JWW	!,,tzz/CTZZ__-B%!4!45 **4<<b%**Mll55dllF6;jjBE3'
||//DII>44DDREIYYP <<<7799t||T\\2sDIINC ll''c65I
WW((((DJJOO,

+I
E ||001A9MDLL!\\$**//:DJJGI I WW'((DJJOO,DJJOO,I
 <<,,_iHDt||DJJOO'DTZZ__5'7 8 8WW	!--d3I%%eT4::tzz&/1 1 WW%6:jjAQVV,AHA48JJ?qt{{166*?G?14Xug1NP P-Cv ))$,,VTJ PH P,,))$,,xHCKKs#JWW$6:jjAQVV,AHA48JJ?qt{{166*?G?%!2!23585;;9@6BC C 1T6 !LL--dllCN C C ll--dll.3kk%++.F.68 E3'
 038W/EG +V !LL--dllC.3kk; G G ||..t||UHMMWW#JJtt$E6;<QVV,<H<49:qt{{166*:G: ,/x+AC'C ))$,,V*/++7 CH C <<))$,,xHHWW#JJEr&D%'{I ,1ll166*++aff-ll166*++aff-C c"  )""7+, <<))$,,*.s9k/J*K*.s4/@*AC C WW,,tzz/CTZZ__-Bll''c2uEGKKw'NWW 233WW<<11%88WW <<11%88WW0003$,,**4773D$?CJ!$''wD D@ @Z ' E>>) !KK11$7	))%tzz*...)E EE. B?P B?CG =:Cs}   "AE""AE(8AAE5 '"AG"AG3AG"AG$"AG))3AG.<AG5"AG;:"AH -<AHEAE%	E(AE2E5AAGGAGc                     || j                   v ry|| j                  vs| j                  r"| j                  ||      }|| j                   |<   yy)zT
        Ensure the given variable has an allocated stack slot (if needed).
        N)r=   r  r   alloca)rM   r  r'  ptrs       rO   r  zLower._alloca_var  sO     4;; 333++++dF+C #DKK	 ,rQ   c                     | j                   s || j                  vsJ || j                  vsJ || j                  vr!| j	                  || j                  |             | j                  |   S )z=
        Get a pointer to the given variable's slot.
        )r   r  r  r=   r  r   )rM   r  s     rO   getvarzLower.getvar  sk     **t55555t99999t{{" T4;;t#45{{4  rQ   c                 |   || j                   v r| j                  s| j                   |   S | j                  |      }|| j                  j                  v rDt        j                  | j                        5  | j                  j                  |      cddd       S | j                  j                  |      S # 1 sw Y   yxY w)z2
        Load the given variable's value.
        N)	r  r   r  r1   	arg_namesr   r   r[   rE  )rM   r  r  s      rO   r   zLower.loadvar  s     4)))$2M2M))$//kk$ 4<<)))++DLL9 .||((-. . <<$$S)). .s   2B22B;c           
         | j                  |      }| j                  ||       || j                  v r| j                  s|| j                  |<   y|#| j                  |      }| j                  ||       | j                  |      }|j                  |j                  j                  k7  r dj                  ||||      }t        |      |t        j                  | j                        5  | j                  j                  ||       ddd       | j                   }| j"                  j%                  |      }	| j"                  j'                  |	      }
| j"                  j(                  |   }| j                  j+                  | j                  |||	|
|j,                  ||       y| j                  j                  ||       y# 1 sw Y   xY w)z:
        Store the value into the given variable.
        NzNStoring {value.type} to ptr of {ptr.type.pointee} ('{name}'). FE type {fetype})r  r  r'  r  )r  lltypesizere   	datamodelr-  )r   r  r  r   r  r   r  r  r9  pointeer   AssertionErrorr   r   r[   r>  rH   rC   r<  get_abi_sizeofdata_model_managermark_variablere   )rM   r  r  r-  r'  oldr  rm   rA   r  sizeofr  s               rO   r4  zLower.storevar  s    T"v& D...//+0D""4(~ ll4(FC( ++d#CzzSXX---67=vEBEEKCG 8> 8I 
 %S))
 !//= 3LL&&uc23mm44V<44V< LL;;FC	,,T\\3T4:25((i4: - <
 ""5#.3 3s   (F==Gc                 4   | j                  |      }|| j                  vr5| j                  s)|| j                  v r| j                  j	                  |       | j                  ||       || j                  v r.| j                  s"| j                  |   }| j                  ||       y| j                  |      }| j                  || j                  j                  |             | j                  j                  t        |j                  j                  d      |       y)z,
        Delete the given variable.
        N)r   r  r   r  discardr  r  r  r[   rE  r>  r   r9  r  )rM   r  r'  llvalr  s        rO   rW  zLower.delvar*  s     T" ...//t111**2248 	v&4)))$2M2M**40EKK&++d#CKK 1 1# 67LLx(8(8$?ErQ   c                     | j                   j                  |      }| j                   j                  |   }| j                  |||      S )N)r  )rC   r<  r  alloca_lltype)rM   r  r9  r  r  s        rO   r  zLower.allocaC  sB    ,,T2LL33D9	!!$)!DDrQ   c           	      Z   |j                  d       }t        j                  | j                  ||d      }|rs|| j                  j
                  vr[| j                  j                  |      }| j                  j                  | j                  ||||| j                  j                  |       |S )N$F)r  zfill)r  r  r  re   r  )r+  r   r;  r[   r1   r  rC   r  r   r  rA   re   )rM   r  r  r  
is_uservaraptrr  s          rO   r  zLower.alloca_lltypeH  s    --
""4<<(,E;  4<<11144V<,,T\\4d4:26((--7@ - C rQ   c                     | j                   j                  sy | j                   j                  j                  | j                  ||       y rS   )rC   r   nrtr{  r[   rM   r  rd  s      rO   r{  zLower.incref\  s2    ||&&c37rQ   c                     | j                   j                  sy t        j                  | j                        5  | j                   j
                  j                  | j                  ||       d d d        y # 1 sw Y   y xY wrS   )rC   r   r   r   r[   r  r  r  s      rO   r  zLower.decrefb  s[    ||&&
 ''5 	<LL##DLL#s;	< 	< 	<s   2A22A;rS   ),r   r   r   r   r   rL   r   r   r   r   r   r   rI  r^  r\  r`  rb  r2  r  r  r  r  r  rL  r  r  r  r  r  r  r2  r=  r  r  r  r  r   r4  rW  r  r  r{  r  __classcell__)r   s   @rO   r   r   `  s    ..N.
 K K%$N$LJ2X:>*
E&OL06dL4D L(,?%N$:((T>@
+Z*
9&v&'P8p(d$ !*$,/\F2E
(8<rQ   r   c                 v    	 t        j                  |       S # t        $ r t        j                  |       cY S w xY w)zjReturns a Literal instance if the type of value is supported;
    otherwise, return `Omitted(value)`.
    )r
   r   r   r  r5  s    rO   r  r  m  s4    $}}U## $}}U##$s    88)/collectionsr   r   rR  rh   	functoolsr   llvmlite.irr:  r   r   
numba.corer   r	   r
   r   r   r   r   r   r   r   r   r   numba.core.errorsr   r   r   r   r   r   numba.core.funcdescr   numba.core.environmentr   numba.core.analysisr   r   numba.misc.firstlinefinderr   numba.misc.coverage_supportr   r    objectr$   r   r  rW   rQ   rO   <module>r     sx    /     +& & & &6 6 0 . A A A (;<D! D!N
J<I J<Z($rQ   