.@jddlZddlZddlmZmZmZddddddd Zejfd Zejfd Z ejfd Z ejfd Z dZ dZ dZdZejfdZdZGddeZdS)N) instructionstypesvaluesgtlteqnegele)><==!=z>=z<=cfd}|S)NcJtj|dfd }|S)Nch|j|j|g||}|||SNblocktype_insert)selfargnameflagsinstrclsopnames DC:\Projects\Historical\venv\Lib\site-packages\llvmlite/ir/builder.pywrappedz$_unop..wrap..wrappeds9C CHfseT5IIE LL   Lrr functoolswrapsfnr"rr s r!wrapz_unop..wrapB             r#rr rr*s`` r!_unopr-) Kr#cfd}|S)NcJtj|dfd }|S)Nrrc|j|jkr td|jd|jd|j|j||f||}|||S)N%Operands must be the same type, got (, ))r ValueErrorrr)rlhsrhsrrrrr s r!r"z%_binop..wrap..wrappedstx38## j$'HHHchhh"8999C CHfsCj$NNE LL   Lr#r$r%r(s r!r*z_binop..wrapsB            r#rr,s`` r!_binopr8s)       Kr#cfd}|S)NcHtj|dfd }|S)Nrc|j|jkr td|jd|jd|j}t|tjst d|tjd}|j}tjtj||g||g}| d d|g|}| |||g|} | S) Nr2r3r4zexpected an integer type, got zllvm.z.with.overflowr) rr5 isinstancerIntType TypeErrormodule FunctionTypeLiteralStructTypedeclare_intrinsiccall) rr6r7rtybool_tymodfntyr)retr s r!r"z3_binop_with_overflow..wrap..wrapped/sx38## j$'HHHchhh"8999Bb%-00 Libb JKKKmA&&G+C%e&=r7m&L&L')2h00D&&&&&&'J(*tT33B))Bc )66CJr#rr%r)r"r s r!r*z"_binop_with_overflow..wrap.s=           "r#rr,s` r!_binop_with_overflowrM-s#* Kr#cfd}|S)NcJtj|dfd }|S)Nrcf|j|j|g|}|||Srr)roperandrrrr s r!r"z%_uniop..wrap..wrappedHs7C GL&7)TJJE LL   Lr#rKr%r(s r!r*z_uniop..wrapGr+r#rr,s`` r!_unioprRFr.r#cfd}|S)NcHtj|dfd }|S)Nrct|jtjst d|jz|j|jg}|||g|S)N expected an integer type, got %s)r>rrr?r@rArDrErrQrr)r s r!r"z3_uniop_intrinsic_int..wrap..wrappedUsmglEM:: "6L!"""..v ~FFB99R'D11 1r#rKr%rLs r!r*z"_uniop_intrinsic_int..wrapTs=    2 2 2 2 2   2r#rr r*s` r!_uniop_intrinsic_intrYSs#      Kr#cfd}|S)NcHtj|dfd }|S)Nrct|jtjtjfst d|jz|j|jg}|||g|S)Nexpected a float type, got %s) r>rr FloatType DoubleTyper@rArDrErWs r!r"z5_uniop_intrinsic_float..wrap..wrappedesrL5?E4D"EGG P ?', NOOO..v ~FFB99R'D11 1r#rKr%rLs r!r*z$_uniop_intrinsic_float..wrapds=    2 2 2 2 2   2r#rrXs` r!_uniop_intrinsic_floatr`cs#      Kr#cfd}|S)NcHtj|dfd }|S)Nrc|t|jtjst d|jzt|jtjr|jjdkst d|jz|j|j|jg}||||g|S)NrVr<zexpected an i1 type, got %s) r>rrr?r@widthrArDrE)rrQflagrr)r s r!r"z9_uniop_intrinsic_with_flag..wrap..wrappedtsglEM:: "6L!"""ty%-88 KIOq(( = IJJJ..ty133B99R'4$77 7r#rKr%rLs r!r*z(_uniop_intrinsic_with_flag..wrapss=    8 8 8 8 8   8r#rrXs` r!_uniop_intrinsic_with_flagrfrs# Kr#cfd}|S)NcHtj|dfd }|S)Nrc|j|jks|j|jkr'td|jd|jd|jt|jtjtjtjfstd|jz|j|j|j|jg}| ||||g|S)Nz#expected types to be the same, got r3z'expected an floating point type, got %s) rr@r>rHalfTyper^r_rArDrE)rabcrr)r s r!r"z/_triop_intrinsic..wrap..wrappedsv16QV#3#3i !!!  F^U_e6FGII  =F..v7OPPB99R!QD11 1r#rKr%rLs r!r*z_triop_intrinsic..wraps=    2 2 2 2 2   2 r#rrXs` r!_triop_intrinsicrns#( Kr#cfd}|S)NcJtj|dfd }|S)Nrct|j|kr|S|j|||}|||Sr)rrr)rvaltyprrrr s r!r"z&_castop..wrap..wrappedsCx3 C FCd;;E LL   Lr#rKr%r(s r!r*z_castop..wrapsB            r#rr,s`` r!_castoprts)       Kr#cvt|dkr"d}d|d|d|gS||zS)zReturns (label + suffix) or a truncated version if it's too long. Parameters ---------- label : str Label name suffix : str Label suffix 2rNz..)lenjoin)labelsuffixnheads r! _label_suffixr}sC 5zzBwwfuf tV4555v~r#c eZdZddZedZeZedZedZdZ dZ dZ d Z dd Z d Zejd ZejdZejdZejddZejddZdZdZedddZedddZedddZedddZedddZedddZed dd!Zed"dd#Z ed$dd%Z!ed&dd'Z"ed(dd)Z#ed*dd+Z$ed,dd-Z%ed.dd/Z&ed0dd1Z'ed2dd3Z(ed4dd5Z)ed6dd7Z*e+d8dd9Z,e+d:dd;Z-e+d<dd=Z.e+d>dd?Z/e+d@ddAZ0e+dBddCZ1ddDZ2ddEZ3e4dFddHZ5dIZ6ddJZ7ddKZ8ddLZ9ddMZ:ddNZ;ees5-...Q "r#c|jS)z* The current basic block. )rrs r!rzIRBuilder.blocks {r#c|jjS)z' The current function. )rparentrs r!functionzIRBuilder.functions z  r#c$|jjjS)z% The current module. )rrrArs r!rAzIRBuilder.modules z ''r#cf|j|_|jj||_dS)z Position immediately before the given instruction. The current block is also changed to the instruction's basic block. Nrrrindexrrrs r!position_beforezIRBuilder.position_befores+ l {/55e<< r#cl|j|_|jj|dz|_dS)z Position immediately after the given instruction. The current block is also changed to the instruction's basic block. r<Nrrs r!position_afterzIRBuilder.position_afters0 l {/55e<> rhs Nrrs r!rzIRBuilder.lshrvrr#ashrcdS)zX Arithmetic (signed) right integer shift: name = lhs >> rhs Nrrs r!rzIRBuilder.ashr}rr#addcdS)z@ Integer addition: name = lhs + rhs Nrrs r!rz IRBuilder.addrr#faddcdS)zG Floating-point addition: name = lhs + rhs Nrrs r!rzIRBuilder.faddrr#subcdS)zC Integer subtraction: name = lhs - rhs Nrrs r!rz IRBuilder.subrr#fsubcdS)zJ Floating-point subtraction: name = lhs - rhs Nrrs r!rzIRBuilder.fsubrr#mulcdS)zF Integer multiplication: name = lhs * rhs Nrrs r!rz IRBuilder.mulrr#fmulcdS)zM Floating-point multiplication: name = lhs * rhs Nrrs r!rzIRBuilder.fmulrr#udivcdS)zI Unsigned integer division: name = lhs / rhs Nrrs r!rzIRBuilder.udivrr#sdivcdS)zG Signed integer division: name = lhs / rhs Nrrs r!rzIRBuilder.sdivrr#fdivcdS)zG Floating-point division: name = lhs / rhs Nrrs r!rzIRBuilder.fdivrr#uremcdS)zJ Unsigned integer remainder: name = lhs % rhs Nrrs r!rzIRBuilder.uremrr#sremcdS)zH Signed integer remainder: name = lhs % rhs Nrrs r!rzIRBuilder.sremrr#fremcdS)zH Floating-point remainder: name = lhs % rhs Nrrs r!rzIRBuilder.fremrr#orcdS)zB Bitwise integer OR: name = lhs | rhs Nrrs r!or_z IRBuilder.or_rr#andcdS)zC Bitwise integer AND: name = lhs & rhs Nrrs r!and_zIRBuilder.and_rr#xorcdS)zC Bitwise integer XOR: name = lhs ^ rhs Nrrs r!rz IRBuilder.xorrr#saddcdS)zn Signed integer addition with overflow: name = {result, overflow bit} = lhs + rhs Nrrs r!sadd_with_overflowzIRBuilder.sadd_with_overflowrr#smulcdS)zt Signed integer multiplication with overflow: name = {result, overflow bit} = lhs * rhs Nrrs r!smul_with_overflowzIRBuilder.smul_with_overflowrr#ssubcdS)zq Signed integer subtraction with overflow: name = {result, overflow bit} = lhs - rhs Nrrs r!ssub_with_overflowzIRBuilder.ssub_with_overflowrr#uaddcdS)zp Unsigned integer addition with overflow: name = {result, overflow bit} = lhs + rhs Nrrs r!uadd_with_overflowzIRBuilder.uadd_with_overflowrr#umulcdS)zv Unsigned integer multiplication with overflow: name = {result, overflow bit} = lhs * rhs Nrrs r!umul_with_overflowzIRBuilder.umul_with_overflow rr#usubcdS)zs Unsigned integer subtraction with overflow: name = {result, overflow bit} = lhs - rhs Nrrs r!usub_with_overflowzIRBuilder.usub_with_overflowrr#ct|jtjr(t j|jd|jjz}nt j|jd}||||S)zG Bitwise integer complement: name = ~value )rr=)r>rr VectorTyperConstantcountr)rvaluerr7s r!not_zIRBuilder.not_se ej%"2 3 3 2/%*eej6F.FGGCC/%*b11Cxxsx...r#cb|tj|jd||S)z= Integer negative: name = -value rr=)rrrr)rrrs r!negz IRBuilder.neg&s* xx A66DxIIIr#fnegrcdS)zB Floating-point negative: name = -arg Nr)rrrrs r!rzIRBuilder.fneg-rr#c t|}n!#t$rtd|dwxYw|dvr||z}tj|j||||}|||S)Nzinvalid comparison z for icmp)rrr=)_CMP_MAPKeyErrorr5r ICMPInstrrr)rprefixcmpopr6r7roprs r!_icmpzIRBuilder._icmp8s J%BB J J J*HII I J  $ $"B&tz2sCdKKK U s .c4|d||||S)z Signed integer comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=' srrrr6r7rs r! icmp_signedzIRBuilder.icmp_signedCzz#uc3555r#c4|d||||S)z Unsigned integer (or pointer) comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=' urrs r! icmp_unsignedzIRBuilder.icmp_unsignedLrr#c|tvrdt|z}n|}tj|j|||||}|||S)z Floating-point ordered comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' orrr r FCMPInstrrrrrr6r7rrrrs r! fcmp_orderedzIRBuilder.fcmp_orderedUa H  x&BBB& JC4u>>> U r#c|tvrdt|z}n|}tj|j|||||}|||S)z Floating-point unordered comparison: name = lhs rhs where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno' rrrrs r!fcmp_unorderedzIRBuilder.fcmp_unordereder!r#cntj|j|||||}|||S)zN Ternary select operator: name = cond ? lhs : rhs r)r SelectInstrrr)rcondr6r7rrrs r!selectzIRBuilder.selectusA (T3$/4666 U r#trunccdS)z_ Truncating integer downcast to a smaller type: name = (typ) value Nrrrrsrs r!r(zIRBuilder.truncrr#zextcdS)z` Zero-extending integer upcast to a larger type: name = (typ) value Nrr*s r!r+zIRBuilder.zextrr#sextcdS)z` Sign-extending integer upcast to a larger type: name = (typ) value Nrr*s r!r-zIRBuilder.sextrr#fptrunccdS)z` Floating-point downcast to a less precise type: name = (typ) value Nrr*s r!r/zIRBuilder.fptruncrr#fpextcdS)z^ Floating-point upcast to a more precise type: name = (typ) value Nrr*s r!r1zIRBuilder.fpextrr#bitcastcdS)zZ Pointer cast to a different pointer type: name = (typ) value Nrr*s r!r3zIRBuilder.bitcastrr# addrspacecastcdS)z[ Pointer cast to a different address space: name = (typ) value Nrr*s r!r5zIRBuilder.addrspacecastrr#fptouicdS)z\ Convert floating-point to unsigned integer: name = (typ) value Nrr*s r!r7zIRBuilder.fptouirr#uitofpcdS)z\ Convert unsigned integer to floating-point: name = (typ) value Nrr*s r!r9zIRBuilder.uitofprr#fptosicdS)zZ Convert floating-point to signed integer: name = (typ) value Nrr*s r!r;zIRBuilder.fptosirr#sitofpcdS)zZ Convert signed integer to floating-point: name = (typ) value Nrr*s r!r=zIRBuilder.sitofprr#ptrtointcdS)z Cast pointer to integer: name = (typ) value Warning: Since LLVM 22, this is affected by changes in pointer provenance behavior. See docs :ref:`llvm22-pointer-provenance`. Nrr*s r!r?zIRBuilder.ptrtointrr#inttoptrcdS)z Cast integer to pointer: name = (typ) value Warning: Since LLVM 22, this is affected by changes in pointer provenance behavior. See docs :ref:`llvm22-pointer-provenance`. Nrr*s r!rAzIRBuilder.inttoptrrr#cL|not|tjtjfr"t|jt jsJn'tjt jd|}tj|j |||}| ||S)zl Stack-allocate a slot for *size* elements of the given type. (default one element) N ) r>rValuerrrr?r AllocaInstrrr)rrssizerals r!allocazIRBuilder.allocas <  v|V_= > > <di77 7 77 7?5=#4#4d;;D  %dj#tT B B R r#ct|jtjs(d}t ||jt |fzt j|j|||}||_ | ||Szf Load value from pointer, with optional guaranteed alignment: name = *ptr z5cannot load from value of type %s (%r): not a pointer)rs) r>rr PointerTyper@strr LoadInstrralignr)rptrrrOrsmsglds r!loadzIRBuilder.loadsy #(E$566 8ICC38SXX"6677 7  #DJTs C C C R r#ct|jtjs(d}t ||jt |fz|jjs5|jj|jkr t d|jd|jdtj |j ||}||_ | ||Sze Store value to pointer, with optional guaranteed alignment: *ptr = name z4cannot store to value of type %s (%r): not a pointerz cannot store z to z: mismatching types) r>rrrLr@rM is_opaquepointeer StoreInstrrrOr)rrrPrOrQsts r!storezIRBuilder.stores #(E$566 8HCC38SXX"6677 7x! 6ch&6%*&D&D)$zzz3888566 6  $TZ < < R r#ct|jtjs(d}t ||jt |fzt j|j|||||}| ||SrK) r>rrrLr@rMrLoadAtomicInstrrr)rrPorderingrOrrsrQrRs r! load_atomiczIRBuilder.load_atomics} #(E$566 8ICC38SXX"6677 7  ) JXud=== R r#cbt|jtjs(d}t ||jt |fz|jj|jkr t d|jd|jdtj|j ||||}| ||SrU) r>rrrLr@rMrWrStoreAtomicInstrrr)rrrPr]rOrQrYs r! store_atomiczIRBuilder.store_atomic$s #(E$566 8HCC38SXX"6677 7 8 uz ) ))$zzz3888566 6  * JsHe55 R r#chtj|jd||}|||S)zF Create a switch-case with a single *default* target. switch)r SwitchInstrrr)rrdefaultswts r!rczIRBuilder.switch8s5&tz8UGLL S!!! r#chtj|jd|g}|||S)z3 Unconditional branch to *target*. rrBranchrr)rtargetrs r!rzIRBuilder.branch@s5 TF8 < < R    r#cltj|jd|||g}|||S)zV Conditional branch to *truebr* if *cond* is true, else to *falsebr*. r)rConditionalBranchrr)rr&truebrfalsebrrs r!rzIRBuilder.cbranchHsA +DJ-167,CEE R    r#cftj|jd|}|||S)z3 Indirect branch to target *addr*. indirectbr)rIndirectBranchrr)raddrrs r!branch_indirectzIRBuilder.branch_indirectQs3 (\4 H H R    r#c\|tj|jdS)z7 Return from function without a value. zret voidrrRetrrs r!ret_voidzIRBuilder.ret_voidYs.##  TZ 4 466 6r#c^|tj|jd|S)z> Return from function with the given *value*. rJru)rrs r!rJz IRBuilder.ret`s0##  TZ 6 688 8r#chtj|jd|g}|||S)z0 Resume an in-flight exception. resumerh)r landingpadrs r!rzzIRBuilder.resumegs5 X | D D R    r#Fc ttj|j|||||||| } || | S)zP Call function *fn* with *args*: name = fn(args...) )rcconvtailfastmathattrs arg_attrs)r CallInstrrr) rr)argsrr}r~rrrinsts r!rEzIRBuilder.callqsM %dj"d,1x,1YHHH T r#c^tj||||}||||S)z# Inline assembler. )r InlineAsmrE)rftypeasm constraintr side_effectrs r!rz IRBuilder.asm}s0$UC[IIyydD)))r#cftj|g}||dd|zgd|S)zo Load a register value into an LLVM value. Example: v = load_reg(IntType(32), "eax") rz={%s}F)rrBr)rreg_typereg_namerrs r!load_regzIRBuilder.load_regs7 "8R00xxr7X#5r5$GGGr#ctjtj|g}||dd|z|gd|S)z Store an LLVM value inside a register Example: store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax") rz{%s}T)rrBVoidTyper)rrrrrrs r! store_regzIRBuilder.store_regsC "5>#3#3hZ@@xxr6H#4ugtTJJJr#c vtj|j|||||||||  } || | S)N)rr}rrr)r InvokeInstrrr) rr)r normal_to unwind_torr}rrrrs r!invokezIRBuilder.invokesM' Bi(1E192;=== T""" r#cntj|j|||||}|||S)zo Compute effective address (getelementptr): name = getelementptr ptr, )inboundsr source_etype)rGEPInstrrr)rrPindicesrrrrs r!gepz IRBuilder.gepsG %dj#w/7d3?AAA U r#cjtj|j|||}|||S)z4 Returns the value at position idx. r=)rExtractElementrr)rvectorrrrs r!extract_elementzIRBuilder.extract_elements6+DJ$OOO U r#cltj|j||||}|||S)z Returns vector with vector[idx] replaced by value. The result is undefined if the idx is larger or equal the vector length. r=)r InsertElementrr)rrrrrrs r!insert_elementzIRBuilder.insert_elements? *4:vuc04666 U r#cltj|j||||}|||S)a Constructs a permutation of elements from *vector1* and *vector2*. Returns a new vector in the same length of *mask*. * *vector1* and *vector2* must have the same element type. * *mask* must be a constant vector of integer types. r=)r ShuffleVectorrr)rvector1vector2maskrrs r!shuffle_vectorzIRBuilder.shuffle_vectors?*4:w04666 U r#ct|ttfs|g}tj|j|||}|||S)z= Extract member number *idx* from aggregate. r=)r>tuplelistr ExtractValuerr)raggrrrs r! extract_valuezIRBuilder.extract_valuesS#t}-- %C)$*c3TJJJ U r#ct|ttfs|g}tj|j||||}|||S)zI Insert *value* into member number *idx* from aggregate. r=)r>rrr InsertValuerr)rrrrrrs r! insert_valuezIRBuilder.insert_valuesU#t}-- %C(S%4PPP U r#cjtj|j|||}|||S)Nr)rPhiInstrrr)rrsrrrs r!phiz IRBuilder.phis4$TZ4uMMM T r#cbtj|j}|||Sr)r Unreachablerr)rrs r! unreachablezIRBuilder.unreachables-' 33 T""" r#cntj|j|||||}|||S)Nr=)r AtomicRMWrr)rrrPrrr]rrs r! atomic_rmwzIRBuilder.atomic_rmws?% JChT;;; T r#c |||n|}tj|j||||||}|||S)a8 Atomic compared-and-set: atomic { old = *ptr success = (old == cmp) if (success) *ptr = val } name = { old, success } If failordering is `None`, the value of `ordering` is used. Nr=)rCmpXchgrr)rrPcmprrr] failorderingrrs r!cmpxchgzIRBuilder.cmpxchgsQ$0#7xx\ #DJS#x$0t=== T r#chtj|j|||}|||Sr)rLandingPadInstrrr)rrsrcleanuprs r!r{zIRBuilder.landingpad s1+DJT7KK T r#cd|jd}|||gS)z? Optimizer hint: assume *cond* is always true. z llvm.assume)rArDrE)rr&r)s r!assumezIRBuilder.assumes/[ * *= 9 9yydV$$$r#cjtj|j|||}|||S)z Add a memory barrier, preventing certain reorderings of load and/or store accesses with respect to other processors and devices. r=)rFencerr)rr] targetscoperrs r!fencezIRBuilder.fences6 !$*h $OOO T r#cdtj|j|}|||S)a Puts a single-line comment into the generated IR. This will be ignored by LLVM, but can be useful for debugging the output of a compiler. Adds a comment to the source file. * *text* is a string that does not contain new line characters. )rCommentrr)rtextrs r!commentzIRBuilder.comments/#DJ55 T r#z llvm.bswapcdS)zv Used to byte swap integer values with an even number of bytes (positive multiple of 16 bits) Nrrr&s r!bswapzIRBuilder.bswap+rr#zllvm.bitreversecdS)zp Reverse the bitpattern of an integer value; for example 0b10110110 becomes 0b01101101. Nrrs r! bitreversezIRBuilder.bitreverse2rr#z llvm.ctpopcdS)z; Counts the number of bits set in a value. Nrrs r!ctpopzIRBuilder.ctpop9rr#z llvm.ctlzcdS)z Counts leading zero bits in *value*. Boolean *flag* indicates whether the result is defined for ``0``. Nrrr&res r!ctlzzIRBuilder.ctlz?rr#z llvm.cttzcdS)z Counts trailing zero bits in *value*. Boolean *flag* indicates whether the result is defined for ``0``. Nrrs r!cttzzIRBuilder.cttzFrr#zllvm.fmacdS)z; Perform the fused multiply-add operation. Nr)rrkrlrms r!fmaz IRBuilder.fmaMrr#c|stdt|tjtjfstd|zt|jtjr|jjdkstd|jzd}|j ||g}| ||g|S)z: Convert from an i16 to the given FP type zexpected a float return typer]zexpected an i16 type, got %szllvm.convert.from.fp16) r@r>rr^r_rr?rdrArDrE)rrktorr r)s r!convert_from_fp16zIRBuilder.convert_from_fp16Ss <:;; ;"u0@ABB B;b@AA A165=11 Eaflb6H6H:QVCDD D) [ * *6B4 8 8yyaS$'''r#zllvm.convert.to.fp16cdS)z7 Convert the given FP number to an i16 Nr)rrks r!convert_to_fp16zIRBuilder.convert_to_fp16brr#rrKr$)Nr)rNN)rN)rNFrrN)rNrrN)FrN)rF)u__name__ __module__ __qualname__rpropertyrrrrArrrrrr contextlibcontextmanagerrrrrrrrr8rrrrrrrrrrrrrrrrrrrMrrrrrrrrr-rrrrr r#r'rtr(r+r-r/r1r3r5r7r9r;r=r?rArIrSrZr^rarcrrrsrwrJrzrErrrrrrrrrrrrrrr{rrrrYrrrrfrrrnrrr`rrr#r!rrs #### X K !!X! ((X( ===AAA///6666,,,    $$$$,$$$$<  VE]]   ]  VF^^   ^  VF^^   ^  VE]]   ]  VF^^   ^  VE]]   ]  VF^^   ^  VE]]   ]  VF^^   ^  VF^^   ^  VF^^   ^  VF^^   ^  VF^^   ^  VF^^   ^  VF^^   ^  VD\\   \  VE]]   ]  VE]]   ] &!!   "! &!!   "! &!!   "! &!!   "! &!!   "! &!!   "!  / / / /JJJJ U6]]   ]    66666666   WW     WV__   _  WV__   _  WY     WW     WY     W_     WX     WX     WX     WX     WZ     WZ    $        (666888HJ!%    ****HHHHKKKKFJ          & %%%   ,''  (' +,,  -, ,''  ('   ,,  -,   ,,  -, j!!  "! ( ( ( (233  43   r#r)rr& llvmlite.irrrrr  Instructionr-r8rMrRrYr`rfrn CastInstrrtr}objectrrr#r!rsp3333333333        #.    $/     &2%=2$/          (0%.        i i i i i i i i i i r#