§
    1@Äj:¹  ã                   ó  — d dl mZ d dlZd dlZd dlmZmZ d dlmZ d dl	m
Z
 d dlmZ d dlmZ d dlmZ d dlmZmZmZmZmZmZmZmZ d d	lmZmZmZ d d
lm Z m!Z! d dl"m#Z# d dl$m%Z% d dl&m'Z'm(Z(m)Z)m*Z*m+Z+ d dl,m-Z-  ej.         ej/        d¦  «        ¦  «        Z0e0Z1e0Z2 G d„ de3¦  «        Z4ej5        d„ ¦   «         Z6 G d„ de3¦  «        Z7 G d„ de3¦  «        Z8d„ Z9 G d„ de3¦  «        Z:ej5        d„ ¦   «         Z; e;¦   «          dS )é    )ÚdefaultdictN)ÚpermutationsÚ	takewhile)Úcontextmanager)Úcached_property)Úir)ÚConstant)ÚtypesÚutilsÚ	datamodelÚ	debuginfoÚfuncdescÚconfigÚcgutilsÚimputils)ÚeventÚerrorsÚtargetconfig)Ú_dynfuncÚ
_helperlib)Úglobal_compiler_lock©Ú	PythonAPI)Úuser_functionÚuser_generatorÚbuiltin_registryÚimpl_ret_borrowedÚRegistryLoader)Úbuiltinsé   c                   óH   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ ZdS )ÚOverloadSelectora   
    An object matching an actual signature against a registry of formal
    signatures and choosing the best candidate, if any.

    In the current implementation:
    - a "signature" is a tuple of type classes or type instances
    - the "best candidate" is the most specific match
    c                 ó"   — g | _         i | _        d S ©N)ÚversionsÚ_cache©Úselfs    ú@C:\Projects\Historical\venv\Lib\site-packages\numba/core/base.pyÚ__init__zOverloadSelector.__init__%   s   € àˆŒØˆŒˆˆó    c                 ó|   — | j                              |¦  «        }|€|                      |¦  «        }|| j         |<   |S r$   )r&   ÚgetÚ_find)r(   ÚsigÚouts      r)   ÚfindzOverloadSelector.find*   s:   € ØŒk�oŠo˜cÑ"Ô"ˆØˆ;Ø—*’*˜S‘/”/ˆCØ"ˆDŒK˜ÑØˆ
r+   c                 ó˜   — |                       |¦  «        }|r||                      |¦  «                 S t          j        | › d|› �¦  «        ‚)Nz, )Ú_select_compatibleÚ_best_signaturer   ÚNumbaNotImplementedError)r(   r/   Ú
candidatess      r)   r.   zOverloadSelector._find1   sV   € Ø×,Ò,¨SÑ1Ô1ˆ
Øð 	DØ˜d×2Ò2°:Ñ>Ô>Ô?Ð?åÔ1°TÐ2BÐ2B¸SÐ2BÐ2BÑCÔCÐCr+   c                 óZ   — i }| j         D ] \  }}|                      ||¦  «        r|||<   Œ!|S )zL
        Select all compatible signatures and their implementation.
        )r%   Ú_match_arglist)r(   r/   r0   Úver_sigÚimpls        r)   r3   z#OverloadSelector._select_compatible8   sE   € ð ˆØ!œ]ð 	$ð 	$‰MˆG�TØ×"Ò" 7¨CÑ0Ô0ð $Ø#��G‘øØˆ
r+   c                 óÐ  ‡‡— |                       |¦  «        \  }Št          |¦  «        dk    r²‰|d                  Št          t          ˆˆfd„|¦  «        ¦  «        }t          |¦  «        dk    rpd                     t          |¦  «        ¬¦  «        g}|D ]"}|d                     |||         ¦  «        gz  }Œ#t          j        d                     |¦  «        ¦  «        ‚|d         S )zB
        Returns the best signature out of the candidates
        é   r   c                 ó   •— ‰|          ‰k    S r$   © )ÚxÚ
firstscoreÚ
genericitys    €€r)   ú<lambda>z2OverloadSelector._best_signature.<locals>.<lambda>J   s   ø€ ¨J°q¬M¸ZÒ,G€ r+   z{n} ambiguous signatures)Únz
{0} => {1}ú
)Ú_sort_signaturesÚlenÚlistr   Úformatr   ÚNumbaTypeErrorÚjoin)r(   r6   ÚorderedÚsameÚmsgr/   r@   rA   s         @@r)   r4   z OverloadSelector._best_signatureB   sñ   øø€ ð #×3Ò3°JÑ?Ô?Ñˆ�åˆw‰<Œ<˜!ÒÐØ# G¨A¤JÔ/ˆJÝ�	Ð"GÐ"GÐ"GÐ"GÐ"GØ")ñ+ô +ñ ,ô ,ˆDå�4‰yŒy˜1Š}ˆ}Ø1×8Ò8½3¸t¹9¼9Ð8ÑEÔEÐF�Øð Gð G�CØ˜L×/Ò/°°ZÀ´_ÑEÔEÐFÑF�C�CÝÔ+¨D¯IªI°c©N¬NÑ;Ô;Ð;Ø�qŒzÐr+   c                 ó$  ‡— t          t          ¦  «        Št          |                     ¦   «         d¬¦  «        D ].\  }}|                      ||¬¦  «        }|r‰|xx         dz  cc<   Œ/t          |                     ¦   «         ˆfd„¬¦  «        }|‰fS )z¿
        Sort signatures in ascending level of genericity.

        Returns a 2-tuple:

            * ordered list of signatures
            * dictionary containing genericity scores
        é   )Úr)Úformal_argsÚactual_argsr<   c                 ó   •— ‰|          S r$   r>   )r?   rA   s    €r)   rB   z3OverloadSelector._sort_signatures.<locals>.<lambda>d   s   ø€ ¸*ÀQ¼-€ r+   )Úkey)r   Úintr   Úkeysr8   Úsorted)r(   r6   ÚthisÚotherÚmatchedrK   rA   s         @r)   rE   z!OverloadSelector._sort_signaturesS   sª   ø€ õ !¥Ñ%Ô%ˆ
Ý'¨
¯ªÑ(9Ô(9¸QÐ?Ñ?Ô?ð 	&ð 	&‰KˆD�%Ø×)Ò)°dÈÐ)ÑNÔNˆGØð &à˜4Ð Ð Ô  AÑ%Ð Ð Ñ øå˜ŸšÑ*Ô*Ð0GÐ0GÐ0GÐ0GÐHÑHÔHˆØ˜
Ð"Ð"r+   c                 óh  — |r^t          |d         t          j        ¦  «        r>t          |¦  «        t          |¦  «        z
  dz   }|dd…         |d         j        f|z  z   }t          |¦  «        t          |¦  «        k    rdS t          ||¦  «        D ]\  }}|                      ||¦  «        s dS ŒdS )zÕ
        Returns True if the signature is "matching".
        A formal signature is "matching" if the actual signature matches exactly
        or if the formal signature is a compatible generic signature.
        éÿÿÿÿr<   NFT)Ú
isinstancer
   ÚVarArgrF   ÚdtypeÚzipÚ_match)r(   rQ   rR   ÚndiffÚformalÚactuals         r)   r8   zOverloadSelector._match_arglistg   sÌ   € ð ð 	N�: k°"¤oµu´|ÑDÔDð 	NÝ˜Ñ$Ô$¥s¨;Ñ'7Ô'7Ñ7¸!Ñ;ˆEØ% c r cÔ*¨k¸"¬oÔ.CÐ-EÈÑ-MÑMˆKåˆ{ÑÔ�s ;Ñ/Ô/Ò/Ð/Ø�5å! +¨{Ñ;Ô;ð 	ð 	‰NˆF�FØ—;’;˜v vÑ.Ô.ð Ø�u�uðð ˆtr+   c                 ó  — ||k    rdS t           j        |k    rdS t          |t          ¦  «        rSt	          |t           j        ¦  «        r;t          |t          ¦  «        rt	          ||¦  «        rdS t          ||¦  «        rdS d S d S d S )NT)r
   ÚAnyr]   ÚtypeÚ
issubclassÚType)r(   rc   rd   s      r)   ra   zOverloadSelector._match{   s¦   € Ø�VÒÐà�4ÝŒY˜&Ò Ð à�4Ý˜¥Ñ%Ô%ð 	­*°V½U¼ZÑ*HÔ*Hð 	Ý˜&¥$Ñ'Ô'ð ­J°v¸vÑ,FÔ,Fð à�tÝ˜F FÑ+Ô+ð à�tð	ð 	ð 	ð 	ðð r+   c                 ó²   — t          |t          ¦  «        sJ ||f¦   «         ‚| j                             ||f¦  «         | j                             ¦   «          dS )zB
        Add a formal signature and its associated value.
        N)r]   Útupler%   Úappendr&   Úclear)r(   Úvaluer/   s      r)   rl   zOverloadSelector.appendŠ   sZ   € õ ˜#�uÑ%Ô%Ð3Ð3¨¨s |Ñ3Ô3Ð%ØŒ×Ò˜c 5˜\Ñ*Ô*Ð*ØŒ×ÒÑÔÐÐÐr+   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r*   r1   r.   r3   r4   rE   r8   ra   rl   r>   r+   r)   r"   r"      s¨   € € € € € ðð ðð ð ð
ð ð ðDð Dð Dðð ð ðð ð ð"#ð #ð #ð(ð ð ð(ð ð ðð ð ð ð r+   r"   c                  óÜ  — t          j        dt          d¦  «        ¦  «         t          j        t
          j        fD ]6} |                      ¦   «         D ]\  }}d|z   }t          j        ||¦  «         Œ Œ7t          j        j	         
                    ¦   «         D ]V}t          |t          ¦  «        r?t          |t          ¦  «        r*t          j        d|j        z  t          |¦  «        ¦  «         ŒWdS )zM
    Execute once to install special symbols into the LLVM symbol table.
    Ú_Py_NoneStructNÚnumba_zPyExc_%s)ÚllÚ
add_symbolÚidr   Ú	c_helpersr   Úitemsr   r   Ú__dict__Úvaluesr]   rg   rh   ÚBaseExceptionro   )ry   Úpy_nameÚ	c_addressÚc_nameÚobjs        r)   Ú_load_global_helpersr‚   “   sð   € õ „MÐ"¥B t¡H¤HÑ-Ô-Ð-õ !Ô*­HÔ,>Ð?ð -ð -ˆ	Ø"+§/¢/Ñ"3Ô"3ð 	-ð 	-ÑˆG�YØ Ñ'ˆFÝŒM˜& )Ñ,Ô,Ð,Ð,ð	-õ
 Œ~Ô&×-Ò-Ñ/Ô/ð @ð @ˆÝ�c�4Ñ Ô ð 	@¥Z°µ]Ñ%CÔ%Cð 	@ÝŒM˜*¨¬Ñ5µr¸#±w´wÑ?Ô?Ð?øð@ð @r+   c                   óH  — e Zd ZdZdZdZdZdZej	        Z	e
