o ۾i@s\dZddlZddlmZmZddlZddlmZddlm Z m Z m Z m Z ddl ZedZedZedZee jZeZedZedZedZedZd d Zdd d Zd dZiZdddZifddZ Gddde!Z"Gddde"Z#Gddde"Z$Gddde!Z%dddZ&d d!Z'dd"d#Z(d$d%Z)d&d'Z*d(d)Z+dd*d+Z,d,d-Z-d.d/Z.d0d1Z/d2d3Z0d4d5Z1d6d7Z2d8d9Z3d:d;Z4e5dd?Z7eddAdBZ8edCdDZ9eddFdGZ:edHdIZ;ddJdKZ  ddPdQZ?ddRdSZ@ ddTdUZAdVdWZBdXdYZCdZd[ZDd\d]ZEeDZFeCZGd^d_ZHed`efdadbZIdcddZJdedfZKddgdhZLeddidjZMeKZNdkdlZOdmdnZPdodpZQdqdrZRdsdtZSddudvZTdwdxZUdydzZVdd|d}ZWd~dZXddZYddZZddZ[dddZ\dddZ]ddZ^ddZ_ddZ`ddZaddZbddZcddZdddZeddZfdS)z+ Generic helpers for LLVM code generation. N)contextmanager ExitStack)ir)utilstypesconfig debuginfo cC|d||dS)N!=r) icmp_unsignedtypebuildervaluerF/home/ubuntu/.local/lib/python3.10/site-packages/numba/core/cgutils.py as_bool_bitrcCsJ|durtdd|D}|tj}t|D] \}}||||}q|S)zH Create an anonymous struct containing the given LLVM *values*. NcSg|]}|jqSrr.0vrrr %z)make_anonymous_struct..rLiteralStructType Undefined enumerate insert_value)rvalues struct_type struct_valirrrrmake_anonymous_struct s  r'cCs*t|}t|}tttd||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)bufbnrrrmake_bytearray,sr0rcCsb||f}t|}|dur/ttd|}|jdt|}|f}t|d}t|||}|t|<|S)zK Returns a specialized StructProxy subclass for the given fe_type. N)rdata_)_fe_type)_struct_proxy_cachegetValueStructProxyDataStructProxy__name__strdictr)fe_typekind cache_keyresbaseclsnamebases clsmembersrrrcreate_struct_proxy8s   rCcCsV|}|jjD]}||t||}t|||q|D] \}}t|||q|S)zJ Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrrrr copy_structKs rOcseZdZdZdZd!ddZddZddZd d Zd d Z d dZ ddZ ddZ fddZ ddZddZddZddZddZdd ZZS)" _StructProxyz Creates a `Structure` like interface that is constructed with information from DataModel instance. FE type must have a data model that is a subclass of StructModel. NcCs||_|jj|j|_t|jtjjjst d |j||_ | |j|_ t|j r-J||\}}|jj|j krGtd|j |jf|durd|j|jjkr]td|jj|jf|j ||||_||_dS)NzNot a structure model: {0}z!bad ref type: expected %s, got %sz#bad value type: expected %s, got %s)_contextdata_model_managerr3rE isinstancenumbacore datamodel StructModel TypeErrorformat_builder _get_be_type_be_type is_pointer _make_refsrpointeeAssertionError as_pointerstore_value _outer_ref)selfcontextrrref outer_refrrr__init__cs,   z_StructProxy.__init__cCs"|dur t|j|jdd}||fS)z Return an (outer ref, value ref) pair. By default, these are the same pointers, but a derived class may override this. NTzfill) alloca_oncerZr\)rergrrrr^|sz_StructProxy._make_refscCtNNotImplementedErrorrerVrrrr[z_StructProxy._get_be_typecCrmrnroreindexvalrrr_cast_member_to_valuerrz"_StructProxy._cast_member_to_valuecCrmrnrorsrrr_cast_member_from_valuerrz$_StructProxy._cast_member_from_valuecCst|j|jd|SNr) gep_inboundsrZrcrertrrr_get_ptr_by_indexsz_StructProxy._get_ptr_by_indexcCs|j|}||Srn)rEget_field_positionr{)reattrnamertrrr_get_ptr_by_names  z_StructProxy._get_ptr_by_namecCs"|ds ||j|St|z; Load the LLVM value of the named *field*. r2) startswithrEr|AttributeErrorrefieldrrr __getattr__s z_StructProxy.__getattr__cs0|drtt|||S|||j|<dSz@ Store the LLVM *value* into the named *field*. r2N)rsuperrP __setattr__rEr|rerr __class__rrrs z_StructProxy.__setattr__cCs|j||}|||Sz> Load the LLVM value of the field at *index*. )rZloadr{rv)rert member_valrrr __getitem__s z_StructProxy.__getitem__cCs||}|||}|j|jjkr>t|jr3t|jjr3|jj|jjjkr3|j|j||jjj}n t dj ||||d|j ||dS)C Store the LLVM *value* into the field at *index*. zjInvalid store of {value.type} to {ptr.type.pointee} in {self._datamodel} (trying to write member #{index}))rptrrertN) r{rwrr_r]rQ addrspacecastrZ addrspacerXrYrb)rertrrrrr __setitem__s   z_StructProxy.__setitem__cCs|jjSz. Return the number of fields. )rE field_countrerrr__len__sz_StructProxy.__len__cC|jSzF Return the LLVM pointer to the underlying structure. )rdrrrr _getpointerz_StructProxy._getpointercC|j|jSzM Load and return the value of the underlying LLVM structure. )rZrrdrrrr _getvaluez_StructProxy._getvaluecC>t|jrJ|j|jksJ|j|jf|j||jdS)z4 Store the value in this structure. N)r]rr\rZrbrcrerrrr _setvaluesz_StructProxy._setvalueNN)r8 __module__ __qualname____doc__r3rir^r[rvrwr{r~rrrrrrrr __classcell__rrrrrPZs$   rPc@(eZdZdZddZddZddZdS) r6zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). cC|Srn)get_value_typerqrrrr[zValueStructProxy._get_be_typecC|Srnrrsrrrrvrrz&ValueStructProxy._cast_member_to_valuecCrrnrrsrrrrwrrz(ValueStructProxy._cast_member_from_valueNr8rrrr[rvrwrrrrr6s  r6c@r) r7zO Create a StructProxy suitable for accessing data persisted in memory. cCrrn) get_data_typerqrrrr[rzDataStructProxy._get_be_typecC|j|}||j|Srn)rE get_model from_datarZrertrumodelrrrrv z%DataStructProxy._cast_member_to_valuecCrrn)rEras_datarZrrrrrwrz'DataStructProxy._cast_member_from_valueNrrrrrr7s  r7csreZdZdZdddZddZdd Zd d Zfd d ZddZ ddZ ddZ ddZ ddZ ddZZS) Structurezs A high-level object wrapping a alloca'ed LLVM structure, including named fields and attribute access. NFc Cs0|||_||_||_|dur:t||jdd|_|dur9t|jr$J|j|jks2J|j|jf|||jn.|dus@Jt|jsGJ|j|jj kre|rZ| ||j }n t d|jj |jf||_i|_ g|_g|_td}t|jD]\}\}} ||j |<|j|t|f|j| qzdS)NTrjz-mismatching pointer type: got %s, expected %sr)get_struct_type_typerQrZrlrcr]rrbr_bitcastrarX_namemap_fdmap_typemapint32_tr!rFappend) rerfrrrgcast_refr?r&rNtprrrris<    zStructure.__init__cCs|jj|j|j|dd}|S)NT)inbounds)rZgeprcr)rertrrrrr{$szStructure._get_ptr_by_indexcCs||j|Srn)r{r)rer}rrrr~(zStructure._get_ptr_by_namecCs |ds ||j|St|r)rrrrrrrr+s zStructure.__getattr__cs.|drtt|||S|||j|<dSr)rrrrrrrrrr4s zStructure.__setattr__cCs|j||Sr)rZrr{rzrrrr<zStructure.__getitem__cCsN||}|jj|jkrd}t||t|jjt|jf|j||dS)rz:Type mismatch: __setitem__(%d, ...) expected %r but got %rN)r{rr_r`r9rZrb)rertrrfmtrrrrCs  zStructure.__setitem__cCs t|jSr)r)rrrrrrOs zStructure.__len__cCrr)rcrrrrrUrzStructure._getpointercCrr)rZrrcrrrrr[rzStructure._getvaluecCr)z!Store the value in this structureN)r]rrrZrbrcrrrrraszStructure._setvalue)NNF)r8rrrrir{r~rrrrrrrrrrrrrrs   rFc Cst|tr tt|}t|:||j|||d}| |d|Wdn1s0wY|rA| |j d||WdS1sMwYdS)aAllocate stack memory at the entry block of the current function pointed by ``builder`` with llvm type ``ty``. The optional ``size`` arg set the number of element to allocate. The default is 1. The optional ``name`` arg set the symbol name inside the llvm IR for debugging. If ``zfill`` is set, fill the memory with zeros at the current use-site location. Note that the memory is always zero-filled after the ``alloca`` at init-site (the entry block). )sizenameN) rSintrr*intp_trsuspend_emissiongoto_entry_blockallocarbrr_)rtyrrrkrrrrrljs   $rlcCs$|d}|tdg}||tS)zCompute sizeof using GEP Nr )rrptrtointr)rptr_typenulloffsetrrrsizeofs rcCs t||j|d}||||S)z Like alloca_once(), but passing a *value* instead of a type. The type is inferred and the allocated slot is also initialized with the given value. rj)rlrrb)rrrrkstoragerrralloca_once_values rcCs(t|||}|jd|jd|S)z_ Insert a pure function (in the functional programming sense) in the given module. readonlynounwind)get_or_insert_function attributesaddmodulefntyrfnrrrinsert_pure_functions   rcCs(|j|d}|durt|||}|S)zm Get the function named *name* with type *fnty* from *module*, or insert it if it doesn't exist. N)globalsr5rFunctionrrrrrsrcCs*z||WSty||YSwrn)get_named_metadataKeyErroradd_named_metadata)rrrrrget_or_insert_named_metadatas   rcCs||}t||||Srn)get_unique_namerGlobalVariable)rrrr unique_namerrradd_global_variables rcCs"|j}|jdur||dSdSrn) basic_block terminatorbranch)rbbendbbrrr terminates rcCs|dSrnr)ltyperrrget_null_valuerrcCt|j}|d||S)N==rrrrrurrrris_null rcCr)Nr rrrrr is_not_nullrrcC|j|ddS)NFlikelyif_thenrpredrrr if_unlikelyrcCr)NTrrrrrr if_likelyrrcCs|||Srn)rnot_rrrrifnotrrcCs|d}|j||dgdS)z# Increment an index *val*. r nsw)flags)rr)rruonerrrincrement_indexs rLoop)rtdo_breakc #s*|dur|j}|dur|d}|}d}d}dfdd}j}||j|dd } d | |} | |Wdn1sUwY|t| |Vj}t | } t |Wdn1s}wY| ||| | | dS) a Generate LLVM IR for a for-loop in [start, count). *start* is equal to 0 by default. Yields a Loop namedtuple with the following members: - `index` is the loop index's value - `do_break` is a no-argument callable to break out of the loop Nrfor.condfor.bodyfor.endcsdSrn)rrrrrrr rzfor_range..do_break loop.indexr<) rappend_basic_blockrr goto_blockphi icmp_signedcbranchr rr add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyr bbstartrtrincrrrr for_ranges4            r!TccsT|dur|j}|d}|d}|d}|j} ||||.|j|dd} |j|dd} |r=|d| |} n|d | |} || ||Wdn1sUwY|| | | fV|j}|| |} t || }t ||Wdn1swY| || | | || t |d | | ||||dS) a[ Generate LLVM IR for a for-loop based on a slice. Yields a (index, count) tuple where `index` is the slice index's value inside the loop, and `count` the iteration count. Parameters ------------- builder : object IRBuilder object start : int The beginning value of the slice stop : int The end value of the slice step : int The step value of the slice intp : The data type inc : boolean, optional Signals whether the step is positive (True) or negative (False). Returns ----------- None Nr r r rrz loop.countr>r)rrrrrrrrrrrrrr*r)rrrsteprincrrrrrtrrr  next_countrrrfor_range_slices8            r&c cs|j}|d|t|d}t|||||dd}t|||||dd}tdd}|j|dd\} } || ||| |fVWd d S1sIwYd S) a A helper wrapper for for_range_slice(). This is a context manager which yields two for_range_slice()-alike context managers, the first for the positive step case, the second for the negative step case. Use: with for_range_slice_generic(...) as (pos_range, neg_range): with pos_range as (idx, count): ... with neg_range as (idx, count): ... >=rT)r$Fc ssf|&| }|VWdn1swYWddSWddS1s,wYdSrnr)condinner_cmrrrrcm_cond`s"z(for_range_slice_generic..cm_condrN)rrrr*r&rif_else) rrrr#r is_pos_step pos_for_range neg_for_ranger*then otherwiserrrfor_range_slice_genericLs "r1Cccs|dvsJ|sdVdS|dkrdd}ndd}t||||}t|t|ks.J||VWddS1s>wYdS)a Generate a loop nest walking a N-dimensional array. Yields a tuple of N indices for use in the inner loop body, iterating over the *shape* space. If *order* is 'C' (the default), indices are incremented inside-out (i.e. (0,0), (0,1), (0,2), (1,0) etc.). If *order* is 'F', they are incremented outside-in (i.e. (0,0), (1,0), (2,0), (0,1) etc.). This has performance implications when walking an array as it impacts the spatial locality of memory accesses. CFrFcSs|dddS)Nrxrrr~szloop_nest..cSs|Srnrr6rrrr8sN) _loop_nestr))rshaperorder_swapindicesrrr loop_nestjs    "r>c cst||d|d>}t|dkr3t||dd|}|jf|VWdn1s-wYn |jfVWddSWddS1sKwYdS)Nrrr )r!r)r9rt)rr:rloopr=rrrr9s  "r9cCsPt|}|dur |dj}t||tj}t|D] \}}||||}q|S)z Pack a sequence of values in a LLVM array. *ty* should be given if the array may be empty, in which case the type can't be inferred from the values. Nr)r)rrr+r r!r")rr#rr/aryr&rrrr pack_arrays rBcCsBtdd|D}|tj}t|D] \}}||||}q|S)z7 Pack a sequence of values into a LLVM struct. cSrrrrrrrrrzpack_struct..r)rr#structtystr&rrrr pack_structs  rEcs0|dur tjj}fddt|D}|S)zH Unpack an array or structure of values, return a Python tuple. Ncsg|]}|qSr) extract_value)rr&rtuprrrsz unpack_tuple..)r)relementsrange)rrHrvalsrrGr unpack_tuples   rLc CsBt||j|jd}t||j|jd}t|||j|||j|||d S)N)r)r1r:strideslayoutinds wraparound boundscheck)rLr:ndimrMget_item_pointer2r1rN) rfrarytyrArOrPrQshapesrMrrrget_item_pointers  rVc sfdd}d}d}t|tjr||jt|fWdn1s1wYdd}t|tjrL||jt|fWddS1s`wYdS)NcsPdurttrtddStddStddS)NzFdebug: IndexError: index %d is out of bounds for axis {} with size %d zFdebug: IndexError: index %d is out of bounds for axis %d with size %d z9debug: IndexError: index %d is out of bounds for size %d )rSrprintfrYraxisrdimlenindrr_dbgs  zdo_boundscheck.._dbgzindex is out of boundsr'rr)rrrFULL_TRACEBACKS call_convreturn_user_exc IndexErrorr) rfrr[rZrYr\msgout_of_bounds_upperout_of_bounds_lowerrrXrdo_boundschecks  "rdc s|r+g} t||D] \} } d| | d} | | } | | | }| |q n|} |rEtt| |D]\}\} } t|| | |q6| sP|t dgS| dj}|dvrg}|dkrt t |D]}|d}||ddD]} ||}qs||qen*|dkrt t |D]}|d}|d|D]} ||}q||qnt d|d}t| |D]\}} ||}||}q||g}|Sfdd t|| D}tj|}t||S) Nrrr3r2r r4 unreachablecsg|] \}}||qSr)mul)rsr&rrrrsz%get_item_pointer2..)ziprrrselectrr!rdrrrJr)rf Exception functoolsreduce pointer_add)rfrr1r:rMrNrOrPrQr=r[rZnegativewrappedselectedrYrstepsr&lastjlocrgtmprdimoffsrrrhrrSsR       rScCs\|d}t|jtjtjfr|||}|St|jtjr&||||}|Std|jf)Nrzunexpected value type %s)rrSr FloatType DoubleTyper,rrX)rrfpredicondnullvalisnullrrr_scalar_pred_against_zeros  r~cCt||t|jddS)zK Return a predicate representing whether *value* is equal to zero. rr~rlpartial fcmp_orderedrrrris_scalar_zero%rcCr)z Return a predicate representing whether a *value* is not equal to zero. (not exactly "not is_scalar_zero" because of nans) r r~rlrfcmp_unorderedrrrris_not_scalar_zero-rcCr)z] Return a predicate representing whether *value* is equal to either zero or NaN. rrrrrris_scalar_zero_or_nan6rrcCr)z: Is *value* negative? Assumes *value* is signed. rrrrrr is_scalar_negCrrstackccsR||j|dd\}}| dVWdn1swY||dS)a The Python code:: with contextlib.ExitStack() as stack: with early_exit_if(builder, stack, cond): cleanup() body() emits the code:: if (cond) { } else { } This can be useful for generating code with lots of early exits, without having to increase the indentation each time. FrN) enter_contextr+)rrr(r/r0rrr early_exit_ifKs rcCst||t||S)z A convenience wrapper for :func:`early_exit_if`, for the common case where the CPython API indicates an error by returning ``NULL``. )rr)rrobjrrrearly_exit_if_nullgrrcCsb|jt||dd|d}|ddpd}|j|||WddS1s*wYdS)zu Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. Frrr N)rrr^r_)rfrr exc_tupleexcexc_argsrrr guard_nullos "rcCspt|jtjs J|j|r|fnd}|jt||dd|j|t|WddS1s1wYdS)zG Guard against *pointer* being NULL (and raise a MemoryError). rFrN) rSrr PointerTyperrr^r_ MemoryError)rfrpointerrarrrrguard_memory_errorzs "rccsB|jt|||d dVWddS1swYdS)z> Execute the given block if the scalar value is zero. rN)rr)rrrrrrif_zeros"rcCs t|tjS)z7 Whether the LLVM type *typ* is a struct type. )rSrr)ltyprrrr]s r]cCs.t||d|}t|jjrJ|||Srx)ryr]rr_rra)rrecordrtyppvalrrrget_record_membersrcCr )Nrr)rr)rrurrr is_neg_intrrcOst||g|Rddi|S)z8 Same as *gep*, but add the `inbounds` keyword. rT)r)rrrOkwsrrrrysryc Osb|dd}|dd}|rJg}|D]}t|tr t|}n|}||q|j||||dS)z Emit a getelementptr instruction for the given pointer and indices. The indices can be LLVM values or Python int constants. rrrF)rr)rGrSrrrr) rrrOrrridxr&r[rrrrs     rcCs<||t}t|trt|}|||}|||p|jS)z Add an integral *offset* to pointer *ptr*, and return a pointer of *return_type* (or, if omitted, the same type as *ptr*). Note the computation is done in bytes, and ignores the width of the pointed item type. )rrrSrrinttoptrr)rrr return_typeintptrrrrrns   rncCsN|jdt|jf}||t}t|trt|}|||||t dgdS)z= Fill *size* bytes starting from *ptr* with *value*. z llvm.memsetrN) rdeclare_intrinsic voidptr_trrrSrint8_tcallbool_t)rrrrrrrrmemsets   rcCs0||}t||t||jd|||dS)z7 Fill padding bytes of the pointee with zeros. rN)rrrrrb)rrrurrrmemset_paddings rinternalcCs<t|tjr |}n|j}t||j|}||_d|_||_|S)zO Get or create a (LLVM module-)global constant with *name* or *value*. T) rSrModulerrrlinkageglobal_constant initializer)builder_or_modulerrrrr1rrrrs rc Cs|dksJ||}|d}t||j}|t||P\}}||||}|||Wdn1s:wY||||}|||}|||||Wdn1sbwYWdn1sqwY||}||| ||} || fS)a  Compute the (quotient, remainder) of *val* divided by the constant positive *divisor*. The semantics reflects those of Python integer floor division, rather than C's / LLVM's signed division and modulo. The difference lies with a negative *val*. rr N) rrlr+rsdivrbrsubrrf) rrudivisorrquotif_negif_posquot_val val_plus_onerem_valrrrdivmod_by_constants&        rcCs&|d}|||||||S)z Branch conditionally or continue. Note: a new block is created and builder is moved to the end of the new block. z .continue)rrr)rr(bbtruebbcontrrrcbranch_or_continues  rcCsx|j|jksJt|||jd"}|||jg}|||jg}||||WddS1s5wYdS)z Emit a memcpy to the builder. Copies each element of dst to src. Unlike the C equivalent, each element can be any LLVM type. Assumes ------- * dst.type == src.type * count is positive r?N)rr!rrtrbr)rrKrLrr@out_ptrin_ptrrrrmemcpys "rc Csd|j}t|trt||}|j|tt|g}t} | || |t| |t| ||| gdSrn) rrSrrr*rrr false_bitrrrf) r func_namerKrLritemsizealignsize_tr is_volatilerrr _raw_memcpy1s     rcCt|d|||||S)za Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpyrrrKrLrrrrrr raw_memcpy?srcCr)zb Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmoverrrrr raw_memmoveGs rc CsX|||}||d}||d}|||}||d}||||d} || fS)zq Compute (a * b + c) and return a (result, overflow bit) pair. The operands must be signed integers. rr )smul_with_overflowrFsadd_with_overflowor_) rar.cpprodprod_ovfrgr>ovfrrrmuladd_with_overflowPs     rc Gst|tsJ|j}t}t|dd}t|d|}tjt |gdd}z| d}Wnt y<tj ||dd}Ynw| ||} ||| gt|S)a Calls printf(). Argument `format` is expected to be a Python string. Values to be printed are listed in `args`. Note: There is no checking to ensure there is correct number of values in `args` and there type matches the declaration in the format string. ascii printf_formatTvar_argrWr)rSr9rrr0encoderr FunctionTyper get_globalrrrrlist) rrYargsmodcstring fmt_bytes global_fmtrrptr_fmtrrrrW^s    rWc Gst|tsJ|j}t}t|dd}t|d|}tjt |t |gdd} d} t j r/d| } z| | } WntyGtj|| | d} Ynw|||} || ||| gt|S) z8Calls libc snprintf(buffer, bufsz, format, ...args) rrsnprintf_formatTrsnprintfr2r)rSr9rrr0rrrrrrrIS_WIN32rrrrrr) rbufferbufszrYrrrrrrsymbolrrrrrrxs$    rcGsXt|tsJttd|}t||dd}||t}t||t ||g|R|S)z{Similar to `snprintf()` but the buffer is stack allocated to size *bufsz*. Returns the buffer pointer as i8*. r Trj) rSrrr+r,rlrrrr)rrrYrspacetyspacerrrrsnprintf_stackbuffers  rcCs|ddS)zk Normalize the given string to latin1 compatible encoding that is suitable for use in LLVM IR. utf8latin1)rdecode)textrrrnormalize_ir_textsrc Csd}||t}t|d||td}|||}t||G}||j t|}| d|td}| | t|dWdn1sIwY| ||j g}| |} t|d| Wdn1skwYt|ddS) zIDebug print the memory region in *ptr* to *ptr + nbytes* as hex. zhexdump p=%p n=%zur rr Nz %02x)zextrrWrr,rrar!uremrtrrrr) rrnbytesbytes_per_linebyte_trdiv_by do_new_linerrurrrhexdumps$       rcCs |dupt|tjpt|tjS)z returns if 'ty' is none N)rSrNoneTypeOmittedrrrr is_nonelikes   rcCst|tjo t|jdkS)z# returns if 'ty' is an empty tuple r)rSrTupler)rrrris_empty_tuples  rcCstt|t||S)z Create an LLVM-constant of a fixed-length array from Python values. The type provided is the type of the elements. )rr*r+r))rrurrrcreate_constant_arraysrrn)r)NrF)rF)rr)NT)r2)FF)F)r)r )gr collections contextlibrrrlllvmliter numba.corerrrrnumba.core.datamodelrTr,rrr MACHINE_BITSrrartrue_bitr true_byte false_byterr'r0r4rCrOobjectrPr6r7rrlrrrrrrrrrrrrrr namedtupler r!r&r1r>r9rBrErLrVrdrSr~rrris_trueis_falserrrrrr guard_zeror]rrryrrnrrrrrrrrrrrWrrrrrrrrrrrs          l      + 9        :