U hdi@sNdZddlZddlmZmZddlZddlmZddlm 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;ddJdKZddPdQZ?ddRdSZ@ddTdUZAdVdWZBdXdYZCdZd[ZDd\d]ZEeDZFeCZGd^d_ZHeed`dadbZIdcddZJdedfZKddgdhZLeddidjZMeKZNdkdlZOdmdnZPdodpZQdqdrZRdsdtZSddudvZTdwdxZUdydzZVdd|d}ZWd~dZXddZYddZZddZ[dddZ\dddZ]ddZ^ddZ_ddZ`ddZaddZbddZcddZdddZedS)z+ Generic helpers for LLVM code generation. N)contextmanager ExitStack)ir)utilstypesconfig debuginfo cCs|d||dS)N!=r) icmp_unsignedtypebuildervaluerK/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/numba/core/cgutils.py as_bool_bitsrcCsJ|dkrtdd|D}|tj}t|D]\}}||||}q.|S)zH Create an anonymous struct containing the given LLVM *values*. NcSsg|] }|jqSrr.0vrrr %sz)make_anonymous_struct..rZLiteralStructType Undefined enumerate insert_value)rvaluesZ struct_typeZ struct_valirrrrmake_anonymous_struct s  r cCs*t|}t|}tttd||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)bufbnrrrmake_bytearray,sr)rcCsb||f}t|}|dkr^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)Zfe_typekind cache_keyresbaseclsnamebasesZ clsmembersrrrcreate_struct_proxy8s   r:cCsV|}|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 rFcseZdZdZdZd!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|jtjjjs8t d |j||_ | |j|_ t|j rZt||\}}|jj|j krtd|j |jf|dk r|j|jjkrtd|jj|jf|j ||||_||_dS)NzNot a structure model: {0}z!bad ref type: expected %s, got %sz#bad value type: expected %s, got %s)_contextZdata_model_managerr,r< isinstancenumbacore datamodelZ StructModel TypeErrorformat_builder _get_be_type_be_type is_pointerAssertionError _make_refsrpointee as_pointerstore_value _outer_ref)selfcontextrrrefZ outer_refrrr__init__cs,  z_StructProxy.__init__cCs"|dkrt|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_oncerOrQ)rZr\rrrrT|sz_StructProxy._make_refscCstdSNNotImplementedErrorrZrLrrrrPsz_StructProxy._get_be_typecCstdSrarbrZindexvalrrr_cast_member_to_valuesz"_StructProxy._cast_member_to_valuecCstdSrarbrerrr_cast_member_from_valuesz$_StructProxy._cast_member_from_valuecCst|j|jd|SNr) gep_inboundsrOrXrZrfrrr_get_ptr_by_indexsz_StructProxy._get_ptr_by_indexcCs|j|}||Sra)r<get_field_positionrm)rZattrnamerfrrr_get_ptr_by_names z_StructProxy._get_ptr_by_namecCs&|ds||j|St|dSz; Load the LLVM value of the named *field*. r+N) startswithr<rnAttributeErrorrZfieldrrr __getattr__s z_StructProxy.__getattr__cs0|drtt|||S|||j|<dSz@ Store the LLVM *value* into the named *field*. r+N)rrsuperrG __setattr__r<rnrZrur __class__rrrys z_StructProxy.__setattr__cCs|j||}|||Sz> Load the LLVM value of the field at *index*. )rOloadrmrh)rZrfZ member_valrrr __getitem__sz_StructProxy.__getitem__cCs||}|||}|j|jjkr|t|jrft|jjrf|jj|jjjkrf|j|j||jjj}nt 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}))rptrrZrfN) rmrirrUrRrHZ addrspacecastrO addrspacerMrNrW)rZrfrrrrr __setitem__s"   z_StructProxy.__setitem__cCs|jjSz. Return the number of fields. )r<Z field_countrZrrr__len__sz_StructProxy.__len__cCs|jSzF Return the LLVM pointer to the underlying structure. )rYrrrr _getpointersz_StructProxy._getpointercCs|j|jSzM Load and return the value of the underlying LLVM structure. )rOr~rYrrrr _getvaluesz_StructProxy._getvaluecCs>t|jrt|j|jks*t|j|jf|j||jdS)z4 Store the value in this structure. N)rRrrSrQrOrWrXrZrrrr _setvaluesz_StructProxy._setvalue)NN)r1 __module__ __qualname____doc__r,r]rTrPrhrirmrprvryrrrrrr __classcell__rrr{rrGZs"   rGc@s(eZdZdZddZddZddZdS) r/zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). cCs|Sra)Zget_value_typerdrrrrPszValueStructProxy._get_be_typecCs|Srarrerrrrhsz&ValueStructProxy._cast_member_to_valuecCs|Srarrerrrrisz(ValueStructProxy._cast_member_from_valueNr1rrrrPrhrirrrrr/sr/c@s(eZdZdZddZddZddZdS) r0zO Create a StructProxy suitable for accessing data persisted in memory. cCs|Sra)Z get_data_typerdrrrrPszDataStructProxy._get_be_typecCs|j|}||j|Sra)r< get_model from_datarOrZrfrgmodelrrrrhs z%DataStructProxy._cast_member_to_valuecCs|j|}||j|Sra)r<rZas_datarOrrrrris z'DataStructProxy._cast_member_from_valueNrrrrrr0sr0csreZdZdZdddZddZdd 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|||_||_||_|dkrtt||jdd|_|dk rt|jrHt|j|jksdt|j|jf| ||jn\|dkstt|jst|j|jj kr|r| ||j }nt d|jj |jf||_i|_g|_g|_td}t|jD]6\}\}} ||j|<|j|t|f|j| qdS)NTr^z-mismatching pointer type: got %s, expected %sr)Zget_struct_type_typerHrOr`rXrRrrSrWrUbitcastrVrM_namemap_fdmapZ_typemapint32_trr=append) rZr[rrr\Zcast_refr7rrEtprrrr]s8    zStructure.__init__cCs|jj|j|j|dd}|S)NT)inbounds)rOgeprXr)rZrfrrrrrm$szStructure._get_ptr_by_indexcCs||j|Sra)rmr)rZrorrrrp(szStructure._get_ptr_by_namecCs$|ds||j|St|dSrq)rrrrsrtrrrrv+s zStructure.__getattr__cs.|drtt|||S|||j|<dSrw)rrrxrryrrzr{rrry4s zStructure.__setattr__cCs|j||Sr})rOr~rmrlrrrr<szStructure.__getitem__cCsN||}|jj|jkrt|jrt|j|jks*t|j|jf|j||jdS)z!Store the value in this structureN)rRrrSrrOrWrXrrrrraszStructure._setvalue)NNF)r1rrrr]rmrprvryrrrrrrrrrr{rrs   rFc Cst|trtt|}t|^|&|j|||d}| |d|W5QRX|rn| |j d||W5QRSQRXdS)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) rIintrr#intp_trZsuspend_emissionZgoto_entry_blockZallocarWrrU)rtyrrr_rrrrr`js    r`cCs$|d}|tdg}||tS)zCompute sizeof using GEP Nr )rrptrtointr)rZptr_typenulloffsetrrrsizeofsrcCs 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. r^)r`rrW)rrrr_Zstoragerrralloca_once_values rcCs(t|||}|jd|jd|S)z_ Insert a pure function (in the functional programming sense) in the given module. readonlyZnounwind)get_or_insert_function attributesaddmodulefntyrfnrrrinsert_pure_functions   rcCs(|j|d}|dkr$t|||}|S)zm Get the function named *name* with type *fnty* from *module*, or insert it if it doesn't exist. N)globalsr.rFunctionrrrrrsrcCs0z ||WStk r*||YSXdSra)Zget_named_metadataKeyErrorZadd_named_metadata)rrrrrget_or_insert_named_metadatas rcCs||}t||||Sra)Zget_unique_namerZGlobalVariable)rrrrZ unique_namerrradd_global_variables rcCs|j}|jdkr||dSra) basic_block terminatorbranch)rbbendZbbrrr terminates rcCs|dSrar)Zltyperrrget_null_valuesrcCst|j}|d||S)N==rrr rrgrrrris_nulls rcCst|j}|d||S)Nr rrrrr is_not_nulls rcCs|j|ddS)NFlikelyif_thenrpredrrr if_unlikelysrcCs|j|ddS)NTrrrrrr if_likelysrcCs|||Sra)rnot_rrrrifnotsrcCs|d}|j||dgdS)z# Increment an index *val*. r Znsw)flags)rr)rrgonerrrincrement_indexs rLoop)rfdo_breakc #s|dkr|j}|dkr|d}|}d}d}dfdd}j}||0j|dd } d | |} | |W5QRX|,t| |Vj}t | } t |W5QRX| ||| | | 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.endcsdSra)rrrrrrrszfor_range..do_break loop.indexr<) rappend_basic_blockrr goto_blockphi icmp_signedcbranchrrr add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyrbbstartrfrincrrrr for_ranges.           rTc cs*|dkr|j}|d}|d}|d}|j} ||||R|j|dd} |j|dd} |rx|d| |} n|d | |} || ||W5QRX||6| | fV|j}|| |} t || }t ||W5QRX| || | | || 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 Nrrrrrz loop.countr>r)rrrrrrrrrrrrrr#r)rrrsteprincrrrrrfrrrZ next_countrrrfor_range_slices2            rc cs|j}|d|t|d}t|||||dd}t|||||dd}tdd}|j|dd \} } || ||| |fVW5QRXd 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)rFc ss*|| }|VW5QRXW5QRXdSrar)condZinner_cmrrrrcm_cond`sz(for_range_slice_generic..cm_condrN)rrrr#rrif_else) rrrrrZ is_pos_stepZ pos_for_rangeZ neg_for_rangerthen otherwiserrrfor_range_slice_genericLs rCc csp|dks t|sdVnT|dkr*dd}ndd}t||||$}t|t|ksXt||VW5QRXdS)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~zloop_nest..cSs|SrarrrrrrrN)rS _loop_nestr")rshaperorderZ_swapindicesrrr loop_nestjs  rc csht||d|dL}t|dkrPt||dd|}|jf|VW5QRXn |jfVW5QRXdS)Nrrr )rr"rrf)rrrlooprrrrrs  rcCsPt|}|dkr|dj}t||tj}t|D]\}}||||}q4|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$rrr)rrrr(aryrrrrr pack_arrays rcCsBtdd|D}|tj}t|D]\}}||||}q&|S)z7 Pack a sequence of values into a LLVM struct. cSsg|] }|jqSrrrrrrrszpack_struct..r)rrZstructtystrrrrr pack_structs  rcs0|dkrtjj}fddt|D}|S)zH Unpack an array or structure of values, return a Python tuple. Ncsg|]}|qSr) extract_value)rrrtuprrrsz unpack_tuple..)r"relementsrange)rr rvalsrr r unpack_tuples   rc CsBt||j|jd}t||j|jd}t|||j|||j|||d S)N)r)r*rstrideslayoutinds wraparound boundscheck)rrndimrget_item_pointer2r*r) r[rZarytyrrrrZshapesrrrrget_item_pointers rc sfdd}d}d}t|$tjr<||jt|fW5QRXdd}t|$tjr||jt|fW5QRXdS)NcsLdk r:ttr(tdqHtdntddS)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 )rIrprintfrNraxisrdimlenindrr_dbgs$ zdo_boundscheck.._dbgzindex is out of boundsrrr)rrrZFULL_TRACEBACKS call_convreturn_user_exc IndexErrorr) r[rrrrrmsgZout_of_bounds_upperZout_of_bounds_lowerrrrdo_boundschecks  r"c s|rVg} t||D]@\} } d| | d} | | } | | | }| |qn|} |rtt| |D]\}\} } t|| | |ql| s|t dgS| dj}|dkrg}|dkr t t |D]8}|d}||ddD]} ||}q||qnZ|dkr\t t |D]8}|d}|d|D]} ||}q8||q nt d|d}t| |D]"\}} ||}||}qv||g}|Sfdd t|| D}tj|}t||SdS) Nrrrrr rZ unreachablecsg|]\}}||qSr)mul)rsrrrrrsz%get_item_pointer2..)ziprrrselectrrr"rrr r"r# Exception functoolsreduce pointer_add)r[rr*rrrrrrrrrnegativewrappedselectedrrZstepsrlastjlocr$tmprZdimoffsrrr%rrsL      rcCs\|d}t|jtjtjfr*|||}n.t|jtjrH||||}ntd|jf|S)Nrzunexpected value type %s)rrIrZ FloatTypeZ DoubleTyper%rrM)rrZfpredZicondZnullvalZisnullrrr_scalar_pred_against_zeros  r3cCst||t|jddS)zK Return a predicate representing whether *value* is equal to zero. rr3r)partialZ fcmp_orderedrrrris_scalar_zero%s  r6cCst||t|jddS)z Return a predicate representing whether a *value* is not equal to zero. (not exactly "not is_scalar_zero" because of nans) r r3r)r5Zfcmp_unorderedrrrris_not_scalar_zero-s  r8cCst||t|jddS)z] Return a predicate representing whether *value* is equal to either zero or NaN. rr7rrrris_scalar_zero_or_nan6s  r9cCst||t|jddS)z: Is *value* negative? Assumes *value* is signed. rr4rrrr is_scalar_negCs  r:)stackc cs<||j|dd\}}| dVW5QRX||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)rr;rrrrrr early_exit_ifKsr=cCst||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``. )r=r)rr;objrrrearly_exit_if_nullgsr?c CsL|jt||dd.|d}|ddp,d}|j|||W5QRXdS)zu Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. Frrr N)rr6rr)r[rr exc_tupleexcexc_argsrrr guard_nullosrCc CsZt|jtjst|j|r"|fnd}|jt||dd|j|t |W5QRXdS)zG Guard against *pointer* being NULL (and raise a MemoryError). rFrN) rIrr PointerTyperSrrrr MemoryError)r[rZpointerr!rBrrrguard_memory_errorzsrFc cs*|jt|||d dVW5QRXdS)z> Execute the given block if the scalar value is zero. rN)rr6)rrrrrrif_zerosrGcCs t|tjS)z7 Whether the LLVM type *typ* is a struct type. )rIrrD)ZltyprrrrRsrRcCs.t||d|}t|jjrt|||Srj)rkrRrrUrSrrV)rrecordrtypZpvalrrrget_record_membersrJcCs|d||dS)Nrr)rr)rrgrrr is_neg_intsrKcOst||f|ddi|S)z8 Same as *gep*, but add the `inbounds` keyword. rT)r)rrrkwsrrrrksrkc Osb|dd}|dd}|r tg}|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)r>rSrIrrrr) rrrrLrridxrrrrrrs     rcCs<||t}t|trt|}|||}|||p8|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. )rrrIrrZinttoptrr)rrr return_typeZintptrrrrr+s    r+cCsN|jdt|jf}||t}t|tr2t|}|||||t dgdS)z= Fill *size* bytes starting from *ptr* with *value*. z llvm.memsetrN) rdeclare_intrinsic voidptr_trrrIrint8_tcallbool_t)rrrrrrrrmemsets   rTcCs0||}t||t||jd|||dS)z7 Fill padding bytes of the pointee with zeros. rN)r~rTrrrW)rrrgrrrmemset_paddings rUinternalcCs<t|tjr|}n|j}t||j|}||_d|_||_|S)zO Get or create a (LLVM module-)global constant with *name* or *value*. T) rIrModulerrrlinkageglobal_constantZ initializer)Zbuilder_or_modulerrrXrr*rrrrYs rYc Cs|dks t||}|d}t||j}|t||n\}}||||}|||W5QRX|2|||}|||}|||||W5QRXW5QRX| |}||| ||} || 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 ) rSrr`rrKZsdivrWrsubr~r#) rrgZdivisorrquotZif_negZif_posZquot_valZ val_plus_oneZrem_valrrrdivmod_by_constants       ( r\cCs&|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)rrZbbtrueZbbcontrrrcbranch_or_continues  r]c Csb|j|jkstt|||jd8}|||jg}|||jg}||||W5QRXdS)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 rN)rrSrrrfrWr~)rrBrCrrZout_ptrZin_ptrrrrmemcpys r^c Csd|j}t|trt||}|j|tt|g}t} | || |t| |t| ||| gdSra) rrIrrr#rrOrP false_bitrRrr#) r func_namerBrCritemsizealignZsize_tr^Z is_volatilerrr _raw_memcpy1s    rccCst|d|||||S)za Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpyrcrrBrCrrarbrrr raw_memcpy?srfcCst|d|||||S)zb Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmoverdrerrr raw_memmoveGs rgc 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 )Zsmul_with_overflowr Zsadd_with_overflowor_) rar'cpprodZprod_ovfr$r6Zovfrrrmuladd_with_overflowPs     rmc Gst|tst|j}t}t|dd}t|d|}tj t |gdd}z| d}Wn$t k rztj ||dd}YnX|||} ||| 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. asciiZ printf_formatTZvar_argrr)rIr2rSrrPr)encoderYr FunctionTyper get_globalrrrrRlist) rrNargsmodcstring fmt_bytes global_fmtrrptr_fmtrrrr^s   rc Gst|tst|j}t}t|dd}t|d|}tj t |t |gdd} d} t j r^d| } z|| } Wn$tk rtj|| | d} YnX|||} || ||| gt|S) z8Calls libc snprintf(buffer, bufsz, format, ...args) rnroZsnprintf_formatTrpsnprintfr+r)rIr2rSrrPr)rqrYrrrrrrZIS_WIN32rsrrrrRrt) rbufferbufszrNrurvrwrxryrsymbolrrzrrrr{xs&  r{cGsVt|tstttd|}t||dd}||t}t ||t ||f||S)z{Similar to `snprintf()` but the buffer is stack allocated to size *bufsz*. Returns the buffer pointer as i8*. r Tr^) rIrrSrr$r%r`rrPr{r)rr}rNruZspacetyspacer|rrrsnprintf_stackbuffers  rcCs|ddS)zk Normalize the given string to latin1 compatible encoding that is suitable for use in LLVM IR. utf8latin1)rqdecode)textrrrnormalize_ir_textsrc Csd}||t}t|d||td}|||}t||p}||j t|}| d|td}| |t|dW5QRX| ||j g}| |} t|d| W5QRXt|ddS) zIDebug print the memory region in *ptr* to *ptr + nbytes* as hex. zhexdump p=%p n=%zur rr z %02xN)Zzextrrrr%rrVrZuremrfr rrr~) rrnbytesZbytes_per_lineZbyte_trMZdiv_byZ do_new_linerrgrrrhexdumps"     rcCs |dkpt|tjpt|tjS)z returns if 'ty' is none N)rIrZNoneTypeZOmitted)rrrr is_nonelikes   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")rrgrrrcreate_constant_arraysr)N)r)NrF)rF)r)NN)NT)r)N)N)FF)N)FF)N)F)N)rV)r )r )fr collections contextlibrrr)ZllvmliterZ numba.corerrrrZnumba.core.datamodelrJr%rSrQrZ MACHINE_BITSrrVrPZtrue_bitr_Z true_byteZ false_byterr r)r-r:rFobjectrGr/r0rr`rrrrrrrrrrrrrr namedtuplerrrrrrrrrrr"rr3r6r8r9Zis_trueZis_falser:r=r?rCrFrGZ guard_zerorRrJrKrkrr+rTrUrYr\r]r^rcrfrgrmrr{rrrrrrrrrs         l       + 9      :