d„ ¦   «         Zej        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dœd„Zd„ Zd„ Zd„ Zd„ Ze
d„ ¦   «         Zed„ ¦   «         Z ed„ ¦   «         Z!d„ Z"d„ Z#d„ Z$d„ Z%d„ Z&d„ Z'd„ Z(djd„Z)djd„Z*d„ Z+d„ Z,d„ Z-dkd „Z.d!„ Z/d"„ Z0dld#„Z1d$„ Z2d%„ Z3d&„ Z4d'„ Z5d(„ Z6dld)„Z7dld*„Z8d+„ Z9d,„ Z:d-„ Z;d.„ Z<dmd0„Z=d1„ Z>d2„ Z?d3„ Z@d4„ ZAd5„ ZBd6„ ZCd7„ ZDd8„ ZEd9„ ZFd:„ ZGd;„ ZHd<„ ZId=„ ZJd>„ ZKd?„ ZLd@„ ZMdA„ ZNdB„ ZOdndC„ZPdD„ ZQdE„ ZRdldF„ZSdG„ ZTdH„ ZUdI„ ZVdJ„ ZWdK„ ZXdL„ ZY	 	 dkdM„ZZ	 	 dodN„Z[dldO„Z\dP„ Z]dQ„ Z^dR„ Z_dS„ Z`dT„ ZadU„ ZbdpdW„ZcdqdX„ZddkdY„ZedldZ„Zfd[„ Zgd\„ Zhdld]„Zid^„ Zjd_„ Zkd`„ Zlda„ Zmdb„ Zndc„ Zodd„ Zpde„ Zqe
df„ ¦   «         Zresdg„ ¦   «         Ztdh„ Zudi„ ZvdS )rÚBaseContexta   

    Notes on Structure
    ------------------

    Most objects are lowered as plain-old-data structure in the generated
    llvm.  They are passed around by reference (a pointer to the structure).
    Only POD structure can live across function boundaries by copying the
    data.
    Fc                 ó@   — t           j        �t           j        S | j        S r$   )r   ÚBOUNDSCHECKÚ_boundscheckr'   s    r)   Úenable_boundscheckzBaseContext.enable_boundscheck¿   s   € åÔÐ)ÝÔ%Ð%ØÔ Ð r+   c                 ó   — || _         d S r$   )r‡   )r(   rn   s     r)   rˆ   zBaseContext.enable_boundscheckÅ   s   € à!ˆÔÐÐr+   Nc                 ó  — t          ¦   «          t          j        | _        || _        ddlm} || _        ||         | _        i | _	        t          t          ¦  «        | _        t          t          ¦  «        | _        t          t          ¦  «        | _        t          ¦   «         | _        t          ¦   «         | _        i | _        i | _        i | _        d | _        g | _        d| _        t.          j        | _        |                      ¦   «          d S )Nr   )Útarget_registryF)r‚   r   ÚMACHINE_BITSÚaddress_sizeÚtyping_contextÚnumba.core.target_extensionr‹   Útarget_nameÚtargetÚ_registriesr   r"   Ú_defnsÚ	_getattrsÚ	_setattrsÚ_castsÚ_get_constantsÚ_generatorsÚspecial_opsÚcached_internal_funcÚ_pidÚ_codelib_stackr‡   r   Údefault_managerÚdata_model_managerÚinit)r(   rŽ   r‘   r‹   s       r)   r*   zBaseContext.__init__á   sé   € ÝÑÔÐå!Ô.ˆÔØ,ˆÔØ?Ð?Ð?Ð?Ð?Ð?Ø!ˆÔØ% fÔ-ˆŒð ˆÔå!Õ"2Ñ3Ô3ˆŒÝ$Õ%5Ñ6Ô6ˆŒÝ$Õ%5Ñ6Ô6ˆŒÝ&Ñ(Ô(ˆŒÝ.Ñ0Ô0ˆÔàˆÔØˆÔØ$&ˆÔ!ØˆŒ	Ø ˆÔà!ˆÔå"+Ô";ˆÔð 	�	Š	‰Œˆˆˆr+   c                 ó   — dS )z3
        For subclasses to add initializer
        Nr>   r'   s    r)   rŸ   zBaseContext.init   ó   € € € r+   c                 ó”   — |                       ¦   «          |                      t          ¦  «         | j                             ¦   «          dS )zy
        Refresh context with new declarations from known registries.
        Useful for third-party extensions.
        N)Úload_additional_registriesÚinstall_registryr   rŽ   Úrefreshr'   s    r)   r¥   zBaseContext.refresh  sJ   € ð 	×'Ò'Ñ)Ô)Ð)ð 	×ÒÕ.Ñ/Ô/Ð/ð 	Ô×#Ò#Ñ%Ô%Ð%Ð%Ð%r+   c                 ó   — dS )zT
        Load target-specific registries.  Can be overridden by subclasses.
        Nr>   r'   s    r)   r£   z&BaseContext.load_additional_registries  r¡   r+   r>   ©Úabi_tagsÚuidc                ó2   — t          j        ||||¬¦  «        S )z(
        Perform name mangling.
        r§   )r   Údefault_mangler)r(   Únamer
   r¨   r©   s        r)   ÚmanglerzBaseContext.mangler  s   € õ Ô'¨¨e¸hÈCÐPÑPÔPÐPr+   c                 ó   — |j         S )zÜGet the environment name given a FunctionDescriptor.

        Use this instead of the ``fndesc.env_name`` so that the target-context
        can provide necessary mangling of the symbol to meet ABI requirements.
        )Úenv_name)r(   Úfndescs     r)   Úget_env_namezBaseContext.get_env_name"  s   € ð ŒÐr+   c                 óÄ   — ||j         vrKt          j        |t          j        |¬¦  «        }d|_        t          j        |j        j        ¦  «        |_	        |j         |         S )aŒ  Declare the Environment pointer as a global of the module.

        The pointer is initialized to NULL.  It must be filled by the runtime
        with the actual address of the Env before the associated function
        can be executed.

        Parameters
        ----------
        module :
            The LLVM Module
        envname : str
            The name of the global variable.
        )r¬   Úcommon)
ÚglobalsÚllvmirÚGlobalVariabler   Ú	voidptr_tÚlinkageÚget_null_valuerg   ÚpointeeÚinitializer)r(   ÚmoduleÚenvnameÚgvs       r)   Údeclare_env_globalzBaseContext.declare_env_global*  sU   € ð ˜&œ.Ð(Ð(ÝÔ& v­wÔ/@ÀwÐOÑOÔOˆBØ!ˆBŒJÝ$Ô3°B´G´OÑDÔDˆBŒNàŒ~˜gÔ&Ð&r+   c                 ó6   — t          j        | j        |¦  «        S r$   )r   Ú	ArgPackerrž   )r(   Úfe_argss     r)   Úget_arg_packerzBaseContext.get_arg_packer?  s   € ÝÔ" 4Ô#:¸GÑDÔDÐDr+   c                 ó6   — t          j        | j        |¦  «        S r$   )r   Ú
DataPackerrž   )r(   Úfe_typess     r)   Úget_data_packerzBaseContext.get_data_packerB  s   € ÝÔ# DÔ$;¸XÑFÔFÐFr+   c                 ó   — t           ‚r$   ©ÚNotImplementedErrorr'   s    r)   Útarget_datazBaseContext.target_dataE  s   € å!Ð!r+   c                 ó   — t          ¦   «         S )zN
        All module attrs are constant for targets using BaseContext.
        )rk   r'   s    r)   Únonconst_module_attrsz!BaseContext.nonconst_module_attrsI  s   € õ
 ‰wŒwˆr+   c                 ó0   — ddl m}  || | j        ¦  «        S )Nr   )Ú
