iSrSSKrSSKJrJr SSKrSSKJr SSKJ r J r J r J r SSK r\R"S5r\R"S5r\R"S5r\R"\ R&5r\R+5r\"S5r\"S5r\"S5r\"S5rS rSUS jrS r0rSVS jr04S jr "SS\!5r""SS\"5r#"SS\"5r$"SS\!5r%SWSjr&Sr'SXSjr(Sr)Sr*Sr+SYSjr,Sr-Sr.Sr/S r0S!r1S"r2S#r3S$r4\Rj"S%S&5r6\SZS'j5r7\S[S(j5r8\S)5r9\S\S*j5r:\S+5r;SUS,jrS]S/jr?SUS0jr@S]S1jrAS2rBS3rCS4rDS5rE\DrF\CrGS6rH\S7\4S8j5rIS9rJS:rKSUS;jrL\S^S<j5rM\KrNS=rOS>rPS?rQS@rRSArSSUSBjrTSCrUSDrVS_SEjrWSFrXSGrYSHrZSIr[S`SJjr\S`SKjr]SLr^SMr_SNr`SOraSPrbSQrcSRrdSSreSTrfg)az+ Generic helpers for LLVM code generation. N)contextmanager ExitStack)ir)utilstypesconfig debuginfo cDURSXRS55$)N!=r) icmp_unsignedtypebuildervalues M/var/www/html/trading/venv/lib/python3.13/site-packages/numba/core/cgutils.py as_bool_bitrs  ujjm <<cUc0[R"UVs/sHo3RPM sn5nU"[R5n[ U5HupSUR XCU5nM U$s snf)z@ Create an anonymous struct containing the given LLVM *values*. rLiteralStructTyper Undefined enumerate insert_value)rvalues struct_typev struct_valis rmake_anonymous_structr" sh**F+CFqFFF+CD R\\*J&!))*; "  ,DsA2c[U5n[U5n[R"[R"[R "S5U5U5$)z( Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)bufbns rmake_bytearrayr,,s: #A AA ;;r||BJJqM15q 99rcX4n[RU5nUcL[[S.UnURS-[ U5-nU4n[ US9n[XVU5nU[U'U$)zC Returns a specialized StructProxy subclass for the given fe_type. )rdata_)_fe_type)_struct_proxy_cachegetValueStructProxyDataStructProxy__name__strdictr)fe_typekind cache_keyresbaseclsnamebases clsmemberss rcreate_struct_proxyr@8s{I  ! !) ,C {)'--#%G 47+ 7:.),I& JrcUR5nURRH*nURU[ X55n[ XU5 M, UR 5Hup4[ XU5 M U$)zB Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrs r copy_structrMKsd 99;D ^^ # # HHQ ($  Jrc^\rSrSrSrSrSSjrSrSrSr Sr S r S r S r U4S jrS rSrSrSrSrSrSrU=r$) _StructProxyZz 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. Nc|XlURRURUl[ UR[ R RR5(d$[SRUR55eX l URUR5Ul [UR5(aeURU5upTUR R"UR:wa5[%SURR'5<SUR <35eUbpUR UR R":wa1[%SUR R"<SUR <35eURR)X55 X@lXPlg)NzNot a structure model: {0}zbad ref type: expected z, got zbad value type: expected )_contextdata_model_managerr0rC isinstancenumbacore datamodel StructModel TypeErrorformat_builder _get_be_type_be_type is_pointer _make_refsrpointeeAssertionError as_pointerstore_value _outer_ref)selfcontextrrref outer_refs r__init___StructProxy.__init__csF --::4==I$//5::+?+?+K+KLL,33DOODF F ))$//: dmm,,,,- 88  t}} , $(MM$<$<$>"JK K  zzY^^333$(1(>(> &LMM MM   1 #rcLUc[URURSS9nX4$)zy Return an (outer ref, value ref) pair. By default, these are the same pointers, but a derived class may override this. Tzfill) alloca_oncer[r])rfrhs rr__StructProxy._make_refs|s& ;dmmT]]$GCxrc[eNNotImplementedErrorrfrWs rr\_StructProxy._get_be_type!!rc[errrsrfindexvals r_cast_member_to_value"_StructProxy._cast_member_to_valuerwrc[errrsrys r_cast_member_from_value$_StructProxy._cast_member_from_valuerwrcF[URURSU5$Nr) gep_inboundsr[rdrfrzs r_get_ptr_by_index_StructProxy._get_ptr_by_indexsDMM4;;5AArcZURRU5nURU5$rr)rCget_field_positionr)rfattrnamerzs r_get_ptr_by_name_StructProxy._get_ptr_by_names'228<%%e,,rc~URS5(dXRRU5$[U5ez+ Load the LLVM value of the named *field*. r/) startswithrCrAttributeErrorrffields r __getattr___StructProxy.__getattr__s8$$::5AB B ' 'rc>URS5(a[[U]X5$X URR U5'gz0 Store the LLVM *value* into the named *field*. r/N)rsuperrO __setattr__rCrrfrr __class__s rr_StructProxy.__setattr__s?   C t8F F:?T__ / / 67rcxURRURU55nURX5$z. Load the LLVM value of the field at *index*. )r[loadrr|)rfrz member_vals r __getitem___StructProxy.__getitem__s4]]''(>(>u(EF ))%<.>.F.FF 33DMM4947HH4D4D4N4NP !D"(e4.3"("5 66 E'rc.URR$z Return the number of fields. )rC field_countrfs r__len___StructProxy.__len__s***rcUR$z6 Return the LLVM pointer to the underlying structure. )rers r _getpointer_StructProxy._getpointersrcLURRUR5$z= Load and return the value of the underlying LLVM structure. )r[rrers r _getvalue_StructProxy._getvalues}}!!$//22rc[UR5(aeURUR:XdURUR45eURR XR 5 g)z$ Store the value in this structure. N)r^rr]r[rcrdrfrs r _setvalue_StructProxy._setvaluesWejj))))zzT]]*GUZZ,GG* E;;/r)r]r[rRrCrerdNN)r5 __module__ __qualname____firstlineno____doc__r0rjr_r\r|rrrrrrrrrrr__static_attributes__ __classcell__rs@rrOrOZsa H$2"""B-(@=(.+  3 00rrOc*\rSrSrSrSrSrSrSrg)r3z` Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). c"UR5$rr)get_value_typerus rr\ValueStructProxy._get_be_types''))rcU$rrrys rr|&ValueStructProxy._cast_member_to_value rcU$rrrrys rr(ValueStructProxy._cast_member_from_valuerrrN r5rrrrr\r|rrrrrr3r3s*rr3c*\rSrSrSrSrSrSrSrg)r4zG Create a StructProxy suitable for accessing data persisted in memory. c"UR5$rr) get_data_typerus rr\DataStructProxy._get_be_types&&((rcpURRU5nURURU5$rr)rC get_model from_datar[rfrzr{models rr|%DataStructProxy._cast_member_to_values+))%0t}}c22rcpURRU5nURURU5$rr)rCras_datar[rs rr'DataStructProxy._cast_member_from_values+))%0}}T]]C00rrNrrrrr4r4s)31rr4cl^\rSrSrSrSSjrSrSrSrU4Sjr Sr S r S r S r S rS rSrU=r$) Structurezg A high-level object wrapping a alloca'ed LLVM structure, including named fields and attribute access. cURU5UlXlX lUc[ X RSS9UlUbn[ UR5(aeURUR:XdURUR45eURX0R 5 OUbe[ UR5(deURURR:wabU(a*URX@RR55nO1[SURR<SUR<35eX@l0Ul /Ul/Ul[!S5n[#UR$5HWunupXpRU'URR'U[!U545 URR'U 5 MY g)NTrmzmismatching pointer type: got z , expected r)get_struct_type_typerRr[rordr^rrcr`bitcastrbrY_namemap_fdmap_typemapint32_trrDappend) rfrgrrrhcast_refr<r!rLtps rrjStructure.__init__sx,,T2   ;%gzzFDK %ejj1111zzTZZ/I%**djj1II/ e[[1= =chh'' ''zzSXX---!//#zz/D/D/FGC#88++TZZ9::K   qz#DLL1JAw MM!  KK  gaj1 2 MM  $2rcjURRURURUSS9nU$)NT)inbounds)r[geprdr)rfrzrs rrStructure._get_ptr_by_index$s/mm T[[-?$O rc>URURU5$rr)rr)rfrs rrStructure._get_ptr_by_name(s%%dmmH&=>>rcfURS5(dXRU$[U5er)rrrrs rrStructure.__getattr__+s2$$ e,- - ' 'rcz>URS5(a[[U]X5$X URU'gr)rrrrrrs rrStructure.__setattr__4s9   C D5eC C%*T]]5 !"rcVURRURU55$r)r[rrrs rrStructure.__getitem__<s$ }}!!$"8"8"?@@rc(URU5nURRUR:waBSn[XA[ URR5[ UR54-5eUR R X#5 g)rz:Type mismatch: __setitem__(%d, ...) expected %r but got %rN)rrr`rar6r[rc)rfrzrrfmts rrStructure.__setitem__Csy$$U+ 88  uzz )NC (+CHH,<,<(=(+EJJ(9"9: : E'rc,[UR5$r)r%rrs rrStructure.__len__Os4==!!rcUR$r)rdrs rrStructure._getpointerUs{{rcLURRUR5$r)r[rrdrs rrStructure._getvalue[s}}!!$++..rc[UR5(aeURUR:XdURUR45eURR XR 5 g)z!Store the value in this structureN)r^rrr[rcrdrs rrStructure._setvalueasUejj))))zzTZZ'A%**djj)AA' E;;/r)r[rRrrrrrd)NNF)r5rrrrrjrrrrrrrrrrrrrs@rrrsE %>?(+A ("  / 00rrc[U[5(a[R"[U5n[ R "U5 UR5 URXUS9nURU"S5U5 SSS5 U(a+URWRRS5U5 WsSSS5 $!,(df  NK=f!,(df  g=f)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) rTintrr&intp_tr suspend_emissiongoto_entry_blockallocarcrr`)rtyrrrnrs rrorojs${{64(  # #G ,  % % '..T.:C MM"T(C ((  MM#((**40# 6 - , ' ' - ,s$C)C;C C C C%ctU"S5nUR[S5/5nURU[5$)zCompute sizeof using GEP Nr )rrptrtointr)rptr_typenulloffsets rsizeofrs4 D>D XXwqzl #F   FF ++rcP[XRUS9nURX5 U$)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. rm)rorrc)rrrrnstorages ralloca_once_valuers% '::U;G MM%! Nrc[XU5nURRS5 URRS5 U$)zS Insert a pure function (in the functional programming sense) in the given module. readonlynounwind)get_or_insert_function attributesaddmodulefntyrfns rinsert_pure_functionrs9 d 3BMMj!MMj! IrcrURRUS5nUc[R"XU5nU$)za Get the function named *name* with type *fnty* from *module*, or insert it if it doesn't exist. N)globalsr2rFunctionrs rrrs4   D$ 'B z [[t , IrchURU5$![a URU5s$f=frr)get_named_metadataKeyErroradd_named_metadata)rrs rget_or_insert_named_metadatar&s8/((.. /((../s 11cRURU5n[R"XXC5$rr)get_unique_namerGlobalVariable)rr rr unique_names radd_global_variabler+s%((.K  V @@rcZURnURcURU5 ggrr) basic_block terminatorbranch)rbbendbbs r terminater2s(   B }}urcU"S5$rrr)ltypes rget_null_valuer5s ;rcP[UR5nURSX!5$)N==r5rrrr{rs ris_nullr:# #(( #D  t 11rcP[UR5nURSX!5$)Nrr8r9s r is_not_nullr=r;rc"URUSS9$)NFlikelyif_thenrpreds r if_unlikelyrEs ??4? ..rc"URUSS9$)NTr?rArCs r if_likelyrGs ??4? --rcBURURU55$rr)rBnot_rCs rifnotrJs ??7<<- ..rcFURS5nURXS/S9$)z Increment an index *val*. r nsw)flags)rr)rr{ones rincrement_indexrOs( ((1+C ;;sw; //rLoop)rzdo_breakc#^^ # Uc URnUcU"S5nUnTRS5nTRS5nTRS5m U U4SjnTRnTRU5 TR U5 TR USS9n TR S X5n TRXT 5 SSS5 TR U5 [W U5v TRn[TU 5n [TU5 SSS5 W RX(5 U RW U5 TRT 5 g!,(df  N=f!,(df  NT=f7f) z 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.endc(>TRT5 grr)r/)r0rsrrQfor_range..do_breaksur loop.indexr<) rappend_basic_blockr-r/ goto_blockphi icmp_signedcbranchrPrOr2 add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyrQbbstartrzrDincrr0s ` @r for_rangerjs> |zz }Q D  ' ' 3F  ' ' 3F  & &y 1E!!G NN6   F # D| 4""34e, $   F #5(##$$w.'6" $ u& tV$ E" $ # $ #s6BE) 5E>E)3E =E) EE) E&"E)c#~# Uc URnURS5nURS5nURS5nURn URU5 UR U5 UR USS9n UR USS9n U(aUR SX5n OUR S X5n URXU5 SSS5 UR U5 W W 4v URnURX5n [X 5n[X5 SSS5 W RX5 U RW U5 W R[R"US 5U 5 U RWU5 URU5 g!,(df  N=f!,(df  N=f7f) 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 NrSrTrUrXrYz loop.countrZ>r)rr[r-r/r\r]r^r_rrOr2r`rr&ra)rrcresteprdincrfrgr0rhrzrbrDri next_counts rfor_range_slicerps|4 |zz  ' ' 3F  ' ' 3F  & &y 1E!!G NN6   F # D| 4 D| 4 &&sE8D&&sE8De, $   F #Ul$${{5'$W4 '" $ u& tV$ r{{4+W5 z6* E") $ # $ #s8A1F=3AFF=+:F,%A6F= F)%F=, F:6F=c #8# URnURSU[R"US55n[ XX#USS9n[ XX#USS9n[ S5nUR USS9upU"X5U"X54v SSS5 g!,(df  g=f7f) 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)rnFc3# U UnUv SSS5 SSS5 g!,(df  N=f!,(df  g=f7frrr)condinner_cmrs rcm_cond(for_range_slice_generic..cm_cond`s+ U TTs'A// A , / =Ar?N)rr^rr&rprif_else) rrcrermrd is_pos_step pos_for_range neg_for_rangervthen otherwises rfor_range_slice_genericr~Ls ::D%%dD"++dA2FGK#GD$OM#GD%PM T 26Gtd*GI,MMM 3 2 2sA)B+B  B BBc## US;deU(dSv gUS:XaSnOSn[X"U5U5n[U5[U5:XdeU"U5v SSS5 g!,(df  g=f7f)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. CFrFcUSSS2$)Nrxs rloop_nest..~s a"grcU$rrrrs rrrsarN) _loop_nestr%)rshaperdorder_swapindicess r loop_nestrjsi D==  C<%EE ut 4w<3u:- --. 5 4 4s4A5%A$ A5$ A2.A5c## [XSUS9n[U5S:a+[XSSU5nUR4U-v SSS5 OUR4v SSS5 g!,(df  N=f!,(df  g=f7f)Nrrdr )rjr%rrz)rrrdlooprs rrrsp 7!H4 0D u:>G12Y5zzmg--65::-  1 055 1 0s3BA4A#A4 B# A1 -A44 B>Bc[U5nUcUSRn[R"X#5"[R5n[ U5HupVUR XFU5nM U$)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. r)r%rrr'rrr)rrr r+aryr!rs r pack_arrayrs^ F A z AY^^ ,,r bll +C&!""31-" Jrc[R"UVs/sHo"RPM sn5nU"[R5n[ U5HupRUR XBU5nM U$s snf)z/ Pack a sequence of values into a LLVM struct. r)rrrstructtystr!s r pack_structrs`##V$TbC[T[5(a[TSRT5TT5 g[TSTTT5 g[TSTT5 g)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 )rTrprintfrZ)axisrdimlenindsr_dbgdo_boundscheck.._dbgsb  $$$w!44:F4L#vOw!458$ 7O rzindex is out of boundsrrrZr)r^rErFULL_TRACEBACKS call_convreturn_user_exc IndexErrorr) rgrrrrrmsgout_of_bounds_upperout_of_bounds_lowers ```` rdo_boundscheckrs  #C!--dC@ W1 2  ! ! F))':vF 3"--c3 D W1 2  ! ! F))':vF 3 2 3 2 3 2s?C,$?C=, C:= D c U(al/n [Xc5HZupURSXRS55n URX5n UR XU 5nU R U5 M\ OUn U(a-[ [X55Hunup[XXU5 M U (dURU[S5/5$U SRnUS;Ga/nUS:XaV[[U55H=nU"S5nUUS-SHnURUU5nM UR U5 M? OdUS:XaS[[U55H:nU"S5nUSUHnURUU5nM UR U5 M< O [S5eU"S5n[U U5H*unnURUU5nURUU5nM, URUU/5nU$[XI5VVs/sHunnURUU5PM nnn[R"URU5n[!XU5$s snnf)NrZrrCr r unreachable)zipr^rrselectrrrrrrr%mul Exception functoolsreduce pointer_add)rgrr.rrrrrrrrrnegativewrappedselectedrrdstepsr!lastjlocstmprdimoffsrs rrrs' t+KC**3XXa[AHkk&.G~~h=H NN8 $ , #,S-@#A D-3 7S$ ?$B {{4'!*.. 1:??D ~ S=3u:&Awq1uvA";;tQ/D' T" ' s]3u:&AwrA";;tQ/D# T" ' M* *1g'DAq++a#C++c3'C(kk$& 25W1FG1FA7;;q!$1FG!!'++w77&11Hs IcVURS5n[UR[R[R45(a U"X5nU$[UR[R 5(aUR X1U5nU$[SUR<35e)Nrzunexpected value type )rrTr FloatType DoubleTyper(r^rY)rrfpredicondnullvalisnulls r_scalar_pred_against_zerorsjjmG%**r||R]];<<u& M EJJ + +$$U7; MejjBCCrcZ[X[R"URS5S5$)zC Return a predicate representing whether *value* is equal to zero. r7rrpartial fcmp_orderedrs ris_scalar_zeror%s- % ))'*>*>Et MMrcZ[X[R"URS5S5$)z| Return a predicate representing whether a *value* is not equal to zero. (not exactly "not is_scalar_zero" because of nans) rrrrfcmp_unorderedrs ris_not_scalar_zeror-- % ))'*@*@$G OOrcZ[X[R"URS5S5$)zQ Return a predicate representing whether *value* is equal to either zero or NaN. r7rrs ris_scalar_zero_or_nanr6rrcZ[X[R"URS5S5$)z2 Is *value* negative? Assumes *value* is signed. rZrrs r is_scalar_negrCs- % ))'*>*>Dc KKrstackc## URURUSS95up4U Sv SSS5 URU5 g!,(df  N =f7f)ah 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. Fr?N) enter_contextrx)rrrtr|r}s r early_exit_ifrKsF,))'//$u/*MNOD     " s$AAA AAc,[X[X55$)z A convenience wrapper for :func:`early_exit_if`, for the common case where the CPython API indicates an error by returning ``NULL``. )rr:)rrobjs rearly_exit_if_nullrgs )> ??rcUR[X5SS9 USnUSS=(d SnURRXU5 SSS5 g!,(df  g=f)zi Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. Fr?rr N)rBrrr)rgrr exc_tupleexcexc_argss r guard_nullrosU 7 FlQR=(D))'A G F Fs 0A A!c8[UR[R5(dUR5eU(aU4OSnUR [ X5SS9 UR RU[U5 SSS5 g!,(df  g=f)z? Guard against *pointer* being NULL (and raise a MemoryError). rFr?N) rTrr PointerTyperBr:rr MemoryError)rgrpointerrrs rguard_memory_errorrzsm gllBNN 3 3AW\\A 3v"H 25 A))';I B A As "B  Bc#z# UR[X5US9 Sv SSS5 g!,(df  g=f7f)z6 Execute the given block if the scalar value is zero. r?N)rBr)rrr@s rif_zerors+ 7 G  H G Gs;* ; 8;c6[U[R5$)z/ Whether the LLVM type *typ* is a struct type. )rTrr)ltyps rr^r^s dBNN ++rc[XSU5n[URR5(aeUR XCR 55$r)rr^rr`rrb)rrecordrtyppvals rget_record_memberrsA F 3D$))++,,, , ??4!1 22rcDURSXRS55$)NrZr)r^r)rr{s r is_neg_intrs   sC! 55rc$[X/UQ7SS0UD6$)z0 Same as *gep*, but add the `inbounds` keyword. rT)r)rrrkwss rrrs w 9d 9T 9S 99rcURSS5nURSS5nU(ae/nUH7n[U[5(a [U5nOUnUR U5 M9 UR XXES9$)z} Emit a getelementptr instruction for the given pointer and indices. The indices can be LLVM values or Python int constants. rrF)rr)rErTrrrr) rrrrrridxr!rs rrrsu 7762 Dwwz5)HN7 C  a  !*CC 3  ;;sd; >>rcURU[5n[U[5(a [U5nUR XB5nUR XC=(d UR 5$)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. )r rrTrrinttoptrr)rrr return_typeintptrs rrrsT  c6 *F&# [[ (F   F$;388 <G  VV 3 2s=D6#D D6 AD%D6 D" D6% D3 /D66 EcnURS5nURXU5 URU5 U$)zy Branch conditionally or continue. Note: a new block is created and builder is moved to the end of the new block. z .continue)r[r_ra)rrtbbtruebbconts rcbranch_or_continuer's5 ' ' 4F OOD&) F# MrcJURUR:Xde[XURS9nURXR/5nURX$R/5nUR UR U5U5 SSS5 g!,(df  g=f)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)rrjrrzrcr)rrIrJrbrout_ptrin_ptrs rmemcpyr+su 88sxx   7 3t++cJJ<0S::,/ gll6*G4 4 3 3s AB B"c dURn[U[5(a[R"Xu5nUR R U[[U/5n[n URXRU[5URU[5URXE5U /5 grr) rrTrrr&rr r  false_bitrrr) r func_namerIrJrbitemsizealignsize_tr+ is_volatiles r _raw_memcpyr31s ZZF(C  ;;v0 ^^ - -i/8)V.LNFK LL//#y9!//#y9!++e6%'(rc  [USXX4U5$)zU Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpyr3rrIrJrbr/r0s r raw_memcpyr7?s w s% PPrc  [USXUXE5$)zV Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmover5r6s r raw_memmover9Gs w% ((rcURX5nURUS5nURUS5nURXS5nURUS5nURX`RUS55n X4$)ze Compute (a * b + c) and return a (result, overflow bit) pair. The operands must be signed integers. rr )smul_with_overflowrsadd_with_overflowor_) rar*cpprodprod_ovfrr;ovfs rmuladd_with_overflowrDPs| ""1(A  A &D$$Q*H""4+A   1 %C ++h 5 5a ; rs 066 A A **R. E&& '     !9 1I 1I AY = :& " B06B0J |  1l 1 g0g0X2,/A  2 2 /./0f&;<(#(#V6#6#rNN:!!6    EJ!& MG>5:72tMOO  K#)##6@BJ ,3 6:?& =4  > 5* (Q( 44C4 0.8r