xKgidZddlZddlmZmZddlZddlmZddlm Z m Z m Z m Z ddl ZejdZejdZejdZeje j&Zej+ZedZedZedZedZd ZdTd Zd ZiZdUd Zifd Z Gdde!Z"Gdde"Z#Gdde"Z$Gdde!Z%dVdZ&dZ'dWdZ(dZ)dZ*dZ+dXdZ,dZ-dZ.dZ/d Z0d!Z1d"Z2d#Z3d$Z4ejjd%d&Z6edYd'Z7edZd(Z8ed)Z9ed[d*Z:ed+Z;dTd,Z d\d/Z?dTd0Z@ d\d1ZAd2ZBd3ZCd4ZDd5ZEeDZFeCZGd6ZHed7efd8ZId9ZJd:ZKdTd;ZLed]d<ZMeKZNd=ZOd>ZPd?ZQd@ZRdAZSdTdBZTdCZUdDZVd^dEZWdFZXdGZYdHZZdIZ[d_dJZ\d_dKZ]dLZ^dMZ_dNZ`dOZadPZbdQZcdRZddSZey)`z+ Generic helpers for LLVM code generation. N)contextmanager ExitStack)ir)utilstypesconfig debuginfo cF|jd||jdS)N!=r) icmp_unsignedtypebuildervalues V/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/core/cgutils.py as_bool_bitrs  uejjm <<c|-tj|Dcgc]}|jc}}|tj}t |D]\}}|j |||}|Scc}w)zH Create an anonymous struct containing the given LLVM *values*. rLiteralStructTyper Undefined enumerate insert_value)rvalues struct_typev struct_valis rmake_anonymous_structr" sn**F+CFqAFFF+CD R\\*J&!1))*a; "  ,DsA.ct|}t|}tjtjtj d||S)z0 Make a byte array constant from *buf*. r ) bytearraylenrConstant ArrayTypeIntType)bufbns rmake_bytearrayr,,s: #A AA ;;r||BJJqM15q 99rc||f}tj|}|Pttd|}|jdzt |z}|f}t |}t|||}|t|<|S)zK 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+ 7E:.),I& Jrc|j}|jjD]+}|j|t ||}t |||-|j D]\}}t ||||S)zJ Copy structure from *src* to *dst* with replacement from *repl*. )copy _datamodel_fieldspopgetattrsetattritems)dstsrcreplkrs r copy_structrMKsl 99;D ^^ # # HHQQ (Q$ 1Q Jrc|eZdZdZdZddZdZdZdZdZ dZ d Z d Z fd Z d Zd ZdZdZdZdZxZS) _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. Ncf||_|jj|j|_t |jt j jjs$tdj|j||_ |j|j|_ t|jrJ|j|\}}|j j"|jk7r3t%d|jj'd|j |n|j |j j"k7r/t%d|j j"d|j |jj)||||_||_y)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__z_StructProxy.__init__csL --::4==I$//5::+?+?+K+KL,33DOODF F ))$//: dmm,,,- 3 88  t}} , $(MM$<$<$>"JK K  zzY^^333$(1(>(> &LMM MM  y 1 #rcR|"t|j|jd}||fS)z Return an (outer ref, value ref) pair. By default, these are the same pointers, but a derived class may override this. Tzfill) alloca_oncerZr\)rergs rr^z_StructProxy._make_refs|s( ;dmmT]]$GCCxrctNNotImplementedErrorrerVs rr[z_StructProxy._get_be_type!!rctrorpreindexvals r_cast_member_to_valuez"_StructProxy._cast_member_to_valuersrctrorprus r_cast_member_from_valuez$_StructProxy._cast_member_from_valuersrcFt|j|jd|SNr) gep_inboundsrZrcrervs r_get_ptr_by_indexz_StructProxy._get_ptr_by_indexsDMM4;;5AArcZ|jj|}|j|Sro)rCget_field_positionr)reattrnamervs r_get_ptr_by_namez_StructProxy._get_ptr_by_names'228<%%e,,rcv|jds||jj|St|z; Load the LLVM value of the named *field*. r/) startswithrCrAttributeErrorrefields r __getattr__z_StructProxy.__getattr__s7$::5AB B ' 'rc|jdrtt|||S|||jj |<yz@ Store the LLVM *value* into the named *field*. r/N)rsuperrO __setattr__rCrrerr __class__s rrz_StructProxy.__setattr__s@   C t8F F:?T__ / / 67rcz|jj|j|}|j||Sz> Load the LLVM value of the field at *index*. )rZloadrrx)rerv member_vals r __getitem__z_StructProxy.__getitem__s6]]''(>(>u(EF ))%<.>.F.FF 33DMM4947HH4D4D4N4NP !D"(e4.3"("5 66 E3'rc.|jjSz. Return the number of fields. )rC field_countres r__len__z_StructProxy.__len__s***rc|jSzF Return the LLVM pointer to the underlying structure. )rdrs r _getpointerz_StructProxy._getpointersrcL|jj|jSzM Load and return the value of the underlying LLVM structure. )rZrrdrs r _getvaluez_StructProxy._getvalues}}!!$//22rct|jrJ|j|jk(sJ|j|jf|jj ||j y)z4 Store the value in this structure. N)r]rr\rZrbrcrers r _setvaluez_StructProxy._setvaluesVejj)))zzT]]*GUZZ,GG* E4;;/rNN)r5 __module__ __qualname____doc__r0rir^r[rxrzrrrrrrrrrr __classcell__rs@rrOrOZs\ H$2"""B-(@=(.+  3 0rrOc"eZdZdZdZdZdZy)r3zl Create a StructProxy suitable for accessing regular values (e.g. LLVM values or alloca slots). c"|jSro)get_value_typerrs rr[zValueStructProxy._get_be_types''))rc|Srorus rrxz&ValueStructProxy._cast_member_to_value rc|Srorrus rrzz(ValueStructProxy._cast_member_from_valuerrNr5rrrr[rxrzrrrr3r3s*rr3c"eZdZdZdZdZdZy)r4zO Create a StructProxy suitable for accessing data persisted in memory. c"|jSro) get_data_typerrs rr[zDataStructProxy._get_be_types&&((rcp|jj|}|j|j|Sro)rC get_model from_datarZrervrwmodels rrxz%DataStructProxy._cast_member_to_values+))%0t}}c22rcp|jj|}|j|j|Sro)rCras_datarZrs rrzz'DataStructProxy._cast_member_from_values+))%0}}T]]C00rNrrrrr4r4s)31rr4c`eZdZdZd dZdZdZdZfdZdZ dZ d Z d Z d Z d ZxZS) Structurezs A high-level object wrapping a alloca'ed LLVM structure, including named fields and attribute access. c|j||_||_||_|t ||jd|_| t |jrJ|j|jk(sJ|j|jf|j||j n|Jt |jsJ|j|jjk7r\|r+|j||jj}n/td|jjd|j||_i|_ g|_g|_t!d}t#|j$D]X\}\}} ||j|<|jj'|t!|f|jj'| Zy)NTrkzmismatching pointer type: got z , expected r)get_struct_type_typerQrZrmrcr]rrbr_bitcastrarX_namemap_fdmap_typemapint32_trrDappend) rerfrrrgcast_refr<r!rLtps rrizStructure.__init__s,,T2   ;%gtzzFDK %ejj111zzTZZ/I%**djj1II/ eT[[1= =chh' ''zzSXX---!//#tzz/D/D/FGC#88++TZZ9::DK   qz#DLL1JAw2 DMM!  KK  gaj1 2 MM  $2rcp|jj|j|j|d}|S)NT)inbounds)rZgeprcr)rervrs rrzStructure._get_ptr_by_index$s/mm T[[-?$O rc>|j|j|Sro)rr)rers rrzStructure._get_ptr_by_name(s%%dmmH&=>>rc^|jds||j|St|r)rrrrs rrzStructure.__getattr__+s1$ e,- - ' 'rct|jdrtt|||S|||j|<yr)rrrrrrs rrzStructure.__setattr__4s:   C D5eUC C%*T]]5 !"rcV|jj|j|Sr)rZrrr~s rrzStructure.__getitem__<s$ }}!!$"8"8"?@@rc*|j|}|jj|jk7rCd}t||t |jjt |jfz|j j ||y)rz:Type mismatch: __setitem__(%d, ...) expected %r but got %rN)rrr_r`r6rZrb)rervrrfmts rrzStructure.__setitem__Cs}$$U+ 88  uzz )NC (+CHH,<,<(=(+EJJ(9"9: : E3'rc,t|jSr)r%rrs rrzStructure.__len__Os4==!!rc|jSr)rcrs rrzStructure._getpointerUs{{rcL|jj|jSr)rZrrcrs rrzStructure._getvalue[s}}!!$++..rct|jrJ|j|jk(sJ|j|jf|jj ||j y)z!Store the value in this structureN)r]rrrZrbrcrs rrzStructure._setvalueasTejj)))zzTZZ'A%**djj)AA' E4;;/r)NNF)r5rrrrirrrrrrrrrrrrs@rrrs@ %>?(+A ("  / 0rrct|trtjt|}t j |5|j5|j|||}|j|d|ddd|r+|jjjd|cdddS#1swYAxYw#1swYyxYw)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_tr suspend_emissiongoto_entry_blockallocarbrr_)rtyrrrlrs rrmrmjs${{64(  # #G ,  % % '..$T.:C MM"T(C ((  MM#((**40# 6 - , ' ' - ,s$C -B>>6C >C C  Cct|d}|jtdg}|j|tS)zCompute sizeof using GEP Nr )rrptrtointr)rptr_typenulloffsets rsizeofrs4 D>D XXwqzl #F   FF ++rcZt||j|}|j|||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. rk)rmrrb)rrrrlstorages ralloca_once_valuers) '5::U;G MM%! Nrct|||}|jjd|jjd|S)z_ Insert a pure function (in the functional programming sense) in the given module. readonlynounwind)get_or_insert_function attributesaddmodulefntyrfns rinsert_pure_functionrs; d 3BMMj!MMj! Ircp|jj|d}|tj|||}|S)zm Get the function named *name* with type *fnty* from *module*, or insert it if it doesn't exist. N)globalsr2rFunctionrs rrrs6   D$ 'B z [[t , Ircf |j|S#t$r|j|cYSwxYwro)get_named_metadataKeyErroradd_named_metadata)rrs rget_or_insert_named_metadatars8/((.. /((../s 00cT|j|}tj||||Sro)get_unique_namerGlobalVariable)rrrr unique_names radd_global_variablers)((.K  VRi @@rcX|j}|j|j|yyro) basic_block terminatorbranch)rbbendbbs r terminater s(   B }}urc|dSror)ltypes rget_null_valuers ;rcRt|j}|jd||S)N==rrrrrwrs ris_nullr% #(( #D  tS 11rcRt|j}|jd||S)Nrrrs r is_not_nullrrrc(|j|dS)NFlikelyif_thenrpreds r if_unlikelyrs ??4? ..rc(|j|dS)NTrrrs r if_likelyr!s ??4? --rcB|j|j|Sro)rnot_rs rifnotr$s ??7<<- ..rcN|jd}|j||dgS)z# Increment an index *val*. r nsw)flags)rr)rrwones rincrement_indexr)s* ((1+C ;;sCw; //rLoop)rvdo_breakc# K| |j}||d}|}jd}jd}jd fd}j}j|j |5j |d} j d | |} j| | dddj |5t |j}t| } t|ddd j||| j |j y#1swYxYw#1swYKxYww) 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.endc(jyro)r )r rsrr+zfor_range..do_breaksur loop.indexr<) rappend_basic_blockrr  goto_blockphi icmp_signedcbranchr*r)r  add_incomingposition_at_end) rcountstartintpstopbbcondbbbodyr+bbstartrvrincrr s ` @r for_rangerCsE |zz }Q D  ' ' 3F  ' ' 3F  & &y 1E!!G NN6   F # D| 4""3t4fe, $   F #5(##$$w.'6" $ ug& tV$ E" $ # $ #s6BE":E E"3E >E" EE"EE"c#vK| |j}|jd}|jd}|jd}|j} |j||j |5|j |d} |j |d} |r|j d| |} n|j d | |} |j| ||ddd|j |5  f|j}|j| |} t|| }t||ddd j|| | j | jtj|d | | j||j|y#1swYxYw#1swYxYww) 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/r1r2z loop.countr3>r)rr4rr r5r6r7r8rr)r r9rr&r:)rr<r>stepr=incr?r@r rArvr;rrB next_counts rfor_range_slicerIs4 |zz  ' ' 3F  ' ' 3F  & &y 1E!!G NN6   F # D| 4 D| 4 &&sE48D&&sE48Dfe, $   F #Ul$${{5$'$We4 '6" $ ug& tV$ r{{4+W5 z6* E") $ # $ #s8A0F92A#F!F9.=F-+A6F9!F*&F9-F62F9c#LK|j}|jd|tj|d}t |||||d}t |||||d}t d}|j |d5\} } || ||| |fdddy#1swYyxYww) 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)rGFc3pK|5|5}|ddddddy#1swYxYw#1swYyxYwwror)condinner_cmrs rcm_condz(for_range_slice_generic..cm_cond`s, U TTs$6** 6' *36rN)rr7rr&rIrif_else) rr<r>rFr= is_pos_step pos_for_range neg_for_rangerOthen otherwises rfor_range_slice_genericrVLs ::D%%dD"++dA2FGK#GUD$$OM#GUD$%PM T 26GtYdM*GI},MMM 3 2 2sA5B$7B B$B!B$c#K|dvsJ|sdy|dk(rd}nd}t||||5}t|t|k(sJ||dddy#1swYyxYww)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. CFrFc|dddS)Nrxs rzloop_nest..~s a"grc|Srorr\s rr^zloop_nest..sarN) _loop_nestr%)rshaper=order_swapindicess r loop_nestrejsj D==  C<%EE ut 4w<3u:- --. 5 4 4s-A($A A(A%!A(c#Kt||d|5}t|dkDr,t||dd|5}|jf|zdddn|jfdddy#1swYxYw#1swYyxYww)Nrr=r )rCr%r`rv)rrar=looprds rr`r`su 7E!H4 0D u:>GU12Y5zzmg--65::-  1 055 1 0s3A?A3A'A3 A?'A0 ,A33A<8A?ct|}||dj}tj||tj}t |D]\}}|j |||}|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. r)r%rrr'rrr)rrrr+aryr!rs r pack_arrayrksf F A z AY^^ ",,r1 bll +C&!1""31-" Jrctj|Dcgc]}|jc}}|tj}t |D]\}}|j |||}|Scc}w)z7 Pack a sequence of values into a LLVM struct. r)rrrstructtystr!s r pack_structrosf##V$ttrtdjytdytdy)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 )rSrprintfrY)axisrdimlenindsr_dbgzdo_boundscheck.._dbgs_  $$w!44:F4L#vOw!458$ 7O rzindex is out of boundsrKr3r)r7rrFULL_TRACEBACKS call_convreturn_user_exc IndexErrorr) rfrrrrrmsgout_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*-C6c |rog} t||D]]\} } |jd| | jd} |j| | } |j | | | }| j |_n|} |r/t t| |D]\}\} } t||| | || s|j|tdgS| dj}|dvr g}|dk(rRtt|D]:}|d}||dzdD]}|j||}|j |<n_|dk(rOtt|D]7}|d}|d|D]}|j||}|j |9n td|d}t| |D])\}}|j||}|j||}+|j||g}|St|| Dcgc]\}}|j||}}}tj|j|}t!|||Scc}}w)Nr3rrXCr rY unreachable)zipr7rrselectrrrrrrrr%mul Exception functoolsreduce pointer_add)rfrr.rarxryrzr{r|rdrrnegativewrappedselectedrr=stepsr!lastjlocstmprdimoffsrs rr~r~s= tU+KC**3SXXa[AHkk&#.G~~h=H NN8 $ , #,S%-@#A D-3 7GS&$ ?$B {{4'!*.. 1:??D ~ S=3u:&Awq1uvA";;tQ/D' T" ' s]3u:&AwrA";;tQ/D# T" ' M* *1g'DAq++a#C++c3'C(kk$& 25Wg1FG1FA7;;q!$1FG!!'++w77D&11Hs3H?cD|jd}t|jtjtjfr |||}|St|jtj r|j |||}|Std|j)Nrzunexpected value type )rrSr FloatType DoubleTyper(r7rX)rrfpredicondnullvalisnulls r_scalar_pred_against_zerorsjjmG%**r||R]];<ug& M EJJ +$$UE7; MejjBCCrcZt||tj|jddS)zK Return a predicate representing whether *value* is equal to zero. rrrpartial fcmp_orderedrs ris_scalar_zeror%s/ % ))'*>*>Et MMrcZt||tj|jddS)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 OOrcZt||tj|jddS)z] Return a predicate representing whether *value* is equal to either zero or NaN. rrrs ris_scalar_zero_or_nanr6rrcZt||tj|jddS)z: Is *value* negative? Assumes *value* is signed. r3rrs r is_scalar_negrCs/ % ))'*>*>Dc KKrstackc#K|j|j|d\}}|5dddd|j|y#1swYxYww)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_contextrP)rrrMrTrUs r early_exit_ifrKsI,))'//$u/*MNOD)     " s(AA A AAc0t||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)rrobjs rearly_exit_if_nullrgs %#)> ??rc|jt||d5|d}|ddxsd}|jj|||dddy#1swYyxYw)zu Guard against *value* being null or zero. *exc_tuple* should be a (exception type, arguments...) tuple. Frrr N)rrrr)rfrr exc_tupleexcexc_argss r guard_nullrosY 7 FlQR=(D))'3A G F Fs ,AAc"t|jtjsJ|j|r|fnd}|j t ||d5|j j|t|dddy#1swYyxYw)zG Guard against *pointer* being NULL (and raise a MemoryError). rFrN) rSrr PointerTyperrrr MemoryError)rfrpointerrrs rguard_memory_errorrzsl gllBNN 3AW\\A 3v"H '25 A))';I B A As "BBc#xK|jt|||5ddddy#1swYyxYww)z> Execute the given block if the scalar value is zero. rN)rr)rrrs rif_zerors. 7 G  H G Gs:. :7:c6t|tjS)z7 Whether the LLVM type *typ* is a struct type. )rSrr)ltyps rr]r]s dBNN ++rct||d|}t|jjrJ|j ||j Sr|)r}r]rr_rra)rrecordrtyppvals rget_record_memberrsB F 3D$))++,, , ??4!1 22rcF|jd||jdS)Nr3r)r7r)rrws r is_neg_intrs   sC! 55rc&t||g|ddi|S)z8 Same as *gep*, but add the `inbounds` keyword. rT)r)rrrzkwss rr}r}s  w 9d 9T 9S 99rc|jdd}|jdd}|rJg}|D]1}t|tr t|}n|}|j |3|j ||||S)z Emit a getelementptr instruction for the given pointer and indices. The indices can be LLVM values or Python int constants. rrF)rr)rErSrrrr) rrrzrrridxr!rs rrrsv 7762 Dwwz5)HN7 C  a !*CC 3  ;;sCdX; >>rc|j|t}t|tr t|}|j ||}|j ||xs |j S)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_typeintptrs rrrsU  c6 *F&# [[ (F   FK$;388 <G W VV 3 2s=D6!%D D6AD*D6D' #D6*D3 /D66D?cp|jd}|j||||j||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)r4r8r:)rrMbbtruebbconts rcbranch_or_continuers7 ' ' 4F OOD&&) F# MrcJ|j|jk(sJt|||j5}|j||jg}|j||jg}|j |j ||dddy#1swYyxYw)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 rgN)rrCrrvrbr)rrIrJr;rhout_ptrin_ptrs rmemcpyrs{ 88sxx   7E 3t++cDJJ<0S4::,/ gll6*G4 4 3 3s ABB"c ^|j}t|trtj||}|j j |tt|g}t} |j||j|t|j|t|j||| gyro) rrSrrr&rrr false_bitrrr) r func_namerIrJr;itemsizealignsize_tr is_volatiles r _raw_memcpyr 1s ZZF(C ;;vx0 ^^ - -i/8)V.LNFK LL'//#y9!//#y9!++eX6%'(rc $t|d|||||S)za Emit a raw memcpy() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memcpyr rrIrJr;rrs r raw_memcpyr ?s w sC% PPrc $t|d|||||S)zb Emit a raw memmove() call for `count` items of size `itemsize` from `src` to `dest`. z llvm.memmover r s r raw_memmoverGs wS% ((rc|j||}|j|d}|j|d}|j||}|j|d}|j||j|d} || fS)zq Compute (a * b + c) and return a (result, overflow bit) pair. The operands must be signed integers. rr )smul_with_overflowrssadd_with_overflowor_) rar*cpprodprod_ovfrr;ovfs rmuladd_with_overflowrPs ""1a(A  A &D$$Q*H""4+A   1 %C ++h 5 5a ; r\s 066 A A "**R. E&& '     !9 1I 1I AY = :& " B06B0J |  1l 1 g0g0X2,/A  2 2 /./0{f&;<(#(#V6#6#rNN:!!6    EJ!& MG>5:72tMOO  K#)##6@BJ ,3 6:?& =4  > 5* (Q( 44C4 0.8r