NRTContext)Únumba.core.runtime.contextrÏ   Ú
enable_nrt)r(   rÏ   s     r)   ÚnrtzBaseContext.nrtP  s(   € à9Ð9Ð9Ð9Ð9Ð9Øˆz˜$ ¤Ñ0Ô0Ð0r+   c                 óF  — t          j         | ¦  «        }|                     ¦   «         D ]H\  }}t          ||¦  «        s"t          d                     |¦  «        ¦  «        ‚t          |||¦  «         ŒI|                     ¦   «         |                      ¦   «         uri |_        |S )Nzunknown option {0!r})Úcopyrz   ÚhasattrÚ	NameErrorrH   ÚsetattrÚcodegenrš   )r(   Úkwsr�   ÚkÚvs        r)   Ú	subtargetzBaseContext.subtargetU  s•   € ÝŒi˜‰oŒoˆØ—I’I‘K”Kð 	ð 	‰DˆAˆqÝ˜3 ‘?”?ð BÝÐ 6× =Ò =¸aÑ @Ô @ÑAÔAÐAÝ�C˜˜AÑÔÐÐØ�;Š;‰=Œ= §¢¡¤Ð.Ð.à')ˆCÔ$Øˆ
r+   c                 ó  — 	 | j         |         }n)# t          $ r t          |¦  «        }|| j         |<   Y nw xY w|                      |                     d¦  «        ¦  «         |                      |                     d¦  «        ¦  «         |                      |                     d¦  «        ¦  «         |                      |                     d¦  «        ¦  «         |                      |                     d¦  «        ¦  «         dS )zx
        Install a *registry* (a imputils.Registry instance) of function
        and attribute implementations.
        Ú	functionsÚgetattrsÚsetattrsÚcastsÚ	constantsN)	r’   ÚKeyErrorr   Úinsert_func_defnÚnew_registrationsÚ_insert_getattr_defnÚ_insert_setattr_defnÚ_insert_cast_defnÚ_insert_get_constant_defn)r(   ÚregistryÚloaders      r)   r¤   zBaseContext.install_registry`  s  € ð
	0ØÔ% hÔ/ˆFˆFøÝð 	0ð 	0ð 	0Ý# HÑ-Ô-ˆFØ)/ˆDÔ˜XÑ&Ð&Ð&ð	0øøøð 	×Ò˜f×6Ò6°{ÑCÔCÑDÔDÐDØ×!Ò! &×":Ò":¸:Ñ"FÔ"FÑGÔGÐGØ×!Ò! &×":Ò":¸:Ñ"FÔ"FÑGÔGÐGØ×Ò˜v×7Ò7¸Ñ@Ô@ÑAÔAÐAØ×&Ò& v×'?Ò'?ÀÑ'LÔ'LÑMÔMÐMÐMÐMs   ‚ �#6µ6c                 óZ   — |D ]'\  }}}| j         |                              ||¦  «         Œ(d S r$   )r“   rl   )r(   Údefnsr:   Úfuncr/   s        r)   rä   zBaseContext.insert_func_defnp  sA   € Ø$ð 	0ð 	0‰OˆD�$˜ØŒK˜Ô×$Ò$ T¨3Ñ/Ô/Ð/Ð/ð	0ð 	0r+   c                 óZ   — |D ]'\  }}}| j         |                              ||¦  «         Œ(d S r$   )r”   rl   ©r(   rí   r:   Úattrr/   s        r)   ræ   z BaseContext._insert_getattr_defnt  óA   € Ø$ð 	3ð 	3‰OˆD�$˜ØŒN˜4Ô ×'Ò'¨¨cÑ2Ô2Ð2Ð2ð	3ð 	3r+   c                 óZ   — |D ]'\  }}}| j         |                              ||¦  «         Œ(d S r$   )r•   rl   rð   s        r)   rç   z BaseContext._insert_setattr_defnx  rò   r+   c                 óL   — |D ] \  }}| j                              ||¦  «         Œ!d S r$   )r–   rl   ©r(   rí   r:   r/   s       r)   rè   zBaseContext._insert_cast_defn|  s:   € Øð 	*ð 	*‰IˆD�#ØŒK×Ò˜t SÑ)Ô)Ð)Ð)ð	*ð 	*r+   c                 óL   — |D ] \  }}| j                              ||¦  «         Œ!d S r$   )r—   rl   rõ   s       r)   ré   z%BaseContext._insert_get_constant_defn€  s;   € Øð 	2ð 	2‰IˆD�#ØÔ×&Ò& t¨SÑ1Ô1Ð1Ð1ð	2ð 	2r+   c                 ór   — t          ||¦  «        }| j        |                              ||j        ¦  «         d S r$   )r   r“   rl   Ú	signature)r(   rî   r°   Úlibsr:   s        r)   Úinsert_user_functionz BaseContext.insert_user_function„  s6   € Ý˜V TÑ*Ô*ˆØŒ�DÔ× Ò   t¤~Ñ6Ô6Ð6Ð6Ð6r+   c                 óv   — t          |t          j        ¦  «        sJ ‚t          ||¦  «        }||f| j        |<   d S r$   )r]   r
   Ú	Generatorr   r˜   )r(   ÚgentyÚgendescrù   r:   s        r)   Úinsert_generatorzBaseContext.insert_generatorˆ  s@   € Ý˜%¥¤Ñ1Ô1Ð1Ð1Ð1Ý˜g tÑ,Ô,ˆØ")¨4 -ˆÔ˜ÑÐÐr+   c                 ó   — | j         |= dS )zl
        Remove user function *func*.
        KeyError is raised if the function isn't known to us.
        N)r“   )r(   rî   s     r)   Úremove_user_functionz BaseContext.remove_user_function�  s   € ð
 ŒK˜ÐÐÐr+   c                 óŒ   ‡ — ˆ fd„|j         D ¦   «         }‰                      |j        ¦  «        }t          j        ||¦  «        }|S )Nc                 ó:   •— g | ]}‰                      |¦  «        ‘ŒS r>   )Úget_argument_type)Ú.0Úatyr(   s     €r)   ú
<listcomp>z:BaseContext.get_external_function_type.<locals>.<listcomp>•  s7   ø€ ð 0ð 0ð 0Øð ×*Ò*¨3Ñ/Ô/ð 0ð 0ð 0r+   )Úargtypesr  Úrestyperµ   ÚFunctionType)r(   r°   r  r	  Úfntys   `    r)   Úget_external_function_typez&BaseContext.get_external_function_type”  s[   ø€ ð0ð 0ð 0ð 0Ø%œð0ñ 0ô 0ˆð ×(Ò(¨¬Ñ8Ô8ˆÝÔ" 7¨HÑ5Ô5ˆØˆr+   c                 óÌ  — | j                              |j        |j        ¦  «        }t	          j        |||j        ¦  «        }|                      ||j        |j        ¦  «         | j                              ||j	        |j        |j
        ¬¦  «         |j        rN|j                             d¦  «         |j                             d¦  «         |j                             d¦  «         |S )N)ÚnoaliasÚalwaysinlineÚnoinlineÚoptnone)Ú	call_convÚget_function_typer	  r  r   Úget_or_insert_functionÚmangled_nameÚapply_target_attributesÚdecorate_functionÚargsr  ÚinlineÚ
attributesÚaddÚdiscard)r(   r¼   r°   r  Úfns        r)   Údeclare_functionzBaseContext.declare_functionœ  sÈ   € ØŒ~×/Ò/°´ÀÄÑPÔPˆÝÔ+¨F°D¸&Ô:MÑNÔNˆØ×$Ò$ R¨¬¸&¼.ÑIÔIÐIØŒ×(Ò(¨¨V¬[¸&¼/ÐSYÔSaÐ(ÑbÔbÐbØŒ=ð 	-ØŒM×Ò˜nÑ-Ô-Ð-àŒM×!Ò! *Ñ-Ô-Ð-ØŒM×!Ò! )Ñ,Ô,Ð,Øˆ	r+   c                 ó   — dS )zY
        Hook for subclasses to apply target-specific attributes (e.g. signext).
        Nr>   )r(   Ú	llvm_funcr  r	  s       r)   r  z#BaseContext.apply_target_attributes©  s	   € ð 	ˆr+   c                 óÌ   — |                       |¦  «        }t          j        |||j        ¦  «        }|j        sJ ‚t          |j        |j        ¦  «        D ]\  }}d|z  |_        Œ|S )Nzarg.%s)r  r   r  r  Úis_declarationr`   r  r¬   )r(   r¼   r°   r  r  ÚakÚavs          r)   Údeclare_external_functionz%BaseContext.declare_external_function¯  sn   € Ø×.Ò.¨vÑ6Ô6ˆÝÔ+¨F°D¸&Ô:MÑNÔNˆØÔ Ð Ð Ð Ý˜&œ+ r¤wÑ/Ô/ð 	$ð 	$‰FˆB�Ø ‘mˆBŒGˆGØˆ	r+   c                 óÆ   — t           }d|z  }t          j        |                     d¦  «        dz   ¦  «        }|                      |||¦  «        }t          j        ||¦  «        S )zL
        Insert constant *string* (a str object) into module *mod*.
        z	.const.%szutf-8ó    )ÚGENERIC_POINTERr   Úmake_bytearrayÚencodeÚinsert_unique_constr	   Úbitcast)r(   ÚmodÚstringÚ
stringtyper¬   Útextr¾   s          r)   Úinsert_const_stringzBaseContext.insert_const_string·  s^   € õ %ˆ
Ø˜VÑ#ˆÝÔ% f§m¢m°GÑ&<Ô&<¸wÑ&FÑGÔGˆØ×%Ò% c¨4°Ñ6Ô6ˆÝÔ  JÑ/Ô/Ð/r+   c                 ó¸   — t           }d|pt          |¦  «        z  }t          j        |¦  «        }|                      |||¦  «        }t          j        ||¦  «        S )zN
        Insert constant *byte* (a `bytes` object) into module *mod*.
        z	.bytes.%s)r(  Úhashr   r)  r+  r	   r,  )r(   r-  Úbytesr¬   r/  r0  r¾   s          r)   Úinsert_const_byteszBaseContext.insert_const_bytesÁ  sX   € õ %ˆ
Ø˜dÐ1¥d¨5¡k¤kÑ2ˆÝÔ% eÑ,Ô,ˆØ×%Ò% c¨4°Ñ6Ô6ˆÝÔ  JÑ/Ô/Ð/r+   c                 ó~   — 	 |                      |¦  «        }|S # t          $ r t          j        |||¦  «        cY S w xY w)zs
        Insert a unique internal constant named *name*, with LLVM value
        *val*, into module *mod*.
        )Ú
get_globalrã   r   Úglobal_constant)r(   r-  r¬   Úvalr¾   s        r)   r+  zBaseContext.insert_unique_constË  sW   € ð
	Ø—’ Ñ%Ô%ˆBð ˆIøõ ð 	;ð 	;ð 	;ÝÔ*¨3°°cÑ:Ô:Ð:Ð:Ð:ð	;øøøs   ‚ ™ <»<c                 ó@   — | j         |                              ¦   «         S r$   )rž   r  ©r(   Útys     r)   r  zBaseContext.get_argument_type×  s   € ØÔ& rÔ*×<Ò<Ñ>Ô>Ð>r+   c                 ó@   — | j         |                              ¦   «         S r$   )rž   Úget_return_typer;  s     r)   r>  zBaseContext.get_return_typeÚ  s   € ØÔ& rÔ*×:Ò:Ñ<Ô<Ð<r+   c                 ó@   — | j         |                              ¦   «         S )a   
        Get a LLVM data representation of the Numba type *ty* that is safe
        for storage.  Record data are stored as byte array.

        The return value is a llvmlite.ir.Type object, or None if the type
        is an opaque pointer (???).
        ©rž   Úget_data_typer;  s     r)   rA  zBaseContext.get_data_typeÝ  s   € ð Ô& rÔ*×8Ò8Ñ:Ô:Ð:r+   c                 ó@   — | j         |                              ¦   «         S r$   )rž   Úget_value_typer;  s     r)   rC  zBaseContext.get_value_typeç  s   € ØÔ& rÔ*×9Ò9Ñ;Ô;Ð;r+   c                 óx   — | j         |                              ||¦  «        }|                     |||¬¦  «         dS )zµ
        Pack value into the array storage at *ptr*.
        If *align* is given, it is the guaranteed alignment for *ptr*
        (by default, the standard ABI alignment).
        )ÚalignN)rž   Úas_dataÚstore)r(   Úbuilderr<  rn   ÚptrrE  Údatavals          r)   Ú
pack_valuezBaseContext.pack_valueê  s?   € ð Ô)¨"Ô-×5Ò5°g¸uÑEÔEˆØ�Š�g˜s¨%ˆÑ0Ô0Ð0Ð0Ð0r+   c                 óJ   — | j         |         }|                     |||¦  «        S )z·
        Unpack value from the array storage at *ptr*.
        If *align* is given, it is the guaranteed alignment for *ptr*
        (by default, the standard ABI alignment).
        )rž   Úload_from_data_pointer)r(   rH  r<  rI  rE  Údms         r)   Úunpack_valuezBaseContext.unpack_valueó  s)   € ð Ô$ RÔ(ˆØ×(Ò(¨°#°uÑ=Ô=Ð=r+   c                 ó˜   — 	 | j                              |f¦  «        } || |||¦  «        S # t          $ r t          d|›d�¦  «        ‚w xY w)zU
        Return a LLVM constant representing value *val* of Numba type *ty*.
        zCannot lower constant of type 'ú')r—   r1   rÊ   )r(   rH  r<  r9  r:   s        r)   Úget_constant_genericz BaseContext.get_constant_genericü  sm   € ð	TØÔ&×+Ò+¨R¨EÑ2Ô2ˆDØ�4˜˜g r¨3Ñ/Ô/Ð/øÝ"ð 	Tð 	Tð 	TÝ%Ð%ÈbÈbÈbÐ&RÑSÔSÐSð	Tøøøs	   ‚(+ «A	c                 ó0   — |                       d||¦  «        S )zx
        Same as get_constant_generic(), but without specifying *builder*.
        Works only for simple types.
        N)rR  )r(   r<  r9  s      r)   Úget_constantzBaseContext.get_constant  s   € ð ×(Ò(¨¨r°3Ñ7Ô7Ð7r+   c                 ó`   — |                       |¦  «        }t          |t          j        ¦  «        S r$   )rC  r	   rµ   Ú	Undefined©r(   r<  Últys      r)   Úget_constant_undefzBaseContext.get_constant_undef  s(   € Ø×!Ò! "Ñ%Ô%ˆÝ˜�VÔ-Ñ.Ô.Ð.r+   c                 óL   — |                       |¦  «        }t          |d ¦  «        S r$   )rC  r	   rW  s      r)   Úget_constant_nullzBaseContext.get_constant_null  s%   € Ø×!Ò! "Ñ%Ô%ˆÝ˜˜TÑ"Ô"Ð"r+   Tc                 óh  — |€J ‚|                      ¦   «         }t          |t          j        ¦  «        r#|                     |¦  «        }| j        |         }n|}| j        |         }	 t          |                     |j        ¦  «        | |¦  «        S # t          j
        $ r Y nw xY wt          |t          j        ¦  «        r4	 |                      t          |¦  «        |¦  «        S # t          $ r Y nw xY w|r,|                      ¦   «          |                      ||d¬¦  «        S t          d|›|›�¦  «        ‚)zœ
        Return the implementation of function *fn* for signature *sig*.
        The return value is a callable with the signature (builder, args).
        NF)Ú
_firstcallúNo definition for lowering )Úas_functionr]   r
   ÚCallableÚget_impl_keyr“   Ú
_wrap_implr1   r  r   r5   ri   Úget_functionrg   rÊ   r¥   )r(   r  r/   r]  rT   Ú	overloadss         r)   rc  zBaseContext.get_function  sJ  € ð
 ˆˆˆØ�oŠoÑÔˆÝ�b�%œ.Ñ)Ô)ð 	)Ø—/’/ #Ñ&Ô&ˆCØœ CÔ(ˆIˆIàˆCØœ CÔ(ˆIð	Ý˜iŸnšn¨S¬XÑ6Ô6¸¸cÑBÔBÐBøÝÔ.ð 	ð 	ð 	ØˆDð	øøøå�b�%œ*Ñ%Ô%ð 	ðØ×(Ò(­¨b©¬°3Ñ7Ô7Ð7øÝ&ð ð ð à�ðøøøð ð 	@Ø�LŠL‰NŒNˆNØ×$Ò$ R¨¸Ð$Ñ?Ô?Ð?å!Ð!ÀsÀsÈCÈCÐ"PÑQÔQÐQs$   Á&(B ÂB!Â B!Â?"C" Ã"
C/Ã.C/c                 ó(   — | j         |         d         S )ú	
        r   )r˜   )r(   rý   s     r)   Úget_generator_desczBaseContext.get_generator_desc8  s   € ð Ô Ô& qÔ)Ð)r+   c                 ót   — | j         |         d         }|                      t          |dd¦  «        ¦  «         |S )rf  r<   rù   r>   )r˜   Úadd_linking_libsÚgetattr)r(   rý   Úress      r)   Úget_generator_implzBaseContext.get_generator_impl=  s;   € ð Ô˜uÔ% aÔ(ˆØ×Ò�g c¨6°2Ñ6Ô6Ñ7Ô7Ð7Øˆ
r+   c                 óF   — |                       |¦  «        |j        k    sJ ‚|S r$   )rC  rg   )r(   rH  r�   r<  s       r)   Úget_bound_functionzBaseContext.get_bound_functionD  s(   € Ø×"Ò" 2Ñ&Ô&¨#¬(Ò2Ð2Ð2Ð2Øˆ
r+   c                 ó  ‡ ‡‡— ||f‰ j         v}t          |t          j        ¦  «        }|rY|rW‰ j                             ||¦  «        Š‰�t          ‰t          j        ¦  «        rdS t          |j        |¦  «        Šˆˆˆ fd„}|S ‰ j	        |         }	 | 
                    |f¦  «        S # t          j        $ r Y nw xY w‰ j	        d         }	 | 
                    |f¦  «        S # t          j        $ r Y nw xY wt          d|›d|›�¦  «        ‚)z¿
        Get the getattr() implementation for the given type and attribute name.
        The return value is a callable with the signature
        (context, builder, typ, val, attr).
        Nc                 óV   •— ‰                      |‰‰¦  «        }t          | |‰|¦  «        S r$   )rR  r   )	ÚcontextrH  Útypr9  rñ   ÚllvalÚattrtyÚpyvalr(   s	         €€€r)   Úimpz$BaseContext.get_getattr.<locals>.imp[  s.   ø€ Ø ×5Ò5°g¸vÀuÑMÔM�EÝ,¨W°g¸vÀuÑMÔMÐMr+   r^  ú.)rÍ   r]   r
   ÚModulerŽ   Úresolve_module_constantsÚDummyrj  Úpymodr”   r1   r   r5   rÊ   )	r(   rr  rñ   Ú
const_attrÚ	is_modulerv  rd  rt  ru  s	   `      @@r)   Úget_getattrzBaseContext.get_getattrH  sb  øøø€ ð ˜4�[¨Ô(BÐBˆ
Ý˜s¥E¤LÑ1Ô1ˆ	Øð 	˜ð 	ð Ô(×AÒAÀ#ÀtÑLÔLˆFØˆ~¥¨FµE´KÑ!@Ô!@ˆ~ð �tå ¤	¨4Ñ0Ô0�ðNð Nð Nð Nð Nð Nð Nð �
ð ”N 4Ô(ˆ	ð	Ø—>’> 3 &Ñ)Ô)Ð)øÝÔ.ð 	ð 	ð 	ØˆDð	øøøð ”N 4Ô(ˆ	ð	Ø—>’> 3 &Ñ)Ô)Ð)øÝÔ.ð 	ð 	ð 	ØˆDð	øøøõ "Ð!ÈÈÈÈTÈTÐ"RÑSÔSÐSs$   ÂB( Â(B:Â9B:ÃC! Ã!C3Ã2C3c                 óº  ‡ ‡‡— t          ‰j        ¦  «        dk    sJ ‚‰j        d         }‰j        d         }ˆˆ ˆfd„}‰ j        ‰         }	  ||                     ||f¦  «        ¦  «        S # t          j        $ r Y nw xY w‰ j        d         }	  ||                     ||f¦  «        ¦  «        S # t          j        $ r Y nw xY wt          d|›d‰›d|›�¦  «        ‚)	z±
        Get the setattr() implementation for the given attribute name
        and signature.
        The return value is a callable with the signature (builder, args).
        rO   r   r<   c                 ó   •‡ — ˆˆ ˆˆfd„}|S )Nc                 ó"   •—  ‰‰| ‰|‰¦  «        S r$   r>   )rH  r  rñ   r:   r(   r/   s     €€€€r)   Úwrappedz>BaseContext.get_setattr.<locals>.wrap_setattr.<locals>.wrappedz  s   ø€ Ø�t˜D '¨3°°dÑ;Ô;Ð;r+   r>   )r:   r‚  rñ   r(   r/   s   ` €€€r)   Úwrap_setattrz-BaseContext.get_setattr.<locals>.wrap_setattry  s1   øø€ ð<ð <ð <ð <ð <ð <ð <ð <àˆNr+   Nr^  rw  z = )rF   r  r•   r1   r   r5   rÊ   )r(   rñ   r/   rr  Úvaltyrƒ  rd  s   ```    r)   Úget_setattrzBaseContext.get_setattro  s2  øøø€ õ �3”8‰}Œ} Ò!Ð!Ð!Ð!ØŒh�qŒkˆØ”˜”ˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð ”N 4Ô(ˆ	ð	Ø�< 	§¢°°U¨|Ñ <Ô <Ñ=Ô=Ð=øÝÔ.ð 	ð 	ð 	ØˆDð	øøøð ”N 4Ô(ˆ	ð	Ø�< 	§¢°°U¨|Ñ <Ô <Ñ=Ô=Ð=øÝÔ.ð 	ð 	ð 	ØˆDð	øøøõ "Ð!Ø%( S S¨$¨$¨$°°ð#7ñ 8ô 8ð 	8s$   ÁA- Á-A?Á>A?ÂB0 Â0CÃCc                 óD   — | j         |                              ||¦  «        S )zG
        Argument representation to local value representation
        )rž   Úfrom_argument©r(   rH  r<  r9  s       r)   Úget_argument_valuezBaseContext.get_argument_valueŽ  s"   € ð Ô& rÔ*×8Ò8¸À#ÑFÔFÐFr+   c                 óD   — | j         |                              ||¦  «        S )zK
        Return value representation to local value representation
        )rž   Úfrom_returnrˆ  s       r)   Úget_returned_valuezBaseContext.get_returned_value”  s"   € ð Ô& rÔ*×6Ò6°wÀÑDÔDÐDr+   c                 óD   — | j         |                              ||¦  «        S )zJ
        Local value representation to return type representation
        )rž   Ú	as_returnrˆ  s       r)   Úget_return_valuezBaseContext.get_return_valueš  s"   € ð Ô& rÔ*×4Ò4°W¸cÑBÔBÐBr+   c                 óD   — | j         |                              ||¦  «        S )zKPrepare local value representation as argument type representation
        )rž   Úas_argumentrˆ  s       r)   Úget_value_as_argumentz!BaseContext.get_value_as_argument   s"   € ð Ô& rÔ*×6Ò6°wÀÑDÔDÐDr+   c                 óD   — | j         |                              ||¦  «        S r$   )rž   rF  rˆ  s       r)   Úget_value_as_datazBaseContext.get_value_as_data¥  s    € ØÔ& rÔ*×2Ò2°7¸CÑ@Ô@Ð@r+   c                 óD   — | j         |                              ||¦  «        S r$   )rž   Ú	from_datarˆ  s       r)   Úget_data_as_valuezBaseContext.get_data_as_value¨  s    € ØÔ& rÔ*×4Ò4°W¸cÑBÔBÐBr+   c                 ó>   — |                       |||¦  «        }|j        S )zD
        Extract the first element of a heterogeneous pair.
        )Úmake_helperÚfirst©r(   rH  r9  r<  Úpairs        r)   Ú
pair_firstzBaseContext.pair_first«  s#   € ð ×Ò ¨¨SÑ1Ô1ˆØŒzÐr+   c                 ó>   — |                       |||¦  «        }|j        S )zE
        Extract the second element of a heterogeneous pair.
        )r™  Úsecondr›  s        r)   Úpair_secondzBaseContext.pair_second²  s#   € ð ×Ò ¨¨SÑ1Ô1ˆØŒ{Ðr+   c           	      ó0  — |t           j        u r|                      |¦  «        S ||k    s|t           j        k    r|S 	 | j                             ||f¦  «        } || ||||¦  «        S # t          j        $ r t          j        d|›d|›d|›�¦  «        ‚w xY w)zÌ
        Cast a value of type *fromty* to type *toty*.
        This implements implicit conversions as can happen due to the
        granularity of the Numba type system, or lax Python semantics.
        zCannot cast z to z: )r
   Ú
_undef_varr[  rf   r–   r1   r   r5   )r(   rH  r9  ÚfromtyÚtotyr:   s         r)   ÚcastzBaseContext.cast¹  sÈ   € ð •UÔ%Ð%Ð%à×)Ò)¨$Ñ/Ô/Ð/Ø�tŠ^ˆ^˜t¥u¤yÒ0Ð0ØˆJð	BØ”;×#Ò# V¨T NÑ3Ô3ˆDØ�4˜˜g v¨t°SÑ9Ô9Ð9øÝÔ.ð 	Bð 	Bð 	BÝÔ1Ð1Ø.4¨f¨f°d°d°d¸C¸CÐ@ñBô Bð Bð	Bøøøs   ½*A( Á(-Bc                 ó´  — |\  }}|\  }}| j                              ||¦  «        }	|	€J ‚|                      ||||	¦  «        }
|                      ||||	¦  «        }| j                              |¦  «        }|                     | j         |	|	fi ¦  «        }|                      ||¦  «        }|                      t          |dd¦  «        ¦  «          |||
|f¦  «        S )z½
        Compare the given LLVM values of the given Numba types using
        the comparison *key* (e.g. '==').  The values are first cast to
        a common safe conversion type.
        Nrù   r>   )rŽ   Úunify_typesr¥  Úresolve_value_typeÚget_call_typerc  ri  rj  )r(   rH  rT   r  r  ÚatÚbtr$  Úbvr<  ÚcavÚcbvr  ÚcmpsigÚcmpfuncs                  r)   Úgeneric_comparezBaseContext.generic_compareË  sä   € ð ‰ˆˆBØ‰ˆˆBØÔ ×,Ò,¨R°Ñ4Ô4ˆØˆ~ˆ~ˆ~Ø�iŠi˜  R¨Ñ,Ô,ˆØ�iŠi˜  R¨Ñ,Ô,ˆØÔ"×5Ò5°cÑ:Ô:ˆà×#Ò# DÔ$7¸"¸b¸À2ÑFÔFˆØ×#Ò# D¨&Ñ1Ô1ˆØ×Ò�g g¨v°rÑ:Ô:Ñ;Ô;Ð;Øˆw�w  c 
Ñ+Ô+Ð+r+   c                 óœ   — |                       |t          j        |¦  «        ¦  «        }t          j        |_        |                     ¦   «         S r$   )r™  r
   ÚOptionalr   Ú	false_bitÚvalidÚ	_getvalue)r(   rH  ÚvaltypeÚoptvals       r)   Úmake_optional_nonezBaseContext.make_optional_noneÞ  s=   € Ø×!Ò! '­5¬>¸'Ñ+BÔ+BÑCÔCˆÝÔ(ˆŒØ×ÒÑ!Ô!Ð!r+   c                 óª   — |                       |t          j        |¦  «        ¦  «        }t          j        |_        ||_        |                     ¦   «         S r$   )r™  r
   r³  r   Útrue_bitrµ  Údatar¶  )r(   rH  r·  rn   r¸  s        r)   Úmake_optional_valuezBaseContext.make_optional_valueã  sD   € Ø×!Ò! '­5¬>¸'Ñ+BÔ+BÑCÔCˆÝÔ'ˆŒØˆŒØ×ÒÑ!Ô!Ð!r+   c                 óÀ   — | j                              t          ¦  «        }|                     | j         |fi ¦  «        }|                      ||¦  «        } |||f¦  «        S )zL
        Return the truth value of a value of the given Numba type.
        )rŽ   r¨  Úboolr©  rc  )r(   rH  rr  r9  r  r/   r:   s          r)   Úis_truezBaseContext.is_trueé  s_   € ð Ô"×5Ò5µdÑ;Ô;ˆØ× Ò  Ô!4°s°f¸bÑAÔAˆØ× Ò   sÑ+Ô+ˆØˆt�G˜c˜VÑ$Ô$Ð$r+   c                 óÈ   — |j         j        }	 |j        |         }nF# t          $ r9 t	          j        |||¦  «        }|r| j        rt          j        dk    rd|_	        Y nw xY w|S )zï
        Get a global value through its C-accessible *name*, with the given
        LLVM type.
        If *dllimport* is true, the symbol will be marked as imported
        from a DLL (necessary for AOT compilation under Windows).
        Úwin32Ú	dllimport)
Úfunctionr¼   r´   rã   r   Úadd_global_variableÚaot_modeÚsysÚplatformÚstorage_class)r(   rH  rr  r¬   rÃ  r¼   r¾   s          r)   Úget_c_valuezBaseContext.get_c_valueò  s   € ð Ô!Ô(ˆð	/Ø” Ô%ˆBˆBøÝð 	/ð 	/ð 	/ÝÔ,¨V°S¸$Ñ?Ô?ˆBØð /˜Tœ]ð /­s¬|¸wÒ/FÐ/FØ#.�Ô øøð	/øøøð ˆ	s   Ž œA AÁAc                 óp   ‡ ‡— ˆˆ fd„t          ||¦  «        D ¦   «         }‰                     ||¦  «        }|S )Nc                 óD   •— g | ]\  }}‰                      ‰||¦  «        ‘ŒS r>   )r’  )r  r<  ÚargrH  r(   s      €€r)   r  z6BaseContext.call_external_function.<locals>.<listcomp>  s?   ø€ ð 2ð 2ð 2Ù�B˜ð ×*Ò*¨7°B¸Ñ<Ô<ð 2ð 2ð 2r+   )r`   Úcall)r(   rH  ÚcalleeÚargtysr  Úretvals   ``    r)   Úcall_external_functionz"BaseContext.call_external_function  sS   øø€ ð2ð 2ð 2ð 2ð 2Ý" 6¨4Ñ0Ô0ð2ñ 2ô 2ˆà—’˜f dÑ+Ô+ˆØˆr+   c                 ó@   — | j         |                              ¦   «         S r$   r@  )r(   rr  s     r)   Úget_function_pointer_typez%BaseContext.get_function_pointer_type  s   € ØÔ& sÔ+×9Ò9Ñ;Ô;Ð;r+   c                 ó2   — |                      |||¬¦  «        S )N)Úcconv)rÎ  )r(   rH  Úfuncptrr  rÖ  s        r)   Úcall_function_pointerz!BaseContext.call_function_pointer  s   € Ø�|Š|˜G T°ˆ|Ñ7Ô7Ð7r+   c                 óÈ   — |j         }t          }t          j        t          j        d¦  «        |g¦  «        }t          j        ||d¦  «        }|                     ||g¦  «        S )Né    Úputs)r¼   r(  rµ   r
  ÚIntTyper   r  rÎ  )r(   rH  r0  r-  Úcstringr  rÛ  s          r)   Úprint_stringzBaseContext.print_string  sV   € ØŒnˆÝ!ˆÝÔ"¥6¤>°"Ñ#5Ô#5¸°yÑAÔAˆÝÔ-¨c°4¸Ñ@Ô@ˆØ�|Š|˜D 4 &Ñ)Ô)Ð)r+   c                 ó†   — |j         }|                      |t          |¦  «        ¦  «        }|                      ||¦  «         d S r$   )r¼   r1  ÚstrrÞ  )r(   rH  r0  r-  Úcstrs        r)   Údebug_printzBaseContext.debug_print  s@   € ØŒnˆØ×'Ò'¨­S°©Y¬YÑ7Ô7ˆØ×Ò˜' 4Ñ(Ô(Ð(Ð(Ð(r+   c                 óD  — |j         }t          |t          ¦  «        r|                      ||¦  «        }n|}t	          j        t	          j        d¦  «        t          fd¬¦  «        }t          j	        ||d¦  «        }| 
                    ||ft          |¦  «        z   ¦  «        S )NrÚ  T)Úvar_argÚprintf)r¼   r]   rà  r1  rµ   r
  rÜ  r(  r   r  rÎ  rk   )r(   rH  Úformat_stringr  r-  rá  r  r  s           r)   rå  zBaseContext.printf  s‘   € ØŒnˆÝ�m¥SÑ)Ô)ð 	!Ø×+Ò+¨C°Ñ?Ô?ˆDˆDà ˆDÝÔ"¥6¤>°"Ñ#5Ô#5½Ð7IÐSWÐXÑXÔXˆÝÔ+¨C°°xÑ@Ô@ˆØ�|Š|˜B  ­%°©+¬+Ñ 5Ñ6Ô6Ð6r+   c                 óR   ‡ — ˆ fd„|j         D ¦   «         }t          j        |¦  «        S )zR
        Get the LLVM struct type for the given Structure class *struct*.
        c                 ó@   •— g | ]\  }}‰                      |¦  «        ‘ŒS r>   )rC  )r  Ú_rÛ   r(   s      €r)   r  z/BaseContext.get_struct_type.<locals>.<listcomp>(  s+   ø€ ÐDÐDÐD©T¨Q°�$×%Ò% aÑ(Ô(ÐDÐDÐDr+   )Ú_fieldsrµ   ÚLiteralStructType)r(   ÚstructÚfieldss   `  r)   Úget_struct_typezBaseContext.get_struct_type$  s2   ø€ ð EÐDÐDÐD°V´^ÐDÑDÔDˆÝÔ'¨Ñ/Ô/Ð/r+   c                 óF   — t          |                      ¦   «         d ¦  «        S r$   )r	   Úget_dummy_typer'   s    r)   Úget_dummy_valuezBaseContext.get_dummy_value+  s   € Ý˜×+Ò+Ñ-Ô-¨tÑ4Ô4Ð4r+   c                 ó   — t           S r$   )r(  r'   s    r)   rð  zBaseContext.get_dummy_type.  s   € ÝÐr+   c                 ó<  — ddl m} |€i }t          5  |                      ¦   «         }|                     |j        ¦  «        }|€`t          j        ¦   «         }	|                     ¦   «         }|	r7|	 	                    ¦   «         }
|
 
                    d¦  «        r|
j        rd|_        d|_        d|_        d|_        |                     | j        | |||j        |j        ||¬¦  «        }| j                             |j        ¦  «         |cddd¦  «         S # 1 swxY w Y   dS )zÛ
        Invoke the compiler to compile a function to be used inside a
        nopython function, but without generating code to call that
        function.

        Note this context's flags are not inherited.
        r   )ÚcompilerNrÒ   T)Úlocals)Ú
numba.corerô  r   rØ   Úcreate_libraryro   r   ÚConfigStackÚFlagsÚtopÚis_setrÒ   Ú
no_compileÚno_cpython_wrapperÚno_cfunc_wrapperÚcompile_internalrŽ   r  Úreturn_typeÚactive_code_libraryÚadd_linking_libraryÚlibrary)r(   rH  r:   r/   rõ  Úflagsrô  rØ   r  ÚcstkÚ	tls_flagsÚcress               r)   Ú_compile_subroutine_no_cachez(BaseContext._compile_subroutine_no_cache1  st  € ð 	(Ð'Ð'Ð'Ð'Ð'àˆ>ØˆFÝ!ð 	ð 	Ø—l’l‘n”nˆGØ×,Ò,¨T¬]Ñ;Ô;ˆGØˆ}å#Ô/Ñ1Ô1�Ø ŸšÑ(Ô(�Øð )Ø $§¢¡
¤
�IØ ×'Ò'¨Ñ.Ô.ð )°9´=ð )Ø$(˜œ	à#ˆEÔØ'+ˆEÔ$Ø%)ˆEÔ"à×,Ò,¨TÔ-@À$Ø-4Ø-1°3´8Ø-0¬_¸eØ4:ð	 -ñ <ô <ˆDð Ô$×8Ò8¸¼ÑFÔFÐFØð1	ð 	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð 	ð 	s   ’C2DÄDÄDc                 óx  — |€i }|j         |t          | j        ¦  «        f}|sd}nB|j        r!|t	          d„ |j        D ¦   «         ¦  «        z  }| j                             |¦  «        }|€$|                      |||||¬¦  «        }	|	| j        |<   | j        |         }	| j         	                    |	j
        ¦  «         |	S )zÿ
        Compile the function *impl* for the given *sig* (in nopython mode).
        Return an instance of CompileResult.

        If *caching* evaluates True, the function keeps the compiled function
        for reuse in *.cached_internal_func*.
        Nc              3   ó$   K  — | ]}|j         V — Œd S r$   )Úcell_contents)r  Úcs     r)   ú	<genexpr>z1BaseContext.compile_subroutine.<locals>.<genexpr>k  s$   è è € Ð"MÐ"M°q 1¤?Ð"MÐ"MÐ"MÐ"MÐ"MÐ"Mr+   )rõ  r  )Ú__code__rg   Úerror_modelÚ__closure__rk   rš   r-   r  r  r  r  )
r(   rH  r:   r/   rõ  r  ÚcachingÚ	cache_keyÚcachedr  s
             r)   Úcompile_subroutinezBaseContext.compile_subroutineY  så   € ð ˆ>ØˆFØ”] C­¨dÔ.>Ñ)?Ô)?Ð@ˆ	Øð 	>ØˆFˆFàÔð Nð �UÐ"MÐ"M¸DÔ<LÐ"MÑ"MÔ"MÑMÔMÑM�	ØÔ.×2Ò2°9Ñ=Ô=ˆFØˆ>Ø×4Ò4°W¸dÀCØ<BØ;@ð 5ñ Bô BˆDð 48ˆDÔ% iÑ0àÔ(¨Ô3ˆàÔ ×4Ò4°T´\ÑBÔBÐBØˆr+   c                 ót   — |€i }|                       ||||¦  «        }|                      ||j        ||¦  «        S )zä
        Like compile_subroutine(), but also call the function with the given
        *args*.

        Notes
        -----
        Use of this API is discouraged. See coding_guidelines.rst in the
        developer docs.
        )r  Úcall_internalr°   )r(   rH  r:   r/   r  rõ  r  s          r)   rÿ  zBaseContext.compile_internalx  sC   € ð ˆ>ØˆFØ×&Ò& w°°c¸6ÑBÔBˆØ×!Ò! '¨4¬;¸¸TÑBÔBÐBr+   c                 ó  — |                       ||||¦  «        \  }}t          j        ||j        ¦  «        5  | j                             ||¦  «         ddd¦  «         n# 1 swxY w Y   t          j        | ||||¦  «        }|S )z’
        Given the function descriptor of an internally compiled function,
        emit a call to that function with the given arguments.
        N)Úcall_internal_no_propagater   Úif_unlikelyÚis_errorr  Úreturn_status_propagater   Úfix_returning_optional)r(   rH  r°   r/   r  Ústatusrk  s          r)   r  zBaseContext.call_internal‡  sÓ   € ð
 ×5Ò5°g¸vÀsÈDÑQÔQ‰ˆ�ÝÔ  ¨&¬/Ñ:Ô:ð 	Dð 	DØŒN×2Ò2°7¸FÑCÔCÐCð	Dð 	Dð 	Dñ 	Dô 	Dð 	Dð 	Dð 	Dð 	Dð 	Dð 	Døøøð 	Dð 	Dð 	Dð 	Dõ Ô-¨d°G¸SÀ&È#ÑNÔNˆØˆ
s   ¶AÁA"Á%A"c                 óš   — |j         }|                      ||¦  «        }| j                             |||j        |j        |¦  «        \  }}||fS )zpSimilar to `.call_internal()` but does not handle or propagate
        the return status automatically.
        )r¼   r  r  Úcall_functionr   r  )	r(   rH  r°   r/   r  Úllvm_modr  r  rk  s	            r)   r  z&BaseContext.call_internal_no_propagate“  sV   € ð
 ”>ˆØ×"Ò" 8¨VÑ4Ô4ˆØ”n×2Ò2°7¸BÀÄØ36´8¸TñCô C‰ˆ�à�sˆ{Ðr+   c                 óÆ  — |                       ¦   «         }| j                             |j        |j        ¦  «        }|                     |||¦  «        }| j                             |||j        |j        |¦  «        \  }}	t          j        ||j	        ¦  «        5  | j         
                    ||¦  «         ddd¦  «         n# 1 swxY w Y   t          j        | ||||	¦  «        }	|	S )aV  
        Insert a function call to an unresolved symbol with the given *name*.

        Note: this is used for recursive call.

        In the mutual recursion case::

            @njit
            def foo():
                ...  # calls bar()

            @njit
            def bar():
                ... # calls foo()

            foo()

        When foo() is called, the compilation of bar() is fully completed
        (codegen'ed and loaded) before foo() is. Since MCJIT's eager compilation
        doesn't allow loading modules with declare-only functions (which is
        needed for foo() in bar()), the call_unresolved injects a global
        variable that the "linker" can update even after the module is loaded by
        MCJIT. The linker would allocate space for the global variable before
        the bar() module is loaded. When later foo() module is defined, it will
        update bar()'s reference to foo().

        The legacy lazy JIT and the new ORC JIT would allow a declare-only
        function be used in a module as long as it is defined by the time of its
        first use.
        N)rØ   r  r  r   r  Úinsert_unresolved_refr  r   r  r  r  r   r  )
r(   rH  r¬   r/   r  rØ   r  r  r  rk  s
             r)   Úcall_unresolvedzBaseContext.call_unresolvedž  s"  € ð@ —,’,‘.”.ˆØŒ~×/Ò/°´ÀÄÑJÔJˆØ×*Ò*¨7°D¸$Ñ?Ô?ˆà”n×2Ò2°7¸BÀÄØ36´8¸TñCô C‰ˆ�åÔ  ¨&¬/Ñ:Ô:ð 	Dð 	DØŒN×2Ò2°7¸FÑCÔCÐCð	Dð 	Dð 	Dñ 	Dô 	Dð 	Dð 	Dð 	Dð 	Dð 	Dð 	Døøøð 	Dð 	Dð 	Dð 	Dõ Ô-¨d°G¸SÀ&È#ÑNÔNˆØˆ
s   ÂB>Â>CÃCc                 ó   — t           ‚r$   rÉ   )r(   rî   r°   Úenvs       r)   Úget_executablezBaseContext.get_executableÊ  s   € Ý!Ð!r+   c                 ó"   — t          | |¦  «        S r$   r   )r(   rH  s     r)   Úget_python_apizBaseContext.get_python_apiÍ  s   € Ý˜˜wÑ'Ô'Ð'r+   c                 ó`  — | j         r¤|                     |¦  «        }|                     |¦  «        }t          |t          j        ¦  «        r|j        }|                      |                      |¦  «        ¦  «        }||z  r.d 	                    |||¬¦  «        }t          j        |¦  «        ‚dS dS )zH
        Assumes offset starts from a properly aligned location
        z*{rec}.{attr} of type {type} is not aligned)Úrecrñ   rg   N)Ústrict_alignmentÚoffsetÚtypeofr]   r
   ÚNestedArrayr_   Úget_abi_alignmentrA  rH   r   rI   )r(   Úrectyprñ   r,  ÚelemtyrE  rM   s          r)   Úsentry_record_alignmentz#BaseContext.sentry_record_alignmentÐ  sÃ   € ð Ô ð 	1Ø—]’] 4Ñ(Ô(ˆFØ—]’] 4Ñ(Ô(ˆFÝ˜&¥%Ô"3Ñ4Ô4ð &ð  œ�Ø×*Ò*¨4×+=Ò+=¸fÑ+EÔ+EÑFÔFˆEØ˜‰~ð 1ØB×IÒIØ T°ð Jñ 8ô 8�åÔ+¨CÑ0Ô0Ð0ð	1ð 	1ð1ð 1r+   rn   c                 ó,   — t          j        ||¦  «        S )z9
        Get a helper class for the given *typ*.
        )r   Úcreate_struct_proxy)r(   rr  Úkinds      r)   Úget_helper_classzBaseContext.get_helper_classâ  s   € õ Ô*¨3°Ñ5Ô5Ð5r+   c                 óL   — |                       ||¦  «        } || |||¬¦  «        S )N)rn   Úref)r6  )r(   rH  rr  rn   r8  r5  Úclss          r)   Ú_make_helperzBaseContext._make_helperê  s0   € Ø×#Ò# C¨Ñ.Ô.ˆØˆs�4˜¨°3Ð7Ñ7Ô7Ð7r+   c                 ó6   — |                       ||||d¬¦  «        S )zn
        Get a helper object to access the *typ*'s members,
        for the given value or reference.
        rn   )r5  ©r:  )r(   rH  rr  rn   r8  s        r)   r™  zBaseContext.make_helperî  s#   € ð
 × Ò  ¨#¨u°cÀÐ ÑHÔHÐHr+   c                 ó4   — |                       |||d¬¦  «        S )zr
        As make_helper(), but considers the value as stored in memory,
        rather than a live value.
        r¼  )r8  r5  r<  )r(   rH  rr  r8  s       r)   Úmake_data_helperzBaseContext.make_data_helperõ  s!   € ð
 × Ò  ¨#°3¸VÐ ÑDÔDÐDr+   c                 ó8   — ddl m} |                     |¦  «        S )Nr   ©Úarrayobj)Únumba.nprA  Ú
make_array)r(   rr  rA  s      r)   rC  zBaseContext.make_arrayü  s(   € Ø%Ð%Ð%Ð%Ð%Ð%Ø×"Ò" 3Ñ'Ô'Ð'r+   c                 ó*   — ddl m}  |j        |fi |¤ŽS )z+
        Populate array structure.
        r   r@  )rB  rA  Úpopulate_array)r(   ÚarrÚkwargsrA  s       r)   rE  zBaseContext.populate_array   s1   € ð 	&Ð%Ð%Ð%Ð%Ð%Ø&ˆxÔ& sÐ5Ð5¨fÐ5Ð5Ð5r+   c                 óx   — t          |t          j        ¦  «        s
J |¦   «         ‚|                      |||¦  «        S )zS
        Get a helper object to access the given complex numbers' members.
        )r]   r
   ÚComplexr™  )r(   rH  rr  rn   s       r)   Úmake_complexzBaseContext.make_complex  s<   € õ ˜#�uœ}Ñ-Ô-Ð2Ð2¨sÑ2Ô2Ð-Ø×Ò ¨¨eÑ4Ô4Ð4r+   c                 óˆ   — |                       |¦  «        }t          |¦  «        D ]\  }}|                     |||¦  «        }Œ|S )zL
        Create a tuple of the given *typ* containing the *values*.
        )rY  Ú	enumerateÚinsert_value)r(   rH  rr  r|   ÚtupÚir9  s          r)   Ú
make_tuplezBaseContext.make_tuple  sP   € ð ×%Ò% cÑ*Ô*ˆÝ Ñ'Ô'ð 	4ð 	4‰FˆAˆsØ×&Ò& s¨C°Ñ3Ô3ˆCˆCØˆ
r+   c           	      ó†  ‡ — ‰                       |j        ¦  «        }d}‰ j        r’|j        dvs|j        |k    r~|j        j        }‰                      ||t          t          |¦  «        ¦  «        ¬¦  «        }‰                      |t          |¦  «        t          t          |¦  «        ¦  «        ¬¦  «        }n†|                     |j        ¬¦  «        }	t          j        t          j        d¦  «        t!          |	j        ¦  «        ¦  «        }
t          j        |d|
¦  «        }‰                      |¦  «        |_        d}‰                      t*          j        ¦  «        }ˆ fd„|j        D ¦   «         }t          j        ||¦  «        }ˆ fd	„|j        D ¦   «         }t          j        ||¦  «        } ‰                      |¦  «        ‰ |¦  «        }‰                      t*          j        |j        j        ¦  «        }‰                      ||                     ||j        j	        ¦  «        ||||d¬
¦  «         |                     ¦   «         S )z—
        Create an array structure reifying the given constant array.
        A low-level contiguous array constant is created in the LLVM IR.
        i@B ÚFC)Úinfo)Úorderr    z.const.array.dataNc                 óP   •— g | ]"}‰                      t          j        |¦  «        ‘Œ#S r>   ©rT  r
   Úintp©r  Úsr(   s     €r)   r  z3BaseContext.make_constant_array.<locals>.<listcomp>5  s+   ø€ ÐIÐIÐI¸!�T×&Ò&¥u¤z°1Ñ5Ô5ÐIÐIÐIr+   c                 óP   •— g | ]"}‰                      t          j        |¦  «        ‘Œ#S r>   rV  rX  s     €r)   r  z3BaseContext.make_constant_array.<locals>.<listcomp>9  s+   ø€ ÐLÐLÐL¸1�d×'Ò'­¬
°AÑ6Ô6ÐLÐLÐLr+   )r¼  ÚshapeÚstridesÚitemsizeÚparentÚmeminfo)rA  r_   Úallow_dynamic_globalsÚlayoutÚnbytesÚctypesr¼  Úadd_dynamic_addrrà  rg   rx   Úflattenr   Úcreate_constant_arrayrµ   rÜ  Ú	bytearrayr8  r/  rE  rC  r
   rW  r[  r\  rC  rT  r]  rE  r,  r¶  )r(   rH  rr  ÚaryÚdatatypeÚ
size_limitÚdataptrr¼  Úrt_addrÚflatÚconstsÚllintpÚ	shapevalsÚcshapeÚ
stridevalsÚcstridesÚcaryÚintp_itemsizes   `                 r)   Úmake_constant_arrayzBaseContext.make_constant_array  s  ø€ ð
 ×%Ò% c¤iÑ0Ô0ˆàˆ
àÔ&ð 	Ø” 4Ð'Ð'¨3¬:¸
Ò+BÐ+Bà”j”oˆGØ×(Ò(¨°'ÅÅDÈÁMÄMÑ@RÔ@RÐ(ÑSÔSˆDØ×+Ò+¨GµR¸±W´WÅ3ÅtÈCÁyÄyÁ>Ä>Ð+ÑRÔRˆGˆGð —;’; S¤Z�;Ñ0Ô0ˆDõ Ô2µ6´>À!Ñ3DÔ3DÅiÐPTÔPYÑFZÔFZÑ[Ô[ˆFÝÔ*¨7Ð4GÈÑPÔPˆDà×/Ò/°Ñ9Ô9ˆDŒJàˆGð ×$Ò$¥U¤ZÑ0Ô0ˆØIÐIÐIÐI¸s¼yÐIÑIÔIˆ	ÝÔ.¨v°yÑAÔAˆð MÐLÐLÐLÀÄÐLÑLÔLˆ
ÝÔ0°¸ÑDÔDˆð $ˆt�Š˜sÑ#Ô# D¨'Ñ2Ô2ˆà×)Ò)­%¬*°c´iÔ6HÑIÔIˆØ×Ò˜DØ!(§¢°°t´y´~Ñ!FÔ!FØ"(Ø$,Ø%2Ø#*Ø$(ð 	ñ 	*ô 	*ð 	*ð �~Š~ÑÔÐr+   c                 ó°  — | j         s
J d¦   «         ‚t          |t          ¦  «        s
J d¦   «         ‚|j        }|                      t
          j        ¦  «        }|                      t
          j        |¦  «         	                    |¦  «        }d 
                    |¦  «        }t          j        |||¦  «        }d|_        ||_        |                     |¦  «        S )zÑ
        Returns dynamic address as a void pointer `i8*`.

        Internally, a global variable is added to inform the lowerer about
        the usage of dynamic addresses.  Caching will be disabled.
        z#dyn globals disabled in this targetzdyn addr not of int typeznumba.dynamic.globals.{:x}Úlinkonce)r`  r]   rU   r¼   rC  r
   ÚvoidptrrT  ÚuintpÚinttoptrrH   r   rÅ  r¸   r»   Úload)	r(   rH  ÚintaddrrS  r-  Ú	llvoidptrÚaddrÚsymnamer¾   s	            r)   rd  zBaseContext.add_dynamic_addrJ  sÅ   € ð Ô)ÐPÐPÐ+PÑPÔPÐ)Ý˜'¥3Ñ'Ô'ÐCÐCÐ)CÑCÔCÐ'ØŒnˆØ×'Ò'­¬Ñ6Ô6ˆ	Ø× Ò ¥¤¨gÑ6Ô6×?Ò?À	ÑJÔJˆà.×5Ò5°gÑ>Ô>ˆÝÔ(¨¨i¸ÑAÔAˆð  ˆŒ
ØˆŒØ�|Š|˜BÑÔÐr+   c                 ó~   — t          |t          j        ¦  «        s
J d¦   «         ‚|                     | j        ¦  «        S )z5
        Get the ABI size of LLVM type *ty*.
        úExpected LLVM type)r]   rµ   ri   Úget_abi_sizerË   r;  s     r)   Úget_abi_sizeofzBaseContext.get_abi_sizeof_  s:   € õ ˜"�fœkÑ*Ô*Ð@Ð@Ð,@Ñ@Ô@Ð*Ø�Š˜tÔ/Ñ0Ô0Ð0r+   c                 ó~   — t          |t          j        ¦  «        s
J d¦   «         ‚|                     | j        ¦  «        S )z:
        Get the ABI alignment of LLVM type *ty*.
        r‚  )r]   rµ   ri   r/  rË   r;  s     r)   r/  zBaseContext.get_abi_alignmentf  s<   € õ ˜"�fœkÑ*Ô*Ð@Ð@Ð,@Ñ@Ô@Ð*Ø×#Ò# DÔ$4Ñ5Ô5Ð5r+   c                 ó   — dS )zD
        Get preferred array alignment for Numba type *ty*.
        rÚ  r>   )rq  r<  s     r)   Úget_preferred_array_alignmentz)BaseContext.get_preferred_array_alignmentm  s	   € ð
 ˆrr+   c                 ó   — dS )z?Run target specific post-lowering transformation here.
        Nr>   )r(   r-  r  s      r)   Úpost_loweringzBaseContext.post_loweringt  r¡   r+   c                 ó   — t           ‚)z¼Create a LLVM module

        The default implementation in BaseContext always raises a
        ``NotImplementedError`` exception. Subclasses should implement
        this method.
        rÉ   )r(   r¬   s     r)   Úcreate_modulezBaseContext.create_modulex  s
   € õ "Ð!r+   c                 ó   — | j         d         S )z$Get the active code library
        r\   )rœ   r'   s    r)   r  zBaseContext.active_code_library�  s   € ð Ô" 2Ô&Ð&r+   c              #   ó¶   K  — | j                              |¦  «         	 dV — | j                              ¦   «          dS # | j                              ¦   «          w xY w)z5Push the active code library for the context
        N)rœ   rl   Úpop)r(   Úlibs     r)   Úpush_code_libraryzBaseContext.push_code_library‡  sc   è è € ð 	Ô×"Ò" 3Ñ'Ô'Ð'ð	&ØˆEˆEˆEàÔ×#Ò#Ñ%Ô%Ð%Ð%Ð%øˆDÔ×#Ò#Ñ%Ô%Ð%Ð%øøøs	   ž= ½Ac                 óH   — | j         }|D ]}|                     |¦  «         ŒdS )zHAdd iterable of linking libraries to the *active_code_library*.
        N)r  r  )r(   rù   Úcolibr�  s       r)   ri  zBaseContext.add_linking_libs‘  s<   € ð Ô(ˆØð 	+ð 	+ˆCØ×%Ò% cÑ*Ô*Ð*Ð*ð	+ð 	+r+   c                 ó&   — t          | › d�¦  «        ‚)aý  Get the ufunc implementation for a given ufunc object.

        The default implementation in BaseContext always raises a
        ``NotImplementedError`` exception. Subclasses may raise ``KeyError``
        to signal that the given ``ufunc_key`` is not available.

        Parameters
        ----------
        ufunc_key : NumPy ufunc

        Returns
        -------
        res : dict[str, callable]
            A mapping of a NumPy ufunc type signature to a lower-level
            implementation.
        z does not support ufuncrÉ   )r(   Ú	ufunc_keys     r)   Úget_ufunc_infozBaseContext.get_ufunc_info˜  s   € õ" " TÐ"BÐ"BÐ"BÑCÔCÐCr+   )r>   )NNr$   )T)F)NNT)rn   )NNrn   )wro   rp   rq   rr   r+  Úimplement_powi_as_math_callÚimplement_pow_as_math_callÚenable_debuginfor   Ú	DIBuilderÚpropertyrˆ   ÚsetterrÑ   Úauto_parallelrÆ  r  r`  ÚfastmathÚenvironmentr°   r*   rŸ   r¥   r£   r­   r±   r¿   rÃ   rÇ   rË   r   rÍ   rÒ   rÜ   r¤   rä   ræ   rç   rè   ré   rú   rÿ   r  r  r  r  r%  r1  r5  r+  r  r>  rA  rC  rK  rO  rR  rT  rY  r[  rc  rg  rl  rn  r~  r…  r‰  rŒ  r�  r’  r”  r—  r�  r   r¥  r±  r¹  r½  rÀ  rÊ  rÒ  rÔ  rØ  rÞ  râ  rå  rî  rñ  rð  r  r  rÿ  r  r  r#  r&  r(  r2  r6  r:  r™  r>  rC  rE  rJ  rP  rv  rd  r„  r/  r‡  r‰  r‹  r  r   r�  ri  r•  r>   r+   r)   r„   r„   §   sP  € € € € € ð	ð 	ð Ðð #(ÐØ!&Ðð ÐØÔ#€Ið ð!ð !ñ „Xð!ð
 Ôð"ð "ñ Ôð"ð €Jð €Mð €Hð €Kð "Ðð €Hð €Kð €Fðð ð ð>ð ð ð
&ð &ð &ð$ð ð ð
 02°tð Qð Qð Qð Qð Qðð ð ð'ð 'ð 'ð*Eð Eð EðGð Gð Gð ð"ð "ñ „Xð"ð ðð ñ „_ðð ð1ð 1ñ „_ð1ð	ð 	ð 	ðNð Nð Nð 0ð 0ð 0ð3ð 3ð 3ð3ð 3ð 3ð*ð *ð *ð2ð 2ð 2ð7ð 7ð 7ð 7ð0ð 0ð 0ð 0ð
ð ð ðð ð ð
ð 
ð 
ðð ð ð ðð ð ð0ð 0ð 0ð0ð 0ð 0ð 0ð
ð 
ð 
ð?ð ?ð ?ð=ð =ð =ð;ð ;ð ;ð<ð <ð <ð1ð 1ð 1ð 1ð>ð >ð >ð >ðTð Tð Tð8ð 8ð 8ð/ð /ð /ð#ð #ð #ð Rð  Rð  Rð  RðD*ð *ð *ð
ð ð ðð ð ð%Tð %Tð %TðN8ð 8ð 8ð>Gð Gð GðEð Eð EðCð Cð CðEð Eð Eð
Að Að AðCð Cð Cðð ð ðð ð ðBð Bð Bð$,ð ,ð ,ð&"ð "ð "ð
"ð "ð "ð%ð %ð %ðð ð ð ð ð ð ð<ð <ð <ð8ð 8ð 8ð 8ð*ð *ð *ð)ð )ð )ð
7ð 7ð 7ð0ð 0ð 0ð5ð 5ð 5ðð ð ð GKØ+/ð&ð &ð &ð &ðP IMØ#'ðð ð ð ð>Cð Cð Cð Cð
ð 
ð 
ð	ð 	ð 	ð*ð *ð *ðX"ð "ð "ð(ð (ð (ð1ð 1ð 1ð$6ð 6ð 6ð 6ð8ð 8ð 8ð 8ðIð Ið Ið IðEð Eð Eð Eð(ð (ð (ð6ð 6ð 6ð5ð 5ð 5ð 5ðð ð ð1 ð 1 ð 1 ðf ð  ð  ð*1ð 1ð 1ð6ð 6ð 6ðð ð ðð ð ð"ð "ð "ð ð'ð 'ñ „Xð'ð
 ð&ð &ñ „^ð&ð+ð +ð +ðDð Dð Dð Dð Dr+   r„   c                   ó,   — e Zd ZdZd„ Zdd„Zd„ Zd„ ZdS )rb  z»
    A wrapper object to call an implementation function with some predefined
    (context, signature) arguments.
    The wrapper also forwards attribute queries, which is important.
    c                 ó|   — t          |¦  «        | _        |                      ¦   «         | _        || _        || _        d S r$   )Ú_wrap_missing_locÚ	_callableÚ_impÚ_contextÚ_sig)r(   rv  rq  r/   s       r)   r*   z_wrap_impl.__init__²  s4   € Ý*¨3Ñ/Ô/ˆŒØ—N’NÑ$Ô$ˆŒ	ØˆŒØˆŒ	ˆ	ˆ	r+   Nc                 ó    — |                       | j        || j        ||¬¦  «        }| j                             t	          | dd¦  «        ¦  «         |S )N)Úlocrù   r>   )r£  r¤  r¥  ri  rj  )r(   rH  r  r§  rk  s        r)   Ú__call__z_wrap_impl.__call__¸  sH   € Ø�iŠi˜œ w°´	¸4ÀSˆiÑIÔIˆØŒ×&Ò&¥w¨t°V¸RÑ'@Ô'@ÑAÔAÐAØˆ
r+   c                 ó,   — t          | j        |¦  «        S r$   )rj  r£  )r(   Úitems     r)   Ú__getattr__z_wrap_impl.__getattr__½  s   € Ý�t”y $Ñ'Ô'Ð'r+   c                 ó0   — dt          | j        ¦  «        z  S ©Nz<wrapped %s>)Úreprr¢  r'   s    r)   Ú__repr__z_wrap_impl.__repr__À  s   € Ø¥ T¤^Ñ 4Ô 4Ñ4Ð4r+   r$   )ro   rp   rq   rr   r*   r¨  r«  r¯  r>   r+   r)   rb  rb  «  s_   € € € € € ðð ðð ð ðð ð ð ð
(ð (ð (ð5ð 5ð 5ð 5ð 5r+   rb  c                 ó<   — t          j        | ¦  «        }d|j        v S )z.Does function *fn* take ``loc`` argument?
    r§  )r   ÚpysignatureÚ
parameters)r  r/   s     r)   Ú_has_locr³  Ã  s!   € õ Ô
˜BÑ
Ô
€CØ�C”NÐ"Ð"r+   c                   ó    — e Zd Zd„ Zd„ Zd„ ZdS )r¡  c                 ó   — || _         d S r$   ©rî   )r(   r  s     r)   r*   z_wrap_missing_loc.__init__Ì  s   € ØˆŒ	ˆ	ˆ	r+   c                 ó´   ‡— | j         Št          ‰¦  «        s@ˆfd„}d}|D ]4}	 t          ‰|¦  «        }t          |||¦  «         Œ%# t          $ r Y Œ1w xY w|S ‰S )ziWrap function for missing ``loc`` keyword argument.
        Otherwise, return the original *fn*.
        c                  ó>   •— |                      d¦  «          ‰| i |¤ŽS )Nr§  )rŽ  )r  rG  r  s     €r)   Úwrapperz+_wrap_missing_loc.__call__.<locals>.wrapperÕ  s*   ø€ Ø—
’
˜5Ñ!Ô!Ð!Ø�r˜4Ð* 6Ð*Ð*Ð*r+   )ro   rù   )rî   r³  rj  r×   ÚAttributeError)r(   r¹  Úattrsrñ   r9  r  s        @r)   r¨  z_wrap_missing_loc.__call__Ï  s¢   ø€ ð ŒYˆÝ˜‰|Œ|ð 	ð+ð +ð +ð +ð +ð 'ˆEØð 0ð 0�ð0Ý! " dÑ+Ô+�Cõ ˜G T¨3Ñ/Ô/Ð/Ð/øõ &ð ð ð Ø�Dðøøøð
 ˆNàˆIs   ¤AÁ
AÁAc                 ó   — d| j         z  S r­  r¶  r'   s    r)   r¯  z_wrap_missing_loc.__repr__é  s   € Ø ¤	Ñ)Ð)r+   N)ro   rp   rq   r*   r¨  r¯  r>   r+   r)   r¡  r¡  Ê  sA   € € € € € ðð ð ðð ð ð4*ð *ð *ð *ð *r+   r¡  c                  óR   — d„ } d„ }t           j                             | |¦  «         dS )z)Initial event triggers for LLVM lock
    c                  ó.   — t          j        d¦  «         d S ©Nznumba:llvm_lock)r   Ústart_eventr>   r+   r)   Úenter_fnz-_initialize_llvm_lock_event.<locals>.enter_fnñ  s   € ÝÔÐ+Ñ,Ô,Ð,Ð,Ð,r+   c                  ó.   — t          j        d¦  «         d S r¿  )r   Ú	end_eventr>   r+   r)   Úexit_fnz,_initialize_llvm_lock_event.<locals>.exit_fnô  s   € ÝŒÐ)Ñ*Ô*Ð*Ð*Ð*r+   N)rv   ÚffiÚregister_lock_callback)rÁ  rÄ  s     r)   Ú_initialize_llvm_lock_eventrÇ  í  s@   € ð-ð -ð -ð+ð +ð +õ „F×!Ò! (¨GÑ4Ô4Ð4Ð4Ð4r+   )<Úcollectionsr   rÔ   rÇ  Ú	itertoolsr   r   Ú
contextlibr   Ú	functoolsr   Úllvmliter   rµ   Úllvmlite.irr	   Úllvmlite.bindingÚbindingrv   rö  r
   r   r   r   r   r   r   r   r   r   r   Únumbar   r   Únumba.core.compiler_lockr   Únumba.core.pythonapir   Únumba.core.imputilsr   r   r   r   r   Únumba.cpythonr   ÚPointerTyperÜ  r(  ÚPYOBJECTÚvoid_ptrÚobjectr"   Úrunoncer‚   r„   rb  r³  r¡  rÇ  r>   r+   r)   ú<module>rÚ     sÙ  ðØ #Ð #Ð #Ð #Ð #Ð #Ø €€€Ø 
€
€
€
Ø -Ð -Ð -Ð -Ð -Ð -Ð -Ð -Ø %Ð %Ð %Ð %Ð %Ð %Ø %Ð %Ð %Ð %Ð %Ð %à !Ð !Ð !Ð !Ð !Ð !Ø  Ð  Ð  Ð  Ð  Ð  Ø Ð Ð Ð Ð Ð à ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ð ^Ø 2Ð 2Ð 2Ð 2Ð 2Ð 2Ð 2Ð 2Ð 2Ð 2Ø &Ð &Ð &Ð &Ð &Ð &Ð &Ð &Ø 9Ð 9Ð 9Ð 9Ð 9Ð 9Ø *Ð *Ð *Ð *Ð *Ð *ð'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð 'ð #Ð "Ð "Ð "Ð "Ð "à$�&Ô$ ^ V¤^°AÑ%6Ô%6Ñ7Ô7€Ø€Ø€ðuð uð uð uð u�vñ uô uð uðp „ð@ð @ñ „ð@ð&BDð BDð BDð BDð BD�&ñ BDô BDð BDðH 5ð 5ð 5ð 5ð 5�ñ 5ô 5ð 5ð0#ð #ð #ð *ð  *ð  *ð  *ð  *˜ñ  *ô  *ð  *ðF „ð	5ð 	5ñ „ð	5ð Ð Ñ Ô Ð Ð Ð r+   