Ë
    pPêjêÿ ã                  óæ  — U d Z ddlmZ ddlZddlmZmZmZ ddlm	Z	 ddl
mZmZmZ ddlmZ ddlmZmZmZmZ dd	lmZmZ dd
lmZmZ ddlmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z' ddl(m)Z)m*Z* ddl+m,Z,m-Z- ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ ddl_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZm€Z€m�Z�m‚Z‚mƒZƒm„Z„m…Z…m†Z†m‡Z‡mˆZˆm‰Z‰mŠZŠm‹Z‹mŒZŒm�Z�mŽZŽm�Z�m�Z�m‘Z‘ ddl’m“Z“ ddl”m•Z•m–Z–m—Z— ddl˜m™Z™ ddlšm›Z› ddlœm�Z�mžZžmŸZŸm Z m¡Z¡m¢Z¢ ddl£m¤Z¤m¥Z¥ ddl¦m§Z§m¨Z¨ ddl©mªZªm«Z«m¬Z¬m­Z­m®Z®m¯Z¯m°Z°m±Z±m²Z² ddl³m´Z´mµZµm¶Z¶m·Z·m¸Z¸m¹Z¹mºZºm»Z»m¼Z¼m½Z½m¾Z¾m¿Z¿mÀZÀ ddlÁmÂZÂmÃZÃmÄZÄmÅZÅ ddlÆmÇZÇmÈZÈmÉZÉmÊZÊmËZËmÌZÌmÍZÍmÎZÎ ddlÏmÐZÐmÑZÑmÒZÒmÓZÓmÔZÔmÕZÕmÖZÖm×Z× ddlØmÙZÙ ddlÚmÛZÛmÜZÜmÝZÝmÞZÞmßZß ddlàmáZámâZâmãZãmäZämåZå dd læmçZç dd!lèméZé dd"lêmëZë dd#lìmíZí eîe[dz  e[f   Zïd$Zðd%e%d&z  d%z
  z  Zñd'eòd(<   h d)£Zód'eòd*<   h d+£Zôd'eòd,<    G d-„ d.«      Zõ G d/„ d0«      Zöd4d1„Z÷ G d2„ d3«      Zøy)5zeA "low-level" IR builder class.

See the docstring of class LowLevelIRBuilder for more information.

é    )ÚannotationsN)ÚCallableÚIteratorÚSequence)Úcontextmanager)ÚFinalÚ	TypeGuardÚcast)Úmap_actuals_to_formals)ÚARG_POSÚARG_STARÚ	ARG_STAR2ÚArgKind)Ú
op_methodsÚunary_op_methods)ÚAnyTypeÚ	TypeOfAny)
ÚBITMAP_BITSÚFAST_ISINSTANCE_MAX_SUBCLASSESÚFAST_PREFIXÚIS_FREE_THREADEDÚKEEP_ALIVE_SHORT_LIVEDÚMAX_LITERAL_SHORT_INTÚMAX_SHORT_INTÚMIN_LITERAL_SHORT_INTÚMIN_SHORT_INTÚPLATFORM_SIZE)ÚErrors)ÚClassIRÚall_concrete_classes)ÚFuncDeclÚFuncSignature)0Ú	ERR_FALSEÚ	ERR_NEVERÚNAMESPACE_MODULEÚNAMESPACE_STATICÚNAMESPACE_TYPEÚAssignÚAssignMultiÚ
BasicBlockÚBoxÚBranchÚCallÚCallCÚCastÚComparisonOpÚExtendÚFloatÚFloatComparisonOpÚFloatNegÚFloatOpÚGetAttrÚ
GetElementÚGetElementPtrÚGotoÚIntegerÚIntOpÚ	KeepAliveÚLoadAddressÚLoadErrorValueÚ
LoadGlobalÚLoadLiteralÚLoadMemÚ
LoadStaticÚ
MethodCallÚOpÚPrimitiveDescriptionÚPrimitiveOpÚRaiseStandardErrorÚRegisterÚSetMemÚTruncateÚTupleGetÚTupleSetÚUnboxÚUnreachableÚValueÚfloat_comparison_op_to_idÚfloat_op_to_idÚint_op_to_id)2ÚPyObjectÚPySetObjectÚRArrayÚ	RInstanceÚ
RPrimitiveÚRStructÚRTupleÚRTypeÚRUnionÚRVecÚbit_rprimitiveÚbitmap_rprimitiveÚbool_rprimitiveÚbytes_rprimitiveÚc_int_rprimitiveÚc_pointer_rprimitiveÚc_pyssize_t_rprimitiveÚc_size_t_rprimitiveÚcheck_native_int_rangeÚfloat_rprimitiveÚint64_rprimitiveÚint_rprimitiveÚis_bool_or_bit_rprimitiveÚis_bytes_rprimitiveÚis_c_py_ssize_t_rprimitiveÚis_dict_rprimitiveÚis_fixed_width_rtypeÚis_float_rprimitiveÚis_frozenset_rprimitiveÚis_int16_rprimitiveÚis_int32_rprimitiveÚis_int64_rprimitiveÚis_int_rprimitiveÚis_list_rprimitiveÚis_none_rprimitiveÚis_object_rprimitiveÚis_optional_typeÚis_set_rprimitiveÚis_short_int_rprimitiveÚis_str_rprimitiveÚ	is_taggedÚis_tuple_rprimitiveÚis_uint8_rprimitiveÚnone_rprimitiveÚobject_pointer_rprimitiveÚobject_rprimitiveÚoptional_value_typeÚpointer_rprimitiveÚshort_int_rprimitiveÚstr_rprimitive)Úconcrete_arg_kind)Úvec_containsÚvec_get_itemÚvec_len_native)ÚCompilerOptions)Úbytes_compare)Údict_build_opÚ	dict_copyÚdict_copy_opÚdict_new_opÚdict_ssize_t_size_opÚdict_update_in_display_op)Úerr_occurred_opÚkeep_propagating_op)Úcopysign_opÚint_to_float_op)	Úgeneric_len_opÚgeneric_ssize_t_len_opÚ
py_call_opÚpy_call_with_kwargs_opÚpy_call_with_posargs_opÚpy_getattr_opÚpy_method_call_opÚpy_vectorcall_method_opÚpy_vectorcall_op)Úint16_divide_opÚint16_mod_opÚint16_overflowÚint32_divide_opÚint32_mod_opÚint32_overflowÚint64_divide_opÚint64_mod_opÚint64_to_int_opÚint_to_int32_opÚint_to_int64_opÚssize_t_to_int_opÚuint8_overflow)Úlist_build_opÚlist_extend_opÚ
list_itemsÚnew_list_op)Úbool_opÚbuf_init_itemÚdebug_print_opÚfast_isinstance_opÚnone_object_opÚnot_implemented_opÚset_immortal_opÚvar_object_size)ÚERR_NEG_INTÚCFunctionDescriptionÚ
binary_opsÚbuiltin_namesÚfunction_opsÚglobal_namesÚmethod_call_opsÚ	unary_ops)Ú
new_set_op)Ústr_check_if_trueÚstr_eqÚstr_eq_literalÚstr_ssize_t_size_opÚunicode_compare)Úlist_tuple_opÚload_empty_tuple_constant_opÚnew_tuple_opÚnew_tuple_with_length_opÚsequence_tuple_op)Úexpand_rtype)Úis_runtime_subtype)Úis_same_type)Ú
is_subtypeé
   é   é   r   ÚPY_VECTORCALL_ARGUMENTS_OFFSET>   ú%=ú*=ú+=ú-=ú<<ú>>ú//=ú<<=ú>>=Ú*ú%ú&ú+ú-ú^ú|ú&=ú//ú^=ú|=ÚFIXED_WIDTH_INT_BINARY_OPS>   ú<=rÝ   ú<ú>rà   rá   ú!=râ   ú==ú>=rä   rå   ÚBOOL_BINARY_OPSc                  ó   — e Zd ZdZdd„Zy)ÚPendingKeepAlive©ÚvalueÚscopeÚseqc                ó.   — || _         || _        || _        y ©Nrð   )Úselfrñ   rò   ró   s       ú]/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/ll_builder.pyÚ__init__zPendingKeepAlive.__init__  s   € ØˆŒ
ØˆŒ
Øˆ�ó    N)rñ   rO   rò   Úintró   rú   ÚreturnÚNone)Ú__name__Ú
__module__Ú__qualname__Ú	__slots__rø   © rù   r÷   rï   rï   ÿ   s   „ Ø)€Iôrù   rï   c                  ó�  — e Zd ZdZdŽd„Zd�d„Zd�d„Zd‘d„Zd’d„Zd“d„Z	d“d„Z
d	d
œd”d„Zd	dœd•d„Zd–d„Zd—d„Zd˜d™d„Zd™d„Zdšd„Zd	dœ	 	 	 	 	 	 	 	 	 d›d„Z	 	 	 	 	 	 	 	 	 	 	 	 dœd„Zd�d„Zdžd„ZdŸd„Zedœd d„Zd¡d„Zd¢d„Zed£d„«       Zd¤d„Zd¥d„Zd¦d „Zd§d!„Z d	d	d"œ	 	 	 	 	 	 	 	 	 	 	 d¨d#„Z!	 d©d	d$œ	 	 	 	 	 	 	 	 	 	 	 dªd%„Z"d«d&„Z#	 	 	 	 	 	 	 	 	 	 d¬d'„Z$	 	 	 	 	 	 	 	 	 	 	 	 	 	 d­d(„Z%d®d)„Z&d«d*„Z'd¯d+„Z(d¯d,„Z)d«d-„Z*d	ed.œ	 	 	 	 	 	 	 	 	 	 	 	 	 d°d/„Z+	 	 	 	 	 	 	 	 	 	 	 	 d±d0„Z,d²d1„Z-d³d2„Z.d´d3„Z/dµd4„Z0d¶d5„Z1	 	 	 	 	 	 	 	 	 	 d·d6„Z2	 	 d¸	 	 	 	 	 	 	 	 	 	 	 d¹d8„Z3	 	 d¸	 	 	 	 	 	 	 	 	 	 	 dºd9„Z4d»d:„Z5	 	 	 	 	 	 	 	 	 	 	 	 	 	 d¼d;„Z6	 	 	 	 	 	 	 	 	 	 	 	 	 	 d½d<„Z7d7d=œ	 	 	 	 	 	 	 	 	 	 	 	 	 d¾d>„Z8d7d=œ	 	 	 	 	 	 	 	 	 	 	 	 	 d¿d?„Z9	 	 	 dÀ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dÁd@„Z:	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dÂdA„Z;d˜dÃdB„Z<d˜dÃdC„Z=d˜dÃdD„Z>d˜dÃdE„Z?d˜dÃdF„Z@d˜dÃdG„ZAd˜dÄdH„ZBd˜dÅdI„ZCd˜dÆdJ„ZDd˜dÇdK„ZEd˜dÈdL„ZFd7eGdd7f	 	 	 	 	 	 	 	 	 	 	 	 	 dÉdM„ZHdÊdN„ZIdËdO„ZJdÌdP„ZKdÍdQ„ZLdÎdR„ZMd©dÏdS„ZNdÐdT„ZOdÐdU„ZPd˜dÐdV„ZQdÑdW„ZRdÍdX„ZSdÍdY„ZTdÒdZ„ZUd	d[œdÓd\„ZVdÔd]„ZWdÔd^„ZXdÔd_„ZYdÒd`„ZZd	d$œ	 	 	 	 	 	 	 	 	 	 	 dÕda„Z[dÖdb„Z\d×dc„Z]dØdd„Z^dØde„Z_d	dfœ	 	 	 	 	 	 	 	 	 dÙdg„Z`	 	 	 	 	 	 	 	 	 	 	 	 dÚdh„ZadÛdi„ZbdÜdj„Zc	 dÝ	 	 	 	 	 	 	 	 	 dÞdk„Zd	 	 dß	 	 	 	 	 	 	 	 	 	 	 dàdl„Ze	 	 d¸	 	 	 	 	 	 	 	 	 	 	 dádm„Zf	 dÝd	dndoœ	 	 	 	 	 	 	 	 	 	 	 	 	 dâdp„Zgd˜dãdq„ZhdÐdr„Zidäds„Zjdådt„Zkdædu„Zldædv„Zmdædw„Zn	 	 	 	 	 	 	 	 	 	 	 	 dçdx„Zodèdy„Zpdédz„Zqdéd{„Zrdêd|„Zsdëd}„Ztdåd~„Zud©dìd„Zvdíd€„Zwd×d�„Zxdîd‚„Zydïdƒ„Zz	 	 	 	 	 	 	 	 	 	 	 	 dðd„„Z{	 d©	 	 	 	 	 	 	 	 	 	 	 	 	 dñd…„Z|	 d©	 	 	 	 	 	 	 	 	 	 	 	 	 dñd†„Z}dòd‡„Z~dódˆ„Z	 	 	 	 	 	 	 	 	 	 dôd‰„Z€dôdŠ„Z�dõd‹„Z‚dödŒ„Zƒd÷d�„Z„y7)øÚLowLevelIRBuilderax  A "low-level" IR builder class.

    LowLevelIRBuilder provides core abstractions we use for constructing
    IR as well as a number of higher-level ones (accessing attributes,
    calling functions and methods, and coercing between types, for
    example).

    The core principle of the low-level IR builder is that all of its
    facilities operate solely on the mypyc IR level and not the mypy AST
    level---it has *no knowledge* of mypy types or expressions.

    The mypyc.irbuilder.builder.IRBuilder class wraps an instance of this
    class and provides additional functionality to transform mypy AST nodes
    to IR.
    c                óh   — || _         || _        g | _        g | _        d g| _        g | _        d| _        y ©Nr   )ÚerrorsÚoptionsÚargsÚblocksÚerror_handlersÚkeep_alivesÚnext_keep_alive_seq)rö   r  r  s      r÷   rø   zLowLevelIRBuilder.__init__  s:   € ØˆŒØˆŒØ$&ˆŒ	Ø(*ˆŒà8<°vˆÔð
 46ˆÔØ#$ˆÕ rù   c                ó    — || _         || _        y)z,Set the name and path of the current module.N)Úmodule_nameÚmodule_path)rö   r  r  s      r÷   Ú
set_modulezLowLevelIRBuilder.set_module'  s   € à&ˆÔØ&ˆÕrù   c                ó–   — | j                   d   j                  rJ d«       ‚| j                   d   j                  j                  |«       |S )z
Add an op.éÿÿÿÿzCan't add to finished block)r	  Ú
terminatedÚopsÚappend)rö   Úops     r÷   ÚaddzLowLevelIRBuilder.add.  s@   € à—;‘;˜r‘?×-Ò-ÐLÐ/LÓLÐ-Ø�‰�B‰×Ñ×"Ñ" 2Ô&Øˆ	rù   c                ó†   — t        |t        «      rt        ||j                  «      }| j	                  t        ||«      «       y rõ   )Ú
isinstancerú   r:   Útyper  r(   )rö   ÚlvalueÚrvalues      r÷   ÚassignzLowLevelIRBuilder.assign4  s/   € Ü�fœcÔ"Ü˜V V§[¡[Ó1ˆFØ�‰”˜ Ó'Õ(rù   c                ól   — | j                   d   j                  s| j                  t        |«      «       yy)zAdd goto to a basic block.r  N)r	  r  r  r9   )rö   Útargets     r÷   ÚgotozLowLevelIRBuilder.goto9  s(   € à�{‰{˜2‰×)Ò)Ø�H‰H”T˜&“\Õ"ð *rù   c                ó°   — | j                   r| j                   d   j                  sJ ‚| j                  d   |_        | j                   j	                  |«       y)z>Add a basic block and make it the active one (target of adds).r  N)r	  r  r
  Úerror_handlerr  ©rö   Úblocks     r÷   Úactivate_blockz LowLevelIRBuilder.activate_block>  sE   € à�;Š;Ø—;‘;˜r‘?×-Ò-Ð-Ð-à"×1Ñ1°"Ñ5ˆÔØ�‰×Ñ˜5Õ!rù   c                óH   — | j                  |«       | j                  |«       y)z.Add goto a block and make it the active block.N)r   r%  r#  s     r÷   Úgoto_and_activatez#LowLevelIRBuilder.goto_and_activateF  s   € à�	‰	�%ÔØ×Ñ˜EÕ"rù   F©Ústealc               ó>   — | j                  t        |||¬«      «       y )Nr(  )r  r<   )rö   ÚvaluesÚliner)  s       r÷   Ú
keep_alivezLowLevelIRBuilder.keep_aliveK  s   € Ø�‰”˜6 4¨uÔ5Õ6rù   ©Úborrowc               ó<   — | j                  t        |||¬«      «      S ©Nr.  )r  rA   )rö   ÚptrÚ
value_typer/  s       r÷   Úload_memzLowLevelIRBuilder.load_memN  s   € Ø�x‰xœ 
¨C¸Ô?Ó@Ð@rù   c                ó@   — | j                  t        |||d¬«      «       y ©Nr  ©r,  )r  rI   )rö   r2  r3  rñ   s       r÷   Úset_memzLowLevelIRBuilder.set_memQ  s   € Ø�‰”˜
 C¨°RÔ8Õ9rù   c                ó8   — | j                  t        ||«      «      S rõ   )r  r7   )rö   ÚregÚfields      r÷   Úget_elementzLowLevelIRBuilder.get_elementT  s   € Ø�x‰xœ
 3¨Ó.Ó/Ð/rù   r  c                ó:   — | j                  t        |||«      «      S rõ   )r  r=   ©rö   ÚnameÚrtyper,  s       r÷   Úload_addresszLowLevelIRBuilder.load_addressW  s   € Ø�x‰xœ E¨4°Ó6Ó7Ð7rù   c                ó:   — | j                  t        |||«      «      S rõ   )r  r?   r>  s       r÷   Úload_globalzLowLevelIRBuilder.load_globalZ  s   € Ø�x‰xœ
 5¨$°Ó5Ó6Ð6rù   c                óÄ   — t        j                  |«      x}r| j                  |d   |d   |«      S t        j                  |«      x}r| j	                  |d   |d   |«      S y )NrÏ   r   )rº   ÚgetrA  r¼   rC  )rö   r?  r,  ÚbuiltinÚglobs        r÷   Úload_builtinzLowLevelIRBuilder.load_builtin]  sk   € Ü#×'Ñ'¨Ó-Ð-ˆ7Ð-Ø×$Ñ$ W¨Q¡Z°¸±¸TÓBÐBÜ×#Ñ# DÓ)Ð)ˆ4Ð)Ø×#Ñ# D¨¡G¨T°!©W°dÓ;Ð;Ørù   c               ó€   — | j                  t        |||«      «      }| j                  ||j                  |«      |¬«      S r1  )r  r8   r4  Ú
field_type)rö   r2  Ústructr;  r/  Úaddresss         r÷   Úload_struct_fieldz#LowLevelIRBuilder.load_struct_fieldd  s;   € ð —(‘(œ=¨¨f°eÓ<Ó=ˆØ�}‰}˜W f×&7Ñ&7¸Ó&>Àvˆ}ÓNÐNrù   c                óÐ   — | j                  t        |||«      «      }|j                  |«      }| j                  |||«      }| j	                  |||«       | j                  |g|«       y rõ   )r  r8   rJ  Úcoercer8  r-  )rö   r2  rK  r;  rñ   r,  rL  rJ  s           r÷   Úset_struct_fieldz"LowLevelIRBuilder.set_struct_fieldj  s]   € ð —(‘(œ=¨¨f°eÓ<Ó=ˆØ×&Ñ& uÓ-ˆ
Ø—‘˜E :¨tÓ4ˆØ�‰�W˜j¨%Ô0Ø�‰˜˜˜tÕ$rù   c                ó:   — | j                   j                  |«       y rõ   )r
  r  )rö   Úhandlers     r÷   Úpush_error_handlerz$LowLevelIRBuilder.push_error_handlers  s   € Ø×Ñ×"Ñ" 7Õ+rù   c                ó6   — | j                   j                  «       S rõ   )r
  Úpop©rö   s    r÷   Úpop_error_handlerz#LowLevelIRBuilder.pop_error_handlerv  s   € Ø×"Ñ"×&Ñ&Ó(Ð(rù   c                ó    — | j                   d   S )zWReturn reference to the 'self' argument.

        This only works in a method.
        r   )r  rV  s    r÷   rö   zLowLevelIRBuilder.selfy  s   € ð
 �y‰y˜‰|Ðrù   ©rò   c          	     óP  ‡— t        ˆfd„| j                  D «       «      r}| j                  t        | j                  D �cg c]  }|j                  ‰k(  sŒ|j
                  ‘Œ  c}|«      «       | j                  D �cg c]  }|j                  ‰k7  sŒ|‘Œ c}| _        y y c c}w c c}w )Nc              3  ó<   •K  — | ]  }|j                   ‰k(  –— Œ y ­wrõ   rY  )Ú.0Úentryrò   s     €r÷   ú	<genexpr>z6LowLevelIRBuilder.flush_keep_alives.<locals>.<genexpr>�  s   øè ø€ ÒB¨ˆu�{‰{˜eÕ#ÑBùs   ƒ)Úanyr  r  r<   rò   rñ   )rö   r,  rò   r]  s     ` r÷   Úflush_keep_alivesz#LowLevelIRBuilder.flush_keep_alives€  s‹   ø€ ÜÓB°×1AÑ1AÔBÔBØ�H‰HÜØ.2×.>Ñ.>ÖW UÀ%Ç+Á+ÐQVÓBV�U—[“[ÒWÐY]óôð
 48×3CÑ3CÖ\¨%ÀuÇ{Á{ÐV[ÓG[¢Ò\ˆDÕð Cùò Xùò  ]s   ¾BÁBÁ;B#ÂB#c                ó   — | j                   S rõ   )r  rV  s    r÷   Úkeep_alive_checkpointz'LowLevelIRBuilder.keep_alive_checkpoint‰  s   € Ø×'Ñ'Ð'rù   c                ó<  — | j                   D �cg c]  }|j                  |k\  sŒ|‘Œ }}|r3| j                  t        |D �cg c]  }|j                  ‘Œ c}|«      «       | j                   D �cg c]  }|j                  |k  sŒ|‘Œ c}| _         yc c}w c c}w c c}w )zIFlush keep-alives added after 'checkpoint' without touching earlier ones.N)r  ró   r  r<   rñ   )rö   r,  Ú
checkpointr]  Únew_keep_alivess        r÷   Úflush_keep_alives_sincez)LowLevelIRBuilder.flush_keep_alives_sinceŒ  s{   € à.2×.>Ñ.>ÖZ UÀ%Ç)Á)ÈzÓBYš5ÐZˆÐZÙØ�H‰H”Y¸ÖI° §£ÒIÈ4ÓPÔQØ/3×/?Ñ/?ÖZ eÀ5Ç9Á9ÈzÓCYšEÒZˆÕùò [ùâIùÚZs   �B¤BÁ BÁ-BÂBc              #  óX   K  — | j                  «       }d–— | j                  ||«       y­w)aB  Confine borrows created in this region: flush them when leaving it.

        Keep-alives added inside the region (regardless of their duration scope)
        are flushed on exit, so borrows can't leak past a lexical boundary such as
        a conditional branch, an 'and'/'or' branch or a comprehension iteration.
        N)rb  rf  )rö   r,  rd  s      r÷   Úborrow_regionzLowLevelIRBuilder.borrow_region“  s)   è ø€ ð ×/Ñ/Ó1ˆ
ÛØ×$Ñ$ T¨:Õ6ùs   ‚(*c                óŽ   — | j                   j                  t        ||| j                  «      «       | xj                  dz  c_        y ©NrÏ   )r  r  rï   r  )rö   rñ   rò   s      r÷   Úadd_keep_alivez LowLevelIRBuilder.add_keep_aliveŸ  s7   € Ø×Ñ×ÑÔ 0°¸¸t×?WÑ?WÓ XÔYØ× Ò  AÑ%Ö rù   c                óÜ   — | j                  ||«       t        |t        «      rJ|j                  r=|j                  }| j                  ||«       t        |t        «      r|j                  rŒ;yyyy)aA  Ensure the source of borrowed value will be alive for given borrow scope.

        A borrow keeps reading from 'value', so 'value' must stay valid for the
        borrow's whole scope. When 'value' is itself a borrowed cast it holds no
        reference of its own (and coerce() only kept its source alive short-term),
        so we follow the cast to the underlying owned value and keep *that* alive
        for the requested scope too. Otherwise, a longer-lived borrow through a cast
        (e.g. a Final attribute read via cast(T, make())) could read freed memory.
        N)rk  r  r/   Úis_borrowedÚsrc)rö   rñ   Úborrow_scopes      r÷   Úkeep_borrow_source_alivez*LowLevelIRBuilder.keep_borrow_source_alive£  s\   € ð 	×Ñ˜E <Ô0Ü˜¤Ô%¨%×*;Ò*;Ø—I‘IˆEØ×Ñ  |Ô4ô ˜¤Ô%¨%×*;Ô*;Ð%Ð*;Ð%rù   c                óv   — t        |t        «      r| j                  |«      }| j                  t        |gd«       y )Nr  )r  ÚstrÚload_strÚprimitive_opr±   )rö   Útoprints     r÷   Údebug_printzLowLevelIRBuilder.debug_print²  s.   € Ü�gœsÔ#Ø—m‘m GÓ,ˆGØ×Ñœ.¨7¨)°RÕ8rù   c                ó   — |j                   j                  rwt        |t        «      rBt	        |j                   «      r-| j                  t        |j                  dz	  t        ¬«      «      S | j                  t        ||j                  «      «      S |S )NrÏ   ©r@  )r  Ú
is_unboxedr  r:   r{   r  r@   rñ   r€   r+   r,  )rö   rn  s     r÷   ÚboxzLowLevelIRBuilder.box¹  sb   € Ø�8‰8×ÒÜ˜#œwÔ'¬I°c·h±hÔ,?Ø—x‘x¤¨C¯I©I¸©NÔBSÔ TÓUÐUØ—8‘8œC  S§X¡XÓ.Ó/Ð/àˆJrù   ©Ú
can_borrowÚ	uncheckedc          	     óÀ   — |j                   r| j                  t        |||«      «      S |r| j                  |t        «       | j                  t        |||||¬«      «      S )N)r/  r}  )ry  r  rM   rk  r   r/   )rö   rn  Útarget_typer,  r|  r}  s         r÷   Úunbox_or_castzLowLevelIRBuilder.unbox_or_castÁ  sV   € ð ×!Ò!Ø—8‘8œE # {°DÓ9Ó:Ð:áØ×#Ñ# CÔ)?Ô@Ø—8‘8œD  k°4À
ÐV_Ô`ÓaÐarù   ©r|  c               óü	  — |j                   }|j                  r|j                  s| j                  |«      S |j                  �rO|j                  �rBt        ||«      �s5t	        |t
        «      rdt        |«      rYt        |«      rN|j                  «       }t        ||«      s| j                  d|› d|› d�|«       t        |j                  dz	  |«      S t        |«      rt        |«      r| j                  |||«      S t        |«      rt        |«      r| j                  ||«      S t        |«      rt        |«      r| j                  |||«      S t	        |t         «      rœt	        |t         «      rŒ|j"                  r€|j"                  rt|j$                  |j$                  k  r[|j&                  |j&                  k(  rB|j$                  |j$                  k(  r|S | j)                  t+        |||j&                  |«      «      S t-        |«      rt/        |«      r| j1                  ||«      S t3        |«      r\t5        |«      rQ| j7                  t8        |t        dt8        «      t:        j<                  «      }| j)                  t+        ||d¬«      «      S t3        |«      r(t        |«      r| j)                  t+        ||d¬«      «      S t	        |t
        «      rUt?        |«      rJt5        |«      r!tA        tC        |j                  dz  «      «      S tA        tC        |j                  «      «      S t5        |«      rt?        |«      r| jE                  ||«      S t	        |tF        «      �rt	        |tF        «      �rtI        |jJ                  «      tI        |jJ                  «      k(  rÛg }	tM        tI        |jJ                  «      «      D ]e  }
d}t	        |tN        «      r!|jP                  |
   }t	        |tR        «      s|}|€tU        ||
«      }| j)                  |«       |	jW                  |«       Œg | j)                  tO        tY        |	|jJ                  «      D ��cg c]  \  }}| j[                  |||«      ‘Œ c}}|«      «      S | j                  |«      }| j]                  |||«      S |j                  s|j                  st_        ||«      s| j]                  ||||¬	«      S |r)tS        |«      }| j)                  ta        |||«      «       |S |S c c}}w )
aÖ  Generate a coercion/cast from one type to other (only if needed).

        For example, int -> object boxes the source int; int -> int emits nothing;
        object -> int unboxes the object. All conversions preserve object value.

        If force is true, always generate an op (even if it is just an assignment) so
        that the result will have exactly target_type as the type.

        Returns the register with the converted value (may be same as src).
        zValue z is out of range for "ú"rÏ   F©Úsignedé   Nr�  )1r  ry  rz  rË   r  r:   ry   rm   Únumeric_valuere   Úerrorrñ   rs   Úcoerce_int_to_fixed_widthÚcoerce_fixed_width_to_intÚcoerce_short_int_to_fixed_widthrW   Úis_native_intÚsizeÚ	is_signedr  r1   rr   rk   Úcoerce_i64_to_ssize_tri   r{   Úint_opr_   r;   Ú
LEFT_SHIFTrn   r2   ÚfloatÚint_to_floatrY   ÚlenÚtypesÚrangerL   ÚitemsrH   rK   r  ÚziprO  r€  rÍ   r(   )rö   rn  r  r,  Úforcer|  Úsrc_typerñ   Úshiftedr+  ÚiÚvÚitemÚtÚtmps                  r÷   rO  zLowLevelIRBuilder.coerceÑ  s)  € ð& —8‘8ˆØ×Ò {×'=Ò'=à—8‘8˜C“=Ð Ø×Ó K×$:Ó$:ÔDVØ�kõE
ô ˜3¤Ô(Ü+¨HÔ5Ü(¨Ô5à×)Ñ)Ó+�Ü-¨k¸5ÔAØ—J‘J ¨ wÐ.DÀ[ÀMÐQRÐSÐUYÔZÜ˜sŸy™y¨A™~¨{Ó;Ð;Ü" 8Ô,Ô1EÀkÔ1RØ×5Ñ5°c¸;ÈÓMÐMÜ% hÔ/Ô4EÀkÔ4RØ×5Ñ5°c¸4Ó@Ð@Ü(¨Ô2Ô7KÈKÔ7XØ×;Ñ;¸CÀÈdÓSÐSä˜8¤ZÔ0Ü˜{¬JÔ7Ø×*Ò*Ø×-Ò-Ø—M‘M [×%5Ñ%5Ò5Ø×&Ñ&¨+×*?Ñ*?Ò?à—=‘= K×$4Ñ$4Ò4à�Jð  Ÿ8™8¤F¨3°¸[×=RÑ=RÐTXÓ$YÓZÐZÜ$ XÔ.Ô3MÈkÔ3ZØ×1Ñ1°#°tÓ<Ð<Ü*¨8Ô4¼À;Ô9OØŸ+™+Ü# S¬'°!´_Ó*EÄu×GWÑGWó�ð —x‘x¤ w°ÀEÔ JÓKÐKÜ*¨8Ô4Ô9MÈkÔ9ZØ—x‘x¤ s¨KÀÔ FÓGÐGÜ˜C¤Ô)Ô.AÀ+Ô.NÜ˜XÔ&Ü ¤ s§y¡y°A¡~Ó!6Ó7Ð7ÜœU 3§9¡9Ó-Ó.Ð.Ü˜8Ô$Ô)<¸[Ô)IØ×(Ñ(¨¨dÓ3Ð3ä˜8¤VÕ,Ü˜{¬FÕ3Ü˜Ÿ™Ó'¬3¨{×/@Ñ/@Ó+AÒAð �Üœs 8§>¡>Ó2Ó3ò 
%�AØ�AÜ! #¤xÔ0Ø"Ÿy™y¨™|˜ä)¨$´Ô9Ø $˜AØ�yÜ$ S¨!Ó,˜ØŸ™ œØ—M‘M !Õ$ð
%ð —x‘xÜÜ=@ÀÈ×IZÑIZÓ=[×\±T°Q¸˜Ÿ™ Q¨¨4Õ0Ó\Ð^bóóð ð —(‘(˜3“-ˆCØ×%Ñ% c¨;¸Ó=Ð=Ø×#Ò#¨×(>Ò(>ÄzØ�kôH
ð ×%Ñ% c¨;¸ÈÐ%ÓTÐTÙÜ˜;Ó'ˆCØ�H‰H”V˜C  dÓ+Ô,ØˆJØˆ
ùó ]s   ÑS8c                óF  — t        |«      sJ |«       ‚t        |t        «      sJ |«       ‚t        «       t        «       t        «       }}}| j	                  ||«      }| j                  t        |||t        j                  «      «       | j                  |«       |j                  }|t        j                  k  r%| j                  ||t        j                  |||«      }	n—|t        j                  kD  r| j                  t        ||d¬«      «      }
n|}
| j                  ||
t        d|«      t        j                   |«      }
t#        |«      }	| j                  t%        |	|
«      «       | j'                  |«       | j                  |«       t)        |«      st+        |«      ræ|t        j                  k(  rÓ| j                  t,        |t        dt,        «      t        j.                  |«      }t#        t0        «      }| j                  t%        ||«      «       t)        |«      rt2        }nt4        }| j7                  ||g|«      }
| j                  t%        |	|
«      «       | j                  t9        |g«      «       | j'                  |«       n| j;                  ||«       | j                  |«       |	S )NTr„  rÏ   )rm   r  rW   r*   Úcheck_tagged_short_intr  r,   ÚBOOLr%  r�  rh   Ú-coerce_tagged_to_fixed_width_with_range_checkr1   r�  r:   r;   ÚRIGHT_SHIFTrH   r(   r   rr   rq   r‚   ÚXORrb   r¨   r§   Úcall_cr<   Úemit_fixed_width_overflow_error)rö   rn  r  r,  ÚfastÚslowÚendÚcheckr�  Úresr   r2  Úptr2Úconv_ops                 r÷   r‰  z+LowLevelIRBuilder.coerce_int_to_fixed_width<  s  € Ü# KÔ0Ð=°+Ó=Ð0Ü˜+¤zÔ2Ð?°KÓ?Ð2ä$›,¬
«´j³l�Cˆdˆà×+Ñ+¨C°Ó6ˆØ�‰”˜˜t T¬6¯;©;Ó7Ô8à×Ñ˜DÔ!à×ÑˆØ”.×%Ñ%Ò%ð ×DÑDØ�[¤.×"5Ñ"5°t¸SÀ$ó‰Cð
 ”n×)Ñ)Ò)Ø—h‘hœv c¨;¸tÔDÓE‘à�Ø—+‘+˜k¨3´¸¸;Ó0GÌ×IZÑIZÐ\`ÓaˆCÜ˜;Ó'ˆCØ�H‰H”V˜C Ó%Ô&Ø�I‰I�cŒNà×Ñ˜DÔ!Ü˜{Ô+Ü Ô,°¼×9LÑ9LÒ1Lð —+‘+Ü" C¬°Ô4FÓ)GÌÏÉÐTXóˆCô Ô0Ó1ˆDØ�H‰H”V˜D #Ó&Ô'Ü" ;Ô/Ü)‘ä)�Ø—+‘+˜g¨ v¨tÓ4ˆCØ�H‰H”V˜C Ó%Ô&Ø�H‰H”Y ˜uÓ%Ô&Ø�I‰I�c�Nð ×0Ñ0°¸dÔCà×Ñ˜CÔ Øˆ
rù   c           	     ó�  — t        «       t        «       }}|j                  }d|dz  dz
  z  }|j                  s|dz  }| j                  t	        |t        ||j                  «      t        j                  |«      «      }	| j                  t        |	||t        j                  |«      «       | j                  |«       |j                  r| }
nd}
| j                  t	        |t        |
|j                  «      t        j                  |«      «      }| j                  t        |||t        j                  |«      «       | j                  |«       y)a¢  Check if src fits in target_type range, branch to overflow_block if not.

        On success, continues in a newly activated block where the value is
        known to be in range.

        Args:
            src: Source value to check
            target_type: Target fixed-width type defining the valid range
            overflow_block: Block to branch to if value is out of range
            line: Line number
        rÏ   rÐ   r†  r   N)r*   r�  rŽ  r  r0   r:   r  ÚSLTr,   r£  r%  ÚSGE)rö   rn  r  Úoverflow_blockr,  Úin_rangeÚ	in_range2r�  Úupper_boundÚcheck_upperÚlower_boundÚcheck_lowers               r÷   Úcheck_fixed_width_rangez)LowLevelIRBuilder.check_fixed_width_ranger  s  € ô )›l¬J«L�)ˆà×ÑˆØ˜D 1™H q™LÑ)ˆØ×$Ò$Ø˜1ÑˆKð —h‘hÜ˜œg k°3·8±8Ó<¼l×>NÑ>NÐPTÓUó
ˆð 	�‰”˜ X¨~¼v¿{¹{ÈDÓQÔRà×Ñ˜HÔ%ð × Ò Ø&˜,‰KàˆKØ—h‘hÜ˜œg k°3·8±8Ó<¼l×>NÑ>NÐPTÓUó
ˆð 	�‰”˜ Y°ÄÇÁÈTÓRÔSà×Ñ˜IÕ&rù   c                óÈ  — t        |«      sJ |«       ‚t        |t        «      sJ |«       ‚|j                  }||k  s
J |||f«       ‚t	        |«      }| j                  ||||«       | j                  t        |t        dt        «      t        j                  |«      }	| j                  t        |	||«      «      }
| j                  t        ||
|«      «       | j                  |«       |S )a–  Helper to convert a tagged value to a smaller fixed-width type with range checking.

        This method generates IR for converting a tagged integer (like short_int or the fast
        path of int) to a smaller fixed-width type (i32, i16, uint8) with overflow detection.

        The method performs range checks and branches to overflow_block on failure, or
        success_block on success (after assigning the result to a register).

        Args:
            src: Tagged source value (with tag bit set)
            target_type: Target fixed-width type (must be smaller than source_size)
            source_size: Size in bytes of the source type
            overflow_block: Block to branch to on overflow
            success_block: Block to goto after successful conversion
            line: Line number

        Returns:
            Result register containing the converted value (valid in success_block)
        rÏ   )rm   r  rW   r�  rH   rº  r�  rc   r:   r;   r¥  r  rJ   r(   r   )rö   rn  r  Úsource_sizer³  Úsuccess_blockr,  r�  r­  r›  r   s              r÷   r¤  z?LowLevelIRBuilder.coerce_tagged_to_fixed_width_with_range_check›  sÛ   € ô8 $ KÔ0Ð=°+Ó=Ð0Ü˜+¤zÔ2Ð?°KÓ?Ð2Ø×ÑˆØ�kÒ!ÐC K°°{Ð#CÓCÐ!ä�{Ó#ˆà×$Ñ$ S¨+°~ÀtÔLð —+‘+Ü"ØÜ�AÔ-Ó.Ü×ÑØó
ˆð �h‰h”x ¨°dÓ;Ó<ˆØ�‰”˜˜S $Ó'Ô(Ø�	‰	�-Ô àˆ
rù   c                ó  — t        |«      r| j                  t        g |«       nMt        |«      r| j                  t        g |«       n*t        |«      r| j                  t        g |«       nJ |«       ‚| j                  t        «       «       y)z4Emit overflow error for fixed-width type conversion.N)	rq   r§  r£   rp   r    r}   rª   r  rN   )rö   r  r,  s      r÷   r¨  z1LowLevelIRBuilder.emit_fixed_width_overflow_errorÎ  sb   € ä˜{Ô+Ø�K‰Kœ¨¨DÕ1Ü  Ô-Ø�K‰Kœ¨¨DÕ1Ü  Ô-Ø�K‰Kœ¨¨DÕ1à%˜+Ó%�5Ø�‰”“Õrù   c                óÈ  — t        |«      sJ |«       ‚t        |t        «      sJ |«       ‚t        |«      st        dk(  r8t        |«      r-| j                  ||t        d|«      t        j                  |«      S t        «       t        «       }}| j                  ||t        j                  |||«      }| j                  |«       | j                  ||«       | j                  |«       |S )Né   rÏ   )rm   r  rW   rr   r   rq   r�  r:   r;   r¥  r*   r¤  rƒ   r�  r%  r¨  )rö   rn  r  r,  Úoverflowr«  r­  s          r÷   r‹  z1LowLevelIRBuilder.coerce_short_int_to_fixed_widthÚ  sÑ   € ô $ KÔ0Ð=°+Ó=Ð0Ü˜+¤zÔ2Ð?°KÓ?Ð2ä˜{Ô+Ü˜QÒÔ#6°{Ô#Cð —;‘;˜{¨C´¸¸KÓ1HÌ%×J[ÑJ[Ð]aÓbÐbô #›¤j£l�#ˆØ×@Ñ@Ø�Ô2×7Ñ7¸À3Èó
ˆð
 	×Ñ˜HÔ%Ø×,Ñ,¨[¸$Ô?à×Ñ˜CÔ Øˆ
rù   c           	     ó˜  — t        |j                  «      r	t        dk(  s*t        |j                  «      st	        |j                  «      rj| j                  t        |t        |j                  j                  ¬«      «      }| j                  t        |t        dt        «      t        j                  |«      S |j                  }t        |«      sJ |«       ‚t        |t         «      sJ |«       ‚t#        t        «      }t%        «       t%        «       t%        «       t%        «       f\  }}}}	| j                  t'        |t        t(        |«      t&        j*                  |«      «      }
| j                  t-        |
||t,        j.                  «      «       | j1                  |«       | j                  t'        |t        t2        |«      t&        j4                  |«      «      }| j                  t-        |||t,        j.                  «      «       | j1                  |«       t7        |«      rt8        }n$t        |«      rt        dk(  sJ ‚t:        }nJ |«       ‚| j=                  ||g|«      }| j                  t?        ||«      «       | jA                  |	«       | j1                  |«       t        jB                  |jB                  k  r | j                  tE        |t        «      «      }n|}| j                  t        |t        d|j                  «      t        j                  |«      }| j                  t?        ||«      «       | jA                  |	«       | j1                  |	«       |S )NrÐ   r„  rÏ   rÀ  )#rq   r  r   rp   r}   r  r1   rc   rŽ  r�  rh   r:   r;   r‘  rm   r  rW   rH   r*   r0   r   ÚSLEr,   r£  r%  r   r²  rr   r¦   r©   r§  r(   r   r�  rJ   )rö   rn  r,  Úextendedrš  r­  r©  Úfast2rª  r«  Úc1Úc2r¯  Úxr   Úss                   r÷   rŠ  z+LowLevelIRBuilder.coerce_fixed_width_to_intõ  sq  € ä  §¡Ô*¬}ÀÒ/AÜ" 3§8¡8Ô,Ü" 3§8¡8Ô,ð —x‘x¤ sÔ,BÈ3Ï8É8×K]ÑK]Ô ^Ó_ˆHØ—;‘;ÜØÜ˜Ô1Ó2Ü× Ñ Øóð ð —8‘8ˆä# HÔ-Ð7¨xÓ7Ð-Ü˜(¤JÔ/Ð9°Ó9Ð/ä”~Ó&ˆä!+£¬z«|¼Z»\Ì:Ë<Ð!WÑˆˆe�T˜3à�X‰X”l 3¬´¸xÓ(HÌ,×JZÑJZÐ\`ÓaÓbˆØ�‰”˜˜D $¬¯©Ó4Ô5à×Ñ˜DÔ!Ø�X‰X”l 3¬´¸xÓ(HÌ,×JZÑJZÐ\`ÓaÓbˆØ�‰”˜˜E 4¬¯©Ó5Ô6à×Ñ˜DÔ!Ü˜xÔ(Ü%‰GÜ  Ô*Ü  AÒ%Ð%Ð%Ü'‰Gà"˜(Ó"�5Ø�K‰K˜ # ¨Ó-ˆØ�‰”˜˜Q“Ô Ø�	‰	�#Œà×Ñ˜EÔ"Ü×Ñ §¡Ò.Ø—(‘(œ8 CÔ)?Ó@ÓA‰CàˆCØ�K‰Kœ¨¬W°Q¸¿¹Ó-AÄ5×CSÑCSÐUYÓZˆØ�‰”˜˜Q“Ô Ø�	‰	�#Œà×Ñ˜CÔ Øˆ
rù   c                óz  — t         dk(  r|S t        «       t        «       }}| j                  |t        ||«       | j	                  t        |t        |«      «      }| j                  |«       | j                  |«       | j                  t        g |«       | j	                  t        «       «       | j                  |«       |S )zðCoerce int64 to c_pyssize_t with range check on 32-bit platforms.

        On 64-bit platforms, this is a no-op since the types have the same size.
        On 32-bit platforms, raises ValueError if the value doesn't fit in 32 bits.
        rÐ   )r   r*   rº  rc   r  rJ   r   r%  r§  r£   rN   )rö   rn  r,  rÁ  r«  r­  s         r÷   r�  z'LowLevelIRBuilder.coerce_i64_to_ssize_t-  s›   € ô ˜AÒØˆJô #›¤j£l�#ˆà×$Ñ$ SÔ*@À(ÈDÔQð �h‰h”x Ô%;¸TÓBÓCˆØ�	‰	�#Œð 	×Ñ˜HÔ%Ø�‰”N B¨Ô-Ø�‰”“Ôà×Ñ˜CÔ Øˆ
rù   c                óÒ  — |j                   j                  |j                  k(  rF|j                  rt        |j                   |«      s"|j                  st        |j                   |«      r|S t	        |«      }t        «       t        «       t        «       }}}| j                  t        |||t        j                  «      «       | j                  |«       | j                  |||«      }| j                  t        |||«      «       | j                  |«       | j                  |«       | j                  t        |«      «      }	| j                  t        ||	|«      «       | j                  |«       |S )z2Generate a coercion from a potentially null value.)r  ry  rË   rÍ   rH   r*   r  r,   ÚIS_ERRORr%  rO  r(   r   r>   r'  )
rö   rn  r  r,  r  ÚvalidÚinvalidÚoutÚcoercedrˆ  s
             r÷   Úcoerce_nullablez!LowLevelIRBuilder.coerce_nullableG  s  € à�8‰8×Ñ +×"8Ñ"8Ò8Ø×#Ò#Ô(:¸3¿8¹8À[Ô(QØ×*Ò*¬z¸#¿(¹(ÀKÔ/PàˆJä˜+Ó&ˆä(›l¬J«L¼*»,˜ˆwˆØ�‰”˜˜W e¬V¯_©_Ó=Ô>à×Ñ˜EÔ"Ø—+‘+˜c ;°Ó5ˆØ�‰”˜ ¨Ó.Ô/Ø�	‰	�#Œà×Ñ˜GÔ$Ø—‘œ¨Ó4Ó5ˆØ�‰”˜  tÓ,Ô-à×Ñ˜sÔ#Øˆrù   ©r/  ro  c               óÖ  — t        |j                  t        «      r„|j                  j                  j                  rd|j                  j                  j                  |«      r?t        |||||¬«      }|j                  r| j                  ||«       | j                  |«      S t        |j                  t        «      r| j                  ||j                  |||«      S | j                  |||«      S )ae  Get a native or Python attribute of an object.

        If the result is borrowed, borrow_scope controls how long it stays valid
        (a KEEP_ALIVE_* constant). The caller is responsible for choosing a scope
        that is actually safe (e.g. downgrading to short-lived if the borrow root
        may be rebound during the borrow's live range).
        rÒ  )r  r  rV   Úclass_irÚis_ext_classÚhas_attrr6   rm  rp  r  r[   Úunion_get_attrÚpy_get_attr)rö   ÚobjÚattrÚresult_typer,  r/  ro  r  s           r÷   Úget_attrzLowLevelIRBuilder.get_attrb  s¶   € ô$ �s—x‘x¤Ô+Ø—‘×!Ñ!×.Ò.Ø—‘×!Ñ!×*Ñ*¨4Ô0ä˜˜d D°ÀlÔSˆBð �~Š~Ø×-Ñ-¨c°<Ô@Ø—8‘8˜B“<ÐÜ˜Ÿ™¤&Ô)Ø×&Ñ& s¨C¯H©H°d¸KÈÓNÐNà×#Ñ# C¨¨tÓ4Ð4rù   c                óF   ‡ ‡‡‡— dˆˆˆˆ fd„}‰ j                  ||‰|‰«      S )z0Get an attribute of an object with a union type.c                ó,   •— ‰j                  | ‰‰‰«      S rõ   )rÜ  )rñ   rÚ  r,  rÛ  rö   s    €€€€r÷   Úget_item_attrz7LowLevelIRBuilder.union_get_attr.<locals>.get_item_attrˆ  s   ø€ Ø—=‘= ¨¨k¸4Ó@Ð@rù   ©rñ   rO   rû   rO   )Údecompose_union_helper)rö   rÙ  r@  rÚ  rÛ  r,  rß  s   `  ``` r÷   r×  z LowLevelIRBuilder.union_get_attrƒ  s+   û€ ÷
	Að 	Að ×*Ñ*¨3°°{ÀMÐSWÓXÐXrù   c                óV   — | j                  |«      }| j                  t        ||g|«      S )zuGet a Python attribute (slow).

        Prefer get_attr() which generates optimized code for native classes.
        )rs  rt  rš   )rö   rÙ  rÚ  r,  Úkeys        r÷   rØ  zLowLevelIRBuilder.py_get_attr�  s+   € ð
 �m‰m˜DÓ!ˆØ× Ñ ¤°°c°
¸DÓAÐArù   c                ó¾   ‡ ‡‡‡‡— |s‰ j                  «       S ‰ j                  ‰|d   ‰«      Š|dd D ]'  Šdˆˆˆˆ fd„}‰ j                  dt        ˆfd„|‰«      ŠŒ) ‰S )zHFast path for isinstance() that checks against a list of native classes.r   rÏ   Nc                 ó*   •— ‰j                  ‰‰ ‰«      S rõ   )Úisinstance_native)rÔ  r,  rÙ  rö   s   €€€€r÷   Úotherz2LowLevelIRBuilder.isinstance_helper.<locals>.otherž  s   ø€ Ø×-Ñ-¨c°8¸TÓBÐBrù   Úorc                 ó   •— ‰ S rõ   r  ©Úrets   €r÷   ú<lambda>z5LowLevelIRBuilder.isinstance_helper.<locals>.<lambda>¡  ó   ø€ È#€ rù   ©rû   rO   )Úfalseræ  Úshortcircuit_helperr_   )rö   rÙ  Ú	class_irsr,  rç  rÔ  rë  s   `` ` @@r÷   Úisinstance_helperz#LowLevelIRBuilder.isinstance_helper—  so   ü€ áØ—:‘:“<ÐØ×$Ñ$ S¨)°A©,¸Ó=ˆØ! ! "˜ò 	\ˆH÷Cð Cð ×*Ñ*¨4´Ã+ÈuÐVZÓ[‰Cð	\ð ˆ
rù   c                ó°   — | j                  t        |t        d|«      «      }| j                  |t        d¬«      }| j                  t        |g|«      «       |S )NÚob_typeTr.  )r  r8   rS   r4  r€   r<   )rö   rÙ  r,  Úob_type_addressrô  s        r÷   Úget_type_of_objz!LowLevelIRBuilder.get_type_of_obj¤  sJ   € ØŸ(™(¤=°´hÀ	È4Ó#PÓQˆØ—-‘- Ô1BÈ4�-ÓPˆØ�‰”˜C˜5 $Ó'Ô(Øˆrù   c                ó|   — | j                  ||«      }| j                  t        ||t        j                  |«      «      S rõ   )rö  r  r0   ÚEQ)rö   rÙ  Útype_objr,  Útyps        r÷   Ú
type_is_opzLowLevelIRBuilder.type_is_opª  s2   € Ø×"Ñ" 3¨Ó-ˆØ�x‰xœ S¨(´L·O±OÀTÓJÓKÐKrù   c                ót  ‡ ‡‡‡‡— t        |«      }|�t        |«      t        dz   kD  r(‰ j                  t        ‰‰ j                  |«      g‰«      S |s‰ j                  «       S ‰ j                  |d   «      }‰ j                  ‰|‰«      Š|dd D ]'  Šdˆˆˆˆ fd„}‰ j                  dt        ˆfd„|‰«      ŠŒ) ‰S )zçFast isinstance() check for a native class.

        If there are three or fewer concrete (non-trait) classes among the class
        and all its children, use even faster type comparison checks `type(obj)
        is typ`.
        NrÏ   r   c                 óH   •— ‰j                  ‰‰j                  ‰ «      ‰«      S rõ   )rû  Úget_native_type)Úcr,  rÙ  rö   s   €€€€r÷   rç  z2LowLevelIRBuilder.isinstance_native.<locals>.otherÁ  s!   ø€ Ø—‘ s¨D×,@Ñ,@ÀÓ,CÀTÓJÐJrù   rè  c                 ó   •— ‰ S rõ   r  rê  s   €r÷   rì  z5LowLevelIRBuilder.isinstance_native.<locals>.<lambda>Ä  rí  rù   rî  )
r    r”  r   rt  r²   rþ  rï  rû  rð  r_   )	rö   rÙ  rÔ  r,  Úconcreterù  rç  rÿ  rë  s	   `` `   @@r÷   ræ  z#LowLevelIRBuilder.isinstance_native®  sÍ   ü€ ô (¨Ó1ˆØÐœs 8›}Ô/MÐPQÑ/QÒQØ×$Ñ$Ü" S¨$×*>Ñ*>¸xÓ*HÐ$IÈ4óð ñ à—:‘:“<ÐØ×'Ñ'¨°©Ó4ˆØ�o‰o˜c 8¨TÓ2ˆØ˜!˜"�ò 	\ˆA÷Kð Kð ×*Ñ*¨4´Ã+ÈuÐVZÓ[‰Cð	\ð ˆ
rù   c          	     ó6  — d}d}g }g }g }	d}
|D �]  \  }}}|t         k(  �r’|�€tt        |«      dk(  r{t        |j                  «      r| j	                  t
        |g|«      }nGt        |j                  «      s2t        |j                  t        «      s| j	                  t        |g|«      }|dfc S t        |«      dk(  rË|d   d   t        k(  r¼t        |j                  «      st        |j                  t        «      r|}nFt        |j                  «      r| j	                  t
        |g|«      }n| j	                  t        |g|«      }|d   }|d   }t        |j                  «      rt        }nt        }|| j	                  ||g|«      fc S | j                  ||«      }| j	                  t        ||g|«       �Œ¤|t        k(  r‰|€kt        |«      dk(  rJt        |j                  «      rt        }nt        }| j!                  g |«      | j	                  ||g|«      fc S | j#                  ||	|«      }| j%                  t&        ||g|¬«       �Œ6|j)                  «       }|j+                  «       xr |}|j-                  «       xs |j)                  «       xr |xr |}|r-|r|€| j                  ||«      }|r|€| j#                  ||	|«      }|r|€|j/                  |«       �ŒÊ|r;|€9|€J ‚| j1                  |«      }|j/                  |«       |	j/                  |«       �Œ|
}t3        «       }|r‘|r;|
s9t5        t6        «      }| j9                  t;        || j=                  «       |«      «       |r
t3        «       n|}t3        «       }| j9                  t?        |||t>        j@                  «      «       | jC                  |«       |rD|rB|
r@t3        «       t3        «       }}| j9                  t?        |
||t>        jD                  «      «       nt3        «       x}}| jG                  |«       |r=| jC                  |«       |sJ ‚| jI                  |d|gd|¬«       | jG                  |«       |rW|r|
rS| jC                  |«       |€J ‚| j1                  |«      }|sJ ‚| jI                  |d||gd|¬«       | jG                  |«       |rV|rT|rR|usJ ‚| jC                  |«       | j9                  t;        || jK                  «       |«      «       | jG                  |«       | jC                  |«       |}
�Œ |s|r|sJ ‚|s|	r|sJ ‚|rB|€| j!                  ||«      }n-t        |j                  «      s| j	                  t
        |g|«      }|r#|€!t        |«      dkD  r| j#                  ||	|«      }||fS )	a  Construct *args and **kwargs from a collection of arguments

        This is pretty complicated, and almost all of the complication here stems from
        one of two things (but mostly the second):
          * The handling of ARG_STAR/ARG_STAR2. We want to create as much of the args/kwargs
            values in one go as we can, so we collect values until our hand is forced, and
            then we emit creation of the list/tuple, and expand it from there if needed.

          * Support potentially nullable argument values. This has very narrow applicability,
            as this will never be done by our compiled Python code, but is critically used
            by gen_glue_method when generating glue methods to mediate between the function
            signature of a parent class and its subclasses.

            For named-only arguments, this is quite simple: if it is
            null, don't put it in the dict.

            For positional-or-named arguments, things are much more complicated.
              * First, anything that was passed as a positional arg
                must be forwarded along as a positional arg. It *must
                not* be converted to a named arg. This is because mypy
                does not enforce that positional-or-named arguments
                have the same name in subclasses, and it is not
                uncommon for code to have different names in
                subclasses (a bunch of mypy's visitors do this, for
                example!). This is arguably a bug in both mypy and code doing
                this, and they ought to be using positional-only arguments, but
                positional-only arguments are new and ugly.

              * On the flip side, we're willing to accept the
                infelicity of sometimes turning an argument that was
                passed by keyword into a positional argument. It's wrong,
                but it's very marginal, and avoiding it would require passing
                a bitmask of which arguments were named with every function call,
                or something similar.
                (See some discussion of this in testComplicatedArgs)

            Thus, our strategy for positional-or-named arguments is to
            always pass them as positional, except in the one
            situation where we can not, and where we can be absolutely
            sure they were passed by name: when an *earlier*
            positional argument was missing its value.

            This means that if we have a method `f(self, x: int=..., y: object=...)`:
              * x and y present:      args=(x, y), kwargs={}
              * x present, y missing: args=(x,),   kwargs={}
              * x missing, y present: args=(),     kwargs={'y': y}

            To implement this, when we have multiple optional
            positional arguments, we maintain a flag in a register
            that tracks whether an argument has been missing, and for
            each such optional argument (except the first), we check
            the flag to determine whether to append the argument to
            the *args list or add it to the **kwargs dict. What a
            mess!

            This is what really makes everything here such a tangle;
            otherwise the *args and **kwargs code could be separated.

        The arguments has_star and has_star2 indicate whether the target function
        takes an ARG_STAR and ARG_STAR2 argument, respectively.
        (These will always be true when making a pycall, and be based
        on the actual target signature for a native call.)
        NrÏ   r†  r   r7  r  ©rÛ  r,  Ú__setitem__)&r   r”  rt   r  rt  rÅ   r|   r  rY   rÉ   r   rl   r�   rŒ   r®   r¬   Ú	new_tupleÚ_create_dictr§  r�   Úis_optionalÚis_positionalÚis_namedr  rs  r*   rH   r_   r  r(   rï  r,   rÌ  r%  r£  r   Útranslate_special_method_callÚtrue)rö   r  r,  Úhas_starÚ	has_star2Ústar_resultÚstar2_resultÚstar_valuesÚ
star2_keysÚstar2_valuesÚseen_empty_regrñ   Úkindr?  Ú	star2_argÚstar2_valueÚstar2_fastpath_opÚnullableÚ	maybe_posÚmaybe_namedrã  Únew_seen_empty_regrÏ  ÚskipÚkeepÚ	pos_blockÚnamed_blocks                              r÷   Ú_construct_varargsz$LowLevelIRBuilder._construct_varargsÉ  ss  € ðP %)ˆØ%)ˆð
 $&ˆØ"$ˆ
Ø$&ˆà*.ˆà!%ó D	4ÑˆE�4˜Ø”xÓØÑ&ä˜4“y A’~ä-¨e¯j©jÔ9Ø$(×$5Ñ$5´mÀeÀWÈdÓ$S™EÜ!4°U·Z±ZÔ!@ÌØ!ŸJ™J¬ôJð %)×$5Ñ$5Ô6GÈ%ÈÐRVÓ$W˜EØ$ d˜{Ò*Ü˜T› aš¨D°©G°A©J¼)Ò,Cô /¨u¯z©zÔ:¼jÈÏÉÔU[Ô>\Ø*/™KÜ/°·
±
Ô;Ø*.×*;Ñ*;¼MÈEÈ7ÐTXÓ*Y™Kà*.×*;Ñ*;Ô<MÐPUÈwÐX\Ó*]˜Kà$(¨¡G˜	Ø&/°¡l˜Ü-¨k×.>Ñ.>Ô?Ü0<Ñ-ä09Ð-Ø*¨D×,=Ñ,=Ø-°¨}¸dó-ð  ò ð
 #'×"2Ñ"2°;ÀÓ"E�KØ×!Ñ!¤.°;ÀÐ2FÈÖMØœÒ"ØÐ'Ü˜4“y A’~ô .¨e¯j©jÔ9Ü0<Ñ-ä09Ð-Ø#Ÿ~™~¨b°$Ó7¸×9JÑ9JØ-°¨w¸ó:ð  ò ð $(×#4Ñ#4°ZÀÈtÓ#T�Là—‘Ô5¸ÀeÐ7LÐSW�ÖXà×+Ñ+Ó-�Ø ×.Ñ.Ó0Ò=°X�	Ø"Ÿm™m›oÒ\°$×2BÑ2BÓ2DÒ2[ÈÒ2[ÐR[�ñ
 Ù  [Ð%8Ø&*×&6Ñ&6°{ÀDÓ&I˜Ù" |Ð';Ø'+×'8Ñ'8¸À\ÐSWÓ'X˜ñ  Ð!4Ø×&Ñ& uÔ-Ùá <Ð#7ØÐ+Ð+Ð+ØŸ-™-¨Ó-�CØ×%Ñ% cÔ*Ø ×'Ñ'¨Ô.Ùð &4Ð"ä “l�Ùñ !©Ü-5´oÓ-FÐ*ØŸ™¤Ð(:¸D¿J¹J»LÈ$Ó!OÔPá+4œ:œ<¸#�DÜ%›<�DØ—H‘HœV E¨4°´v·±ÓGÔHØ×'Ñ'¨Ô-ñ
 ¡±Ü-7«\¼:»<˜{�IØ—H‘HœV N°KÀÌFÏKÉKÓXÕYä.8«lÐ:�I Ø—I‘I˜iÔ(áØ×'Ñ'¨	Ô2Ù&Ð&˜;Ø×6Ñ6Ø# X°¨wÀDÈtð 7ô ð —I‘I˜c”Ná©	±^Ø×'Ñ'¨Ô4ØÐ+Ð+Ð+ØŸ-™-¨Ó-�CÙ'Ð'˜<Ø×6Ñ6Ø$ m°c¸5°\ÈtÐZ^ð 7ô ð —I‘I˜c”Ná¡	Ñ.@Ø s™?Ð*˜?Ø×'Ñ'¨Ô-Ø—H‘HœVÐ$6¸¿	¹	»ÀTÓJÔKØ—I‘I˜c”Nà×#Ñ# CÔ(à!3’ðID	4ñL  ¡;±8Ð;Ð;Ù ¡L±YÐ>Ð>Ùð Ð"Ø"Ÿn™n¨[¸$Ó?‘Ü(¨×)9Ñ)9Ô:à"×/Ñ/´À¸}ÈdÓS�Ù˜Ð-´#°j³/ÀAÒ2Eà×,Ñ,¨Z¸ÀtÓLˆLà˜LÐ(Ð(rù   Nc           	     ód  — | j                  |||||«      }|�|S |�t        d„ |D «       «      r| j                  t        |g|z   |«      S |€J ‚| j	                  t        t        |||«      «      |dd¬«      \  }}|sJ ‚|€| j                  t        ||g|«      S | j                  t        |||g|«      S )z‚Call a Python function (non-native and slow).

        Use py_call_op or py_call_with_kwargs_op for Python function call.
        c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrõ   ©r   ©r\  r  s     r÷   r^  z,LowLevelIRBuilder.py_call.<locals>.<genexpr>Å  ó   è ø€ Ò#J¸ D¬G¥OÑ#Jùó   ‚T©r  r  )	Ú_py_vector_callÚallr§  r—   r   Úlistr˜  r™   r˜   )	rö   ÚfunctionÚ
arg_valuesr,  Ú	arg_kindsÚ	arg_namesÚresultÚpos_args_tupleÚkw_args_dicts	            r÷   Úpy_callzLowLevelIRBuilder.py_call´  sÜ   € ð ×%Ñ% h°
¸DÀ)ÈYÓWˆØÐØˆMð Ð¤Ñ#JÀ	Ô#JÔ JØ—;‘;œz¨H¨:¸
Ñ+BÀDÓIÐIð Ð$Ð$Ð$à'+×'>Ñ'>Ü”�Z ¨IÓ6Ó7¸ÈÐX\ð (?ó (
Ñ$ˆ˜ñ Ðˆ~àÐØ—;‘;Ô6¸À>Ð8RÐTXÓYÐYà�{‰{Ô1°H¸nÈlÐ3[Ð]aÓbÐbrù   c           	     ó   — |�t        d„ |D «       «      rµ|r>|D �cg c]  }| j                  |t        |«      ‘Œ }}| j                  t        ||d¬«      }nt	        dt
        «      }t        ||«      }	| j                  |«      }
| j                  t        ||t	        |	t        «      |
g|«      }|r| j                  t        |«      «       |S yc c}w )z°Call function using the vectorcall API if possible.

        Return the return value if successful. Return None if a non-vectorcall
        API should be used instead.
        Nc              3  ód   K  — | ](  }|j                  «        xr |j                  «        –— Œ* y ­wrõ   ©Úis_starr  r$  s     r÷   r^  z4LowLevelIRBuilder._py_vector_call.<locals>.<genexpr>ã  ó2   è ø€ ò $
Ø>B�—‘“ÐÒ9 t×'7Ñ'7Ó'9Ð#9Ó9ñ$
ùó   ‚.0T©Ú
object_ptrr   )r)  rO  r€   Úsetup_rarrayr:   r   Únum_positional_argsÚ_vectorcall_keywordsr§  r�   rd   r  r<   )rö   r+  r,  r,  r-  r.  ÚargÚcoerced_argsÚarg_ptrÚnum_posÚkeywordsrñ   s               r÷   r(  z!LowLevelIRBuilder._py_vector_callÕ  sØ   € ð Ð¤ñ $
ØFOô$
ô !
ñ àU_Ö`Èc §¡¨CÔ1BÀDÕ IÐ`�Ð`Ø×+Ñ+Ô,=¸|ÈTÐ^bÐ+Óc‘ä! !Ô%>Ó?�Ü)¨*°iÓ@ˆGØ×0Ñ0°Ó;ˆHØ—K‘KÜ Ø˜7¤G¨GÔ5HÓ$IÈ8ÐTØóˆEñ
 ð —‘œ <°Ó6Ô7ØˆLØùò#  as   ›Cc                ó¨   — |r<|D �cg c]  }|€Œ|‘Œ	 }}|r(| j                  t        t        |«      t        «      «      S t	        dt        «      S c c}w )z‹Return a reference to a tuple literal with keyword argument names.

        Return null pointer if there are no keyword arguments.
        r   )r  r@   Útupler€   r:   )rö   r.  r?  Úkw_lists       r÷   r=  z&LowLevelIRBuilder._vectorcall_keywordsû  sQ   € ñ
 Ø(1ÖF °TÑ5E’tÐFˆGÐFÙØ—x‘x¤¬E°'«NÔ<MÓ NÓOÐOÜ�qÔ+Ó,Ð,ùò Gs
   ‡A�Ac                ó
  — | j                  ||||||«      }|�|S |�t        d„ |D «       «      r-| j                  |«      }| j                  t        ||g|z   |«      S | j                  |||«      }	| j                  |	||||¬«      S )z+Call a Python method (non-native and slow).c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrõ   r#  r$  s     r÷   r^  z3LowLevelIRBuilder.py_method_call.<locals>.<genexpr>  r%  r&  ©r-  r.  )Ú_py_vector_method_callr)  rs  r§  r›   rØ  r2  )
rö   rÙ  Úmethod_namer,  r,  r-  r.  r/  Úmethod_name_regÚmethods
             r÷   Úpy_method_callz LowLevelIRBuilder.py_method_call  sž   € ð ×,Ñ,Ø�˜j¨$°	¸9ó
ˆð ÐØˆMàÐ¤Ñ#JÀ	Ô#JÔ Jà"Ÿm™m¨KÓ8ˆOØ—;‘;Ô0°3¸Ð2HÈ:Ñ2UÐW[Ó\Ð\ð ×%Ñ% c¨;¸Ó=ˆFØ—<‘< ¨
°DÀIÐYb�<ÓcÐcrù   c           	     ó´  — |�t        d„ |D «       «      r¿| j                  |«      }|g|z   D �cg c]  }| j                  |t        |«      ‘Œ }	}| j	                  t        |	|d¬«      }
t        ||«      }| j                  |«      }| j                  t        ||
t        |dz   t        z  t        «      |g|«      }| j                  t        |	|«      «       |S yc c}w )z®Call method using the vectorcall API if possible.

        Return the return value if successful. Return None if a non-vectorcall
        API should be used instead.
        Nc              3  ód   K  — | ](  }|j                  «        xr |j                  «        –— Œ* y ­wrõ   r5  r$  s     r÷   r^  z;LowLevelIRBuilder._py_vector_method_call.<locals>.<genexpr>-  r7  r8  Tr9  rÏ   )r)  rs  rO  r€   r;  r<  r=  r§  rœ   r:   rÑ   rd   r  r<   )rö   rÙ  rJ  r,  r,  r-  r.  rK  r>  r?  r@  rA  rB  rñ   s                 r÷   rI  z(LowLevelIRBuilder._py_vector_method_call  sñ   € ð Ð¤ñ $
ØFOô$
ô !
ð #Ÿm™m¨KÓ8ˆOàFIÀUÈZÑEWöØ>A�—‘˜CÔ!2°DÕ9ðˆLð ð ×'Ñ'Ô(9¸<ÈÐZ^Ð'Ó_ˆGÜ)¨*°iÓ@ˆGØ×0Ñ0°Ó;ˆHØ—K‘KÜ'à#ØÜ˜W q™[Ô,JÑJÔL_Ó`Øð	ð ó	ˆEð �H‰H”Y˜|¨TÓ2Ô3ØˆLØùò+s   ®C©Úbitmap_argsc               ó|   — | j                  ||||j                  ||¬«      }| j                  t        |||«      «      S )a  Call a native function.

        If bitmap_args is given, they override the values of (some) of the bitmap
        arguments used to track the presence of values for certain arguments. By
        default, the values of the bitmap arguments are inferred from args.
        rP  )Únative_args_to_positionalÚsigr  r-   )rö   Údeclr  r-  r.  r,  rQ  s          r÷   ÚcallzLowLevelIRBuilder.callH  sD   € ð" ×-Ñ-Ø�)˜Y¨¯©°$ÀKð .ó 
ˆð �x‰xœ˜T 4¨Ó.Ó/Ð/rù   c          
     ó¤  — |j                   }|j                  }|r|d|  }|D �	cg c]  }	|	j                  ‘Œ }
}	|D �	cg c]  }	|	j                  ‘Œ }}	|D �cg c]  }t	        |«      ‘Œ }}t        |||
|d„ «      }dx}}g }t        ||«      D ]x  \  }}	|	j                  j                  «       r+|j                  |D �cg c]  }||   ||   ||   f‘Œ c}«       |xs |	j                  t        k(  }|xs |	j                  t        k(  }Œz | j                  ||||¬«      \  }}g }t        ||«      D �]+  \  }}	|	j                  t        k(  r|sJ ‚|}nú|	j                  t        k(  r|xs | j                  g g |«      }nÏ|stt        |	j                  «      rt        d|	j                  «      }n¡t!        |	j                  «      rt#        d«      }n€| j%                  t'        |	j                  d¬«      «      }nY||d      }||d      j)                  «       r| j+                  ||	j                  |«      }n| j-                  ||	j                  |«      }|j/                  |«       �Œ. t1        t3        |«      «      D ]È  }|r#|t5        |«      k  r|j/                  ||   «       Œ(d}d}t        ||«      D ]o  \  }}	|	j                  j)                  «       sŒ!|	j                  j6                  sŒ8|t8        z  |cxk  r|d	z   t8        z  k  rn n|r|d	|t8        d	z
  z  z  z  }|d	z  }Œq |j/                  t        |t:        «      «       ŒÊ |S c c}	w c c}	w c c}w c c}w )
aŠ  Prepare arguments for a native call.

        Given args/kinds/names and a target signature for a native call, map
        keyword arguments to their appropriate place in the argument list,
        fill in error values for unspecified default arguments,
        package arguments that will go into *args/**kwargs into a tuple/dict,
        and coerce arguments to the appropriate type.
        Nc                ó4   — t        t        j                  «      S rõ   )r   r   Úspecial_form)Úns    r÷   rì  z=LowLevelIRBuilder.native_args_to_positional.<locals>.<lambda>  s   € ”gœi×4Ñ4Ó5€ rù   Fr'  r   ç        T)rm  rÏ   )r  Únum_bitmap_argsr  r?  r…   r   r˜  r6  Úextendr   r   r   r  rm   r  r:   rn   r2   r  r>   r  rÑ  rO  r  Úreversedr–  r”  Úerror_overlapr   r^   )rö   r  r-  r.  rT  r,  rQ  Úsig_argsrZ  r>  Úsig_arg_kindsÚsig_arg_namesÚarg_kindÚconcrete_kindsÚformal_to_actualr  r  Ústar_arg_entriesÚlstrœ  Ústar_argr  Úoutput_argsÚ
output_argÚbase_argÚbitmaprÿ  s                              r÷   rS  z+LowLevelIRBuilder.native_args_to_positional^  s:  € ð& —8‘8ˆØ×ÑˆÙØ  ! �}ˆHà-5Ö6 c˜Ÿ›Ð6ˆÐ6Ø-5Ö6 c˜Ÿ›Ð6ˆÐ6àFOÖP¸(Ô+¨HÕ5ÐPˆÐPÜ1ØØØØÙ5ó
Ðð  %Ð$ˆ�9ØÐÜÐ,¨hÓ7ò 	;‰HˆC�Ø�x‰x×ÑÔ!Ø ×'Ñ'ÐX[Ö(\ÐST¨$¨q©'°9¸Q±<ÀÈ1ÁÒ)NÒ(\Ô]ØÒ7 3§8¡8¬xÑ#7ˆHØ!Ò: S§X¡X´Ñ%:‰Ið		;ð #×5Ñ5Ø˜d¨XÀð 6ó 
Ñˆ�)ð $&ˆÜÐ,¨hÓ7ó 	+‰HˆC�Ø�x‰xœ8Ò#Ù��xØ%‘
Ø—‘œYÒ&Ø&ÒI¨$×*;Ñ*;¸BÀÀDÓ*I‘
ÙÜ'¨¯©Ô1Ü!(¨¨C¯H©HÓ!5‘JÜ(¨¯©Ô2Ü!& s£‘Jà!%§¡¬.¸¿¹ÈtÔ*TÓ!U‘Jà  A¡™<�à˜S ™VÑ$×0Ñ0Ô2Ø!%×!5Ñ!5°hÀÇÁÈ$Ó!O‘Jà!%§¡¨X°s·x±xÀÓ!F�Jà×Ñ˜zÖ*ð+	+ô. œ% ›(Ó#ò 	CˆAÙ˜q¤3 {Ó#3Ò3à×"Ñ" ;¨q¡>Ô2ØàˆFØˆAÜÐ 0°(Ó;ò ‘��SØ—8‘8×'Ñ'Õ)¨c¯h©h×.DÓ.DØœ;‘¨!ÔC¨q°1©u¼Ñ.CÕCÙØ" a¨A´¸q±Ñ,AÑ&BÑB˜FØ˜‘F‘Aðð ×Ñœw vÔ/@ÓAÕBð	Cð  ÐùòI 7ùÚ6ùâPùò )]s   ¥L>¾MÁMÂ<M
c	           
     ó  — |�(t        d„ |D «       «      r| j                  ||||||«      S t        |z   }	t        |j                  t
        «      �r­|j                  j                  j                  s&|j                  j                  j                  |	«      �rg|j                  j                  j                  �sF|j                  j                  j                  r|n|	}|j                  j                  j                  |«      r¦|j                  j                  j                  |«      }
|€,|�J d«       ‚|D �cg c]  }t        ‘Œ
 }}|D �cg c]  }d‘Œ }}n	|€J d«       ‚|
j                  sJ ‚| j                  ||||
j                  |«      }| j                  t        ||||«      «      S |j                  j                  j!                  |«      rn| j                  t#        |||«      «      }| j%                  |||||¬«      S t        |j                  t&        «      r"| j)                  ||j                  ||||||«      S |r|t        gt+        |«      z  k(  r| j-                  ||||||¬«      }|r|S | j                  ||||||«      S c c}w c c}w )z/Generate either a native or Python method call.Nc              3  ó<   K  — | ]  }|j                  «       –— Œ y ­wrõ   )r6  r$  s     r÷   r^  z4LowLevelIRBuilder.gen_method_call.<locals>.<genexpr>É  s   è ø€ Ò(N¸D¨¯©¯Ñ(Nùs   ‚z&arg_kinds not present but arg_names isz&arg_kinds present but arg_names is notrH  r�  )r_  rM  r   r  r  rV   rÔ  rÕ  Ú
has_methodÚbuiltin_baseÚmethod_declr   Ú	bound_sigrS  r  rC   rÖ  r6   r2  r[   Úunion_method_callr”  r
  )rö   Úbaser?  r,  rÛ  r,  r-  r.  r|  Ú	fast_namerU  Ú_r+  r  s                 r÷   Úgen_method_callz!LowLevelIRBuilder.gen_method_call¼  s`  € ð Ð ¤SÑ(NÀIÔ(NÔ%NØ×&Ñ& t¨T°:¸tÀYÐPYÓZÐZô   $Ñ&ˆ	ä�t—y‘y¤)Õ,Ø—‘×#Ñ#×0Ò0°D·I±I×4FÑ4F×4QÑ4QÐR[Õ4\Ø—I‘I×&Ñ&×3Ó3àŸ9™9×-Ñ-×:Ò:‘4À	ˆDØ�y‰y×!Ñ!×,Ñ,¨TÔ2Ø—y‘y×)Ñ)×5Ñ5°dÓ;�ØÐ$Ø$Ð,ÐVÐ.VÓVÐ,Ø2<Ö =¨Q¦Ð =�IÐ =Ø/9Ö :¨!¢Ð :�IÑ :à$Ð0ÐZÐ2ZÓZÐ0ð —~’~Ð%�~Ø!×;Ñ;Ø 	¨9°d·n±nÀdó�
ð —x‘x¤
¨4°°zÀ4Ó HÓIÐIØ—‘×#Ñ#×,Ñ,¨TÔ2ØŸ8™8¤G¨D°$¸Ó$=Ó>�Ø—|‘|Ø˜j¨$¸)Èyð $ó ð ô ˜Ÿ	™	¤6Ô*Ø×)Ñ)Ø�d—i‘i  z°;ÀÀiÐQZóð ñ
 ˜I¬'¨´S¸³_Ñ)DÒDØ×7Ñ7Ø�d˜J¨°TÀjð 8ó ˆFñ Ø�ð ×"Ñ" 4¨¨z¸4ÀÈIÓVÐVùò? !>ùÚ :s   Ä3JÅ	Jc	                óf   ‡ ‡‡‡‡‡‡— ‰xs t         Šdˆˆˆˆˆˆˆ fd„}	‰ j                  ||‰|	‰«      S )z8Generate a method call with a union type for the object.c           	     ó2   •— ‰j                  | ‰‰‰‰‰‰«      S rõ   )rw  )rñ   r-  r.  r,  r,  r?  Úreturn_rtyperö   s    €€€€€€€r÷   Úcall_union_itemz<LowLevelIRBuilder.union_method_call.<locals>.call_union_item	  s%   ø€ Ø×'Ñ'Ø�t˜Z¨°t¸YÈ	óð rù   rà  )r€   rá  )
rö   rt  Úobj_typer?  r,  rz  r,  r-  r.  r{  s
   `  `````` r÷   rs  z#LowLevelIRBuilder.union_method_callù  s6   þ€ ð $Ò8Ô'8ˆ÷	ó 	ð
 ×*Ñ*¨4°¸<ÈÐZ^Ó_Ð_rù   c                ó$   — t        dt        |«      S )z0Load unboxed None value (type: none_rprimitive).rÏ   )r:   r~   ©rö   r,  s     r÷   ÚnonezLowLevelIRBuilder.none  ó   € ä�qœ/¨4Ó0Ð0rù   c                ó$   — t        dt        |«      S )z0Load unboxed True value (type: bool_rprimitive).rÏ   ©r:   r_   r~  s     r÷   r  zLowLevelIRBuilder.true  r€  rù   c                ó$   — t        dt        |«      S )z1Load unboxed False value (type: bool_rprimitive).r   r‚  r~  s     r÷   rï  zLowLevelIRBuilder.false  r€  rù   c                ór   — | j                  t        t        j                  t        j                  |«      «      S )z1Load Python None value (type: object_rprimitive).)r  r=   r³   r  rn  r~  s     r÷   Únone_objectzLowLevelIRBuilder.none_object  s&   € à�x‰xœ¤N×$7Ñ$7¼×9KÑ9KÈTÓRÓSÐSrù   c                óB   — | j                  t        t        d|«      «      S )z2Load Python True object (type: object_rprimitive).ÚPy_True©r  r?   r€   r~  s     r÷   Útrue_objectzLowLevelIRBuilder.true_object"  s   € à�x‰xœ
Ô#4°iÀÓFÓGÐGrù   c                óB   — | j                  t        t        d|«      «      S )z3Load Python False object (type: object_rprimitive).ÚPy_Falserˆ  r~  s     r÷   Úfalse_objectzLowLevelIRBuilder.false_object&  s   € à�x‰xœ
Ô#4°jÀ$ÓGÓHÐHrù   c                ó€   — |t         kD  s	|t        k  r | j                  t        |t        |«      «      S t        ||¬«      S )z-Load a tagged (Python) integer literal value.r7  )r   r   r  r@   rh   r:   ©rö   rñ   r,  s      r÷   Úload_intzLowLevelIRBuilder.load_int*  s8   € àÔ(Ò(¨EÔ4IÒ,IØ—8‘8œK¨¬~¸tÓDÓEÐEä˜5 tÔ,Ð,rù   c                ó   — t        ||«      S )zLoad a float literal value.)r2   rŽ  s      r÷   Ú
load_floatzLowLevelIRBuilder.load_float1  s   € ä�U˜DÓ!Ð!rù   c                óB   — | j                  t        |t        |«      «      S )z¸Load a str literal value.

        This is useful for more than just str literals; for example, method calls
        also require a PyObject * form for the name of the method.
        )r  r@   r„   rŽ  s      r÷   rs  zLowLevelIRBuilder.load_str5  s   € ð �x‰xœ E¬>¸4Ó@ÓAÐArù   c                óB   — | j                  t        |t        |«      «      S )zLoad a bytes literal value.)r  r@   r`   rŽ  s      r÷   Ú
load_byteszLowLevelIRBuilder.load_bytes=  s   € à�x‰xœ EÔ+;¸TÓBÓCÐCrù   c                óB   — | j                  t        |t        |«      «      S )zLoad a complex literal value.)r  r@   r€   rŽ  s      r÷   Úload_complexzLowLevelIRBuilder.load_complexA  s   € à�x‰xœ EÔ+<¸dÓCÓDÐDrù   c           	     ó   — |€d|› d�}t        «       t        «       }}| j                  t        |||||¬«      «      }	| j                  t        |	||t        j                  d¬«      «       | j                  |«       | j                  t        t        j                  ||«      «       | j                  t        «       «       | j                  |«       |	S )Nzname "z" is not definedr7  T©Úrare)	r*   r  rB   r,   rÌ  r%  rG   Ú
NAME_ERRORrN   )
rö   rú  Ú
identifierr  Ú	namespacer,  Ú	error_msgÚok_blockÚerror_blockrñ   s
             r÷   Úload_static_checkedz%LowLevelIRBuilder.load_static_checkedE  s«   € ð ÐØ   Ð,<Ð=ˆIÜ *£¬j«l�+ˆØ—‘œ C¨°[À)ÐRVÔWÓXˆØ�‰”˜˜{¨H´f·o±oÈDÔQÔRØ×Ñ˜KÔ(Ø�‰Ô#Ô$6×$AÑ$AÀ9ÈdÓSÔTØ�‰”“ÔØ×Ñ˜HÔ%Øˆrù   c                óL   — | j                  t        t        |t        ¬«      «      S )N)rœ  )r  rB   r€   r%   )rö   r?  s     r÷   Úload_modulezLowLevelIRBuilder.load_moduleY  s   € Ø�x‰xœ
Ô#4°dÔFVÔWÓXÐXrù   c                óZ   — |j                   › d|j                  › �}| j                  |«      S )zLoad native type object.ú.)r  r?  Úload_native_type_object)rö   ÚclsÚfullnames      r÷   rþ  z!LowLevelIRBuilder.get_native_type\  s,   € à—o‘oÐ& a¨¯© zÐ2ˆØ×+Ñ+¨HÓ5Ð5rù   c                óv   — |j                  dd«      \  }}| j                  t        t        ||t        «      «      S )Nr¤  rÏ   )Úrsplitr  rB   r€   r'   )rö   r§  Úmoduler?  s       r÷   r¥  z)LowLevelIRBuilder.load_native_type_objecta  s1   € Ø—‘ s¨AÓ.‰ˆ�Ø�x‰xœ
Ô#4°d¸FÄNÓSÓTÐTrù   c           	     ó¾  — |j                   }|j                   }t        |t        «      r(t        |t        «      r|dv r| j                  ||||«      S |dv r| j	                  ||||«      }|�|S |dv r| j                  ||||«      S t        |«      rPt        |«      rE|t        v r=|t        j                  v r| j                  ||||«      S | j                  |||d   |«      S t        |t        «      r|dv r| j                  ||||«      S t        |«      �r||t        v r²|j!                  d«      }|dk7  r
t"        |   }nt$        j&                  }t        |«      r| j)                  |||«      }|}t        |«      st+        |«      r| j-                  |||||«      S t        |t.        «      �ru| j-                  ||| j)                  |||«      ||«      S |t        j                  v �r<t1        |«      r| j3                  |||«      }nt        |«      r| j)                  |||«      }t        j                  |   }t        |j                   «      r| j5                  ||||«      S t        |t.        «      �r²| j5                  || j)                  |||«      ||«      S t        |«      �r�|t        v r¹|j!                  d«      }|dk7  r
t"        |   }nt$        j&                  }t        |t.        «      r&| j-                  || j)                  |||«      |||«      S t+        |«      r| j-                  |||||«      S t        |«      rè| j)                  |||«      }| j-                  |||||«      S |t        j                  v r®t1        |«      r| j3                  |||«      }nt        |«      r| j)                  |||«      }t        j                  |   }t        |t.        «      r%| j5                  | j)                  |||«      |||«      S t        |j                   «      r| j5                  ||||«      S t7        |«      st7        |«      �r7t        |t.        «      r#t9        t;        |j=                  «       «      «      }n‚t        |t.        «      r#t9        t;        |j=                  «       «      «      }nOt1        |j                   «      r| j?                  ||«      }n't1        |j                   «      r| j?                  ||«      }t7        |j                   «      rmt7        |j                   «      rX|t@        v r| jC                  ||t@        |   |«      S |jE                  d«      r|dd }	n|}	|	tF        v r| jI                  |||	|«      S | jK                  ||||«      }
|
r|
S t        |tL        «      r|d	k(  rtO        | |||«      S tQ        jR                  |g «      }| jU                  |||g|«      }|s
J d
|z  «       ‚|S )z”Perform a binary operation.

        Generate specialized operations based on operand types, with a fallback
        to generic operations.
        )rë   rê   N)Úisúis notr   )Úinúnot inú=rã   r  r®  z Unsupported binary operation: %s)+r  r  rY   Úcompare_tuplesÚtranslate_eq_cmpÚtranslate_is_opri   rí   r0   Ú
signed_opsÚbool_comparison_opÚbool_bitwise_oprV   Útranslate_instance_containsrm   ræ   ÚremovesuffixrR   r;   ÚDIVrO  r{   Úfixed_width_int_opr:   rs   r‰  Úcomparison_oprn   r2   r’  r‡  r“  rP   Úcompare_floatsÚendswithrQ   Úfloat_opÚ	dunder_opr\   r†   r¹   rE  Úmatching_primitive_op)rö   ÚlregÚrregr  r,  Últyper@  rñ   Úop_idÚbase_opr¿  Úprimitive_ops_candidatesr  s                r÷   Ú	binary_opzLowLevelIRBuilder.binary_opg  sj  € ð —	‘	ˆØ—	‘	ˆô �eœVÔ$¬°E¼6Ô)BÀrÈ\ÑGYØ×&Ñ& t¨T°2°tÓ<Ð<ð �ÑØ×)Ñ)¨$°°b¸$Ó?ˆEØÐ Ø�ð Ð!Ñ!Ø×'Ñ'¨¨d°B¸Ó=Ð=ä% eÔ,Ü)¨%Ô0Ø”oÑ%à”\×,Ñ,Ñ,Ø×.Ñ.¨t°T¸2¸tÓDÐDà×+Ñ+¨D°$¸¸1¹¸tÓDÐDÜ�eœYÔ'¨BÐ2BÑ,BØ×3Ñ3°D¸$ÀÀDÓIÐIÜ Õ&ØÔ/Ñ/Ø—_‘_ SÓ)�Ø˜’:Ü(¨Ñ,‘Eä!ŸI™I�EÜ,¨UÔ3ØŸ;™; t¨U°DÓ9�DØ!�EÜ'¨Ô.´)¸EÔ2BØ×2Ñ2°5¸$ÀÀeÈTÓRÐRÜ˜d¤GÕ,Ø×2Ñ2Ø˜t T§[¡[°°u¸dÓ%CÀUÈDóð ð ”|×.Ñ.Ò.Ü$ UÔ+Ø×9Ñ9¸$ÀÀtÓL‘DÜ.¨uÔ5ØŸ;™; t¨U°DÓ9�DÜ$×/Ñ/°Ñ3�Ü'¨¯	©	Ô2Ø×-Ñ-¨d°D¸%ÀÓFÐFÜ˜d¤GÕ,Ø×-Ñ-¨d°D·K±KÀÀeÈTÓ4RÐTYÐ[_Ó`Ð`Ü! %Õ(ØÔ/Ñ/Ø—_‘_ SÓ)�Ø˜’:Ü(¨Ñ,‘Eä!ŸI™I�EÜ˜d¤GÔ,Ø×2Ñ2Ø˜tŸ{™{¨4°¸Ó=¸tÀUÈDóð ô ˜UÔ#Ø×2Ñ2°5¸$ÀÀeÈTÓRÐRÜ,¨UÔ3ØŸ;™; t¨U°DÓ9�DØ×2Ñ2°5¸$ÀÀeÈTÓRÐRØ”|×.Ñ.Ñ.Ü$ UÔ+Ø×9Ñ9¸$ÀÀtÓL‘DÜ.¨uÔ5ØŸ;™; t¨U°DÓ9�DÜ$×/Ñ/°Ñ3�Ü˜d¤GÔ,Ø×-Ñ-¨d¯k©k¸$ÀÀtÓ.LÈdÐTYÐ[_Ó`Ð`Ü'¨¯	©	Ô2Ø×-Ñ-¨d°D¸%ÀÓFÐFä˜uÔ%Ô)<¸UÕ)CÜ˜$¤Ô(ÜœU 4×#5Ñ#5Ó#7Ó8Ó9‘Ü˜D¤'Ô*ÜœU 4×#5Ñ#5Ó#7Ó8Ó9‘Ü" 4§9¡9Ô-Ø×(Ñ(¨¨tÓ4‘Ü" 4§9¡9Ô-Ø×(Ñ(¨¨tÓ4�Ü" 4§9¡9Ô-Ô2EÀdÇiÁiÔ2PØÔ2Ñ2Ø×.Ñ.¨t°TÔ;TÐUWÑ;XÐZ^Ó_Ð_Ø—;‘;˜sÔ#Ø   "˜g‘Gà �GØœnÑ,ØŸ=™=¨¨t°W¸dÓCÐCà—N‘N 4¨¨r°4Ó8ˆ	ÙØÐä�eœTÔ" r¨T¢zÜ  d¨D°$Ó7Ð7ä#-§>¡>°"°bÓ#9Ð Ø×+Ñ+Ð,DÀtÈTÀlÐTXÓYˆÙÐ>Ð9¸BÑ>Ó>ˆvØˆrù   c                óÌ  — |j                   }t        |t        «      sy|rt        j                  |«      nt        j                  |«      }|€y|j                  j                  |«      sy|j                  j                  |«      }|s#t        |j                  j                  «      dk7  ry|rZt        |j                  j                  «      dk7  s7t        |j                   |j                  j                  d   j                   «      sy|r/t        t        j                   |j                  j                  «      ry|r|gng }| j                  ||||j                  j                  |«      S )a[  
        Dispatch a dunder method if applicable.

        For example for `a + b` it will use `a.__add__(b)` which can lead to higher performance
        due to the fact that the method could be already compiled and optimized instead of going
        all the way through `PyNumber_Add(a, b)` python api (making a jump into the python DL).
        NrÏ   r†  )r  r  rV   r   rE  r   rÔ  ro  rq  r”  rT  r  rÍ   r´   Úret_typerw  )	rö   rÁ  rÂ  r  r,  rÃ  rJ  rU  r  s	            r÷   r¿  zLowLevelIRBuilder.dunder_opÜ  s  € ð —	‘	ˆÜ˜%¤Ô+Øá,0”j—n‘n RÔ(Ô6F×6JÑ6JÈ2Ó6NˆØÐØà�~‰~×(Ñ(¨Ô5Øà�~‰~×)Ñ)¨+Ó6ˆÙœ˜DŸH™HŸM™MÓ*¨aÒ/Øá”S˜Ÿ™Ÿ™Ó'¨1Ò,´J¸t¿y¹yÈ$Ï(É(Ï-É-ÐXYÑJZ×J_ÑJ_Ô4`Øá”JÔ1×6Ñ6¸¿¹×8IÑ8IÔJð á�‰v 2ˆØ×#Ñ# D¨+°t¸T¿X¹X×=NÑ=NÐPTÓUÐUrù   c                ó  — t        dt        |«      }| j                  t        ||t        j                  |«      }t        dt        |«      }|rt
        j                  nt
        j                  }| j                  ||||«      }|S )zuCheck if a tagged integer is a short integer.

        Return the result of the check (value of type 'bit').
        rÏ   r   )	r:   rc   r�  r;   ÚANDr0   ÚNEQrø  r»  )	rö   Úvalr,  ÚnegatedÚint_tagÚbitwise_andÚzeror  r¬  s	            r÷   r¢  z(LowLevelIRBuilder.check_tagged_short_intþ  sl   € ô
 ˜!Ô3°TÓ:ˆØ—k‘kÔ"8¸#¸wÌÏ	É	ÐSWÓXˆÜ�qÔ0°$Ó7ˆÙ!(Œ\×Ò¬l¯o©oˆØ×"Ñ" ;°°b¸$Ó?ˆØˆrù   c           	     ó  — |dk(  r×d}dd„} ||«      rH ||«      r9|j                   |j                   k(  r| j                  «       S | j                  «       S ||}}d}n
 ||«      rd}|r\t        t        t        t
        |«      j                   «      }t        t        |«      t        |«      }| j                  t        |||g|«      S | j                  t        ||g|«      S |dk(  rM| j                  ||d|«      }	| j                  t        |	| j                  «       t        j                  |«      «      S | j!                  t"        ||g|«      }
t        dt$        |«      }| j                  t        |
|t        j                  |«      «      }t'        «       t'        «       t'        «       }}}t)        |||t(        j*                  «      }d|_        | j                  |«       | j/                  |«       | j!                  t0        g |«      }t        dt2        |«      }| j                  t        ||t        j4                  |«      «      }t)        |||t(        j*                  «      }d|_        | j                  |«       | j/                  |«       | j!                  t6        g |«       | j9                  |«       | j/                  |«       |dk(  rt        j                  nt        j4                  }| j                  t        |
t        dt$        «      ||«      «      S )	zCompare two stringsrë   Fc                óP   — t        | t        «      xr t        | j                  «      S rõ   )r  r@   rz   r  )rñ   s    r÷   Úis_string_literalz<LowLevelIRBuilder.compare_strings.<locals>.is_string_literal  s   € Ü! %¬Ó5ÒWÔ:KÈEÏJÉJÓ:WÐWrù   Trê   r  r   )rñ   rO   rû   zTypeGuard[LoadLiteral])rñ   r  rï  r
   rr  r@   r:   r”  rc   rt  rÂ   rÁ   Úcompare_stringsr  r0   rø  r§  rÄ   ra   r*   r,   r£  rÎ  r%  r‘   r‚   rÌ  r’   r   )rö   ÚlhsÚrhsr  r,  Úliteral_fastpathrÔ  Úliteral_stringÚliteral_lengthÚeqÚcompare_resultÚerror_constantÚcompare_error_checkÚexception_checkÚ	propagateÚfinal_compareÚbranchÚcheck_error_resultÚnullÚop_types                       r÷   rÕ  z!LowLevelIRBuilder.compare_strings
  s�  € à�Š:à$ÐóXñ ! Ô%Ù$ SÔ)à*-¯)©)°s·y±yÒ*@˜4Ÿ9™9›;ÐRÀdÇjÁjÃlÐRð  �S�Ø#'Ñ Ù" 3Ô'Ø#'Ð áÜ!%¤c¬4´¸SÓ+A×+GÑ+GÓ!H�Ü!(¬¨^Ó)<Ô>TÐVZÓ![�Ø×(Ñ(¬¸#¸sÀNÐ9SÐUYÓZÐZà×$Ñ$¤V¨c°3¨Z¸Ó>Ð>à�4ŠZà×%Ñ% c¨3°°dÓ;ˆBØ—8‘8œL¨¨T¯Z©Z«\¼<¿?¹?ÈDÓQÓRÐRð
 Ÿ™¤_°s¸C°jÀ$ÓGˆÜ  Ô%5°tÓ<ˆØ"Ÿh™hÜ˜¨¼¿¹È$ÓOó
Ðô 5?³LÄ*Ã,ÔPZÓP\ M˜ˆÜÐ+¨_¸mÌVÏ[É[ÓYˆØˆŒØ�‰�ÔØ×Ñ˜OÔ,Ø!Ÿ[™[¬¸"¸dÓCÐÜ�qÔ,¨dÓ3ˆØ"Ÿh™hÜÐ+¨T´<×3CÑ3CÀTÓJó
Ðô Ð+¨Y¸ÄvÇ{Á{ÓSˆØˆŒØ�‰�ÔØ×Ñ˜IÔ&Ø�‰Ô'¨¨TÔ2Ø�	‰	�-Ô Ø×Ñ˜MÔ*Ø%'¨4¢Z”,—/’/´\×5EÑ5EˆØ�x‰xœ ^´W¸QÔ@PÓ5QÐSZÐ\`ÓaÓbÐbrù   c           	     óÔ   — | j                  t        ||g|«      }|dk(  rt        j                  nt        j                  }| j                  t        |t        dt        «      ||«      «      S )Nrë   rÏ   )r§  rŠ   r0   rø  rÌ  r  r:   ra   )rö   rÖ  r×  r  r,  rÜ  rå  s          r÷   Úcompare_byteszLowLevelIRBuilder.compare_bytesF  sS   € ØŸ™¤]°S¸#°JÀÓEˆØ%'¨4¢Z”,—/’/´\×5EÑ5EˆØ�x‰xœ ^´W¸QÔ@PÓ5QÐSZÐ\`ÓaÓbÐbrù   c           
     óÖ  — t        |j                  t        «      rt        |j                  t        «      sJ |j                  |j                  f«       ‚|dk(  rdnd}t        t        «      }t        |j                  j                  «      t        |j                  j                  «      k7  r>| j                  t        ||r| j                  «       n| j                  «       |«      «       |S t        |j                  j                  «      dk(  r`t        |j                  j                  «      dk(  r>| j                  t        ||r| j                  «       n| j                  «       |«      «       |S t        |j                  j                  «      }t        «       t        «       t        «       }
}	}t        |«      D �cg c]  }t        «       ‘Œ }}t        |«      D �cg c]  }| j                  t        |||«      «      ‘Œ  }}t        |«      D �cg c]  }| j                  t        |||«      «      ‘Œ  }}|r||	}}n|	|}}t        t        |j                  j                  «      «      D ]â  }|dk7  r| j                  ||   «       ||   }||   }| j                  ||||«      }t!        |j                  «      s| j#                  t$        |g|«      }|t        |j                  j                  «      dz
  k  r#t'        ||||dz      t&        j(                  «      }nt'        |||t&        j(                  «      }||_        | j                  |«       Œä | j                  |«       | j                  t        || j                  «       |«      «       | j-                  |
«       | j                  |	«       | j                  t        || j                  «       |«      «       | j/                  |
«       |S c c}w c c}w c c}w )zCompare two tuples item by itemrë   TFr   rÏ   )r  r  rY   rH   r_   r”  r•  r  r(   rï  r  r*   r–  rK   r%  rÇ  ri   rt  r¯   r,   r£  rÎ  r   r'  )rö   rÖ  r×  r  r,  Úequalr/  ÚlengthÚfalse_assignÚtrue_assignrÏ  rv  Úcheck_blocksrœ  Ú	lhs_itemsÚ	rhs_itemsÚ
early_stopÚfinalÚlhs_itemÚrhs_itemÚcomparerâ  s                         r÷   r±  z LowLevelIRBuilder.compare_tuplesK  sõ  € ô ˜#Ÿ(™(¤FÔ+´
¸3¿8¹8ÄVÔ0LÐbÈsÏxÉxÐY\×YaÑYaÐNbÓbÐLØ˜dš
‘¨ˆÜœ/Ó*ˆäˆs�x‰x�~‰~Ó¤# c§h¡h§n¡nÓ"5Ò5Ø�H‰H”V˜F±E D§J¡J¤L¸t¿y¹y»{ÈDÓQÔRØˆMäˆs�x‰x�~‰~Ó !Ò#¬¨C¯H©H¯N©NÓ(;¸qÒ(@Ø�H‰H”V˜F±5 D§I¡I¤K¸d¿j¹j»lÈDÓQÔRØˆMÜ�S—X‘X—^‘^Ó$ˆÜ)3«´z³|ÄZÃ\ 3�kˆÜ.3°F«mÖ<¨œ
�Ð<ˆÐ<Ü?DÀV»}ÖM¸!�T—X‘Xœh s¨A¨tÓ4Õ5ÐMˆ	ÐMÜ?DÀV»}ÖM¸!�T—X‘Xœh s¨A¨tÓ4Õ5ÐMˆ	ÐMáØ ,¨k˜‰Jà +¨\˜ˆJä”s˜3Ÿ8™8Ÿ>™>Ó*Ó+ò 	ˆAØ�AŠvØ×#Ñ# L°¡OÔ4Ø  ‘|ˆHØ  ‘|ˆHØ—n‘n X¨x¸¸TÓBˆGô -¨W¯\©\Ô:Ø×+Ñ+¬G°g°YÀÓE�Ø”3�s—x‘x—~‘~Ó&¨Ñ*Ò*Ü ¨°\À!ÀaÁ%Ñ5HÌ&Ï+É+ÓV‘ä ¨°U¼F¿K¹KÓH�à"ˆFŒNØ�H‰H�VÕð!	ð" 	×Ñ˜LÔ)Ø�‰”˜ §
¡
£¨dÓ3Ô4Ø�	‰	�#ŒØ×Ñ˜KÔ(Ø�‰”˜ §	¡	£¨TÓ2Ô3Ø×Ñ˜sÔ#ØˆùòA =ùÚMùÚMs   Æ3OÇ#O!È#O&c                óÜ   — | j                  |d|gd |«      }t        |j                  «      s| j                  t        |g|«      }|dk(  r#| j                  |t        dt        ¬«      d|«      }|S )NÚ__contains__r¯  rÏ   rx  rà   )rw  ri   r  rt  r¯   r¶  r:   r_   )rö   Úinstrž  r  r,  r­  s         r÷   r·  z-LowLevelIRBuilder.translate_instance_contains}  sh   € Ø×"Ñ" 4¨¸$¸ÀÀtÓLˆÜ(¨¯©Ô2Ø×#Ñ#¤G¨c¨U°DÓ9ˆCØ�Š>Ø×&Ñ& s¬G°A¼_Ô,MÈsÐTXÓYˆCØˆ
rù   c           	     óØ   — |dk(  rt         j                  }n3|dk(  rt         j                  }n|dk(  rt         j                  }nJ |«       ‚| j	                  t        t
        ||||«      «      S )NrÝ   rá   rà   )r;   rË  ÚORr¦  r  r_   )rö   rÁ  rÂ  r  r,  Úcodes         r÷   r¶  z!LowLevelIRBuilder.bool_bitwise_op…  sX   € Ø�Š9Ü—9‘9‰DØ�3ŠYÜ—8‘8‰DØ�3ŠYÜ—9‘9‰Dà˜"Ó�5Ø�x‰xœœo¨t°T¸4ÀÓFÓGÐGrù   c                óP   — t         j                  |   }| j                  ||||«      S rõ   )r0   r´  r»  )rö   rÁ  rÂ  r  r,  rÄ  s         r÷   rµ  z$LowLevelIRBuilder.bool_comparison_op�  s)   € Ü×'Ñ'¨Ñ+ˆØ×!Ñ! $¨¨e°TÓ:Ð:rù   c                óÖ   — t        |j                  t        «      r| j                  |d ||«      }|�|S t	        j
                  |g «      }| j                  ||g|«      }|s
J d|z  «       ‚|S )NúUnsupported unary operation: %s)r  r  rV   r¿  r¾   rE  rÀ  )rö   rñ   r  r,  r/  rÆ  r  s          r÷   Ú_non_specialized_unary_opz+LowLevelIRBuilder._non_specialized_unary_op”  so   € Ü�e—j‘j¤)Ô,Ø—^‘^ E¨4°°TÓ:ˆFØÐ!Ø�Ü#,§=¡=°°RÓ#8Ð Ø×+Ñ+Ð,DÀuÀgÈtÓTˆÙÐ=Ð8¸2Ñ=Ó=ˆvØˆrù   )Úlikely_boolc          	     óx	  — |j                   }t        |«      r0t        d||«      }| j                  |||t        j
                  |«      S t        |«      st        |«      r| j                  |t        d«      d|«      S t        |«      s1t        |«      s&t        |«      st        |«      st        |t        «      r#| j                  |«      }| j!                  ||«      S t#        |«      �ržt%        |«      }|sJ ‚t        |«      s2t        |«      s't        |«      st        |«      st        |t        «      �rRt'        t(        «      }| j+                  t-        || j/                  «       t,        j0                  |«      «      }	t3        «       t3        «       t3        «       }}}
| j+                  t5        |	|
|t4        j6                  «      «       | j9                  |
«       | j+                  t;        || j=                  «       «      «       | j?                  |«       | j9                  |«       | j!                  | jA                  |||dd¬«      |«      }| j+                  t;        ||«      «       | j?                  |«       | j9                  |«       |S |�r"tC        |«      �rt'        t(        «      }t3        «       t3        «       t3        «       t3        «       f\  }}}}t3        «       }| j+                  t-        || jE                  «       t,        j0                  |«      «      }	| j+                  t5        |	||t4        j6                  «      «       | j9                  |«       | j+                  t;        || jG                  «       «      «       | j?                  |«       | j9                  |«       | j+                  t-        || jI                  «       t,        j0                  |«      «      }	| j+                  t5        |	||t4        j6                  «      «       | j9                  |«       | j+                  t;        || j=                  «       «      «       | j?                  |«       | j9                  |«       | jK                  |d|«      }| j+                  t;        ||«      «       | j?                  |«       | j9                  |«       |S | jK                  |d|«      S )zÃPerform unary 'not'.

        Args:
            likely_bool: The operand is likely a bool value, even if the type is something
                more general, so specialize for bool values
        rÏ   r   rë   Tr{  Únot)&r  ri   r:   r�  r;   r¦  r{   rm   rÇ  rz   rt   r|   rl   r  rV   Ú
bool_valueÚ	unary_notrw   r�   rH   r]   r  r0   r…  rø  r*   r,   r£  r%  r(   r  r   r€  rv   r‰  rï  rŒ  rþ  )rö   rñ   r,  rÿ  rú  ÚmaskÚbool_valÚ	value_typr­  Úcmpr  Únot_nonerÏ  rÍ  rï  Ú	not_falser  rç  s                     r÷   r  zLowLevelIRBuilder.unary_notž  s�  € ð �j‰jˆÜ$ SÔ)Ü˜1˜c 4Ó(ˆDØ—;‘;˜s E¨4´·±¸DÓAÐAÜ�SŒ>Ô1°#Ô6Ø—>‘> %¬°«°T¸4Ó@Ð@ä˜cÔ"Ü! #Ô&Ü" 3Ô'Ü! #Ô&Ü˜#œyÔ)à—‘ uÓ-ˆHØ—>‘> (¨DÓ1Ð1Ü˜CÕ Ü+¨CÓ0ˆIÙÐ�9ä! )Ô,Ü% iÔ0Ü& yÔ1Ü% iÔ0Ü˜i¬Õ3ô œ~Ó.�Ø—h‘hœ|¨E°4×3CÑ3CÓ3EÄ|ÇÁÐX\Ó]Ó^�Ü&0£l´J³LÄ*Ã, �h�Ø—‘œ  T¨8´V·[±[ÓAÔBØ×#Ñ# DÔ)Ø—‘œ  T§Y¡Y£[Ó1Ô2Ø—	‘	˜#”Ø×#Ñ# HÔ-Ø—n‘nØ×&Ñ& u¨i¸È$ÐZ^Ð&Ó_Øó�ð —‘œ  SÓ)Ô*Ø—	‘	˜#”Ø×#Ñ# CÔ(Ø�
ÚÔ/°Õ4äœ>Ó*ˆCÜ,6«L¼*»,Ì
ËÔV`ÓVbÐ,bÑ)ˆE�9˜d EÜ“,ˆCØ—(‘(œ<¨¨t×/?Ñ/?Ó/AÄ<Ç?Á?ÐTXÓYÓZˆCØ�H‰H”V˜C ¨	´6·;±;Ó?Ô@Ø×Ñ Ô&Ø�H‰H”V˜C §¡£Ó.Ô/Ø�I‰I�cŒNØ×Ñ 	Ô*Ø—(‘(œ<¨¨t×/@Ñ/@Ó/BÄLÇOÁOÐUYÓZÓ[ˆCØ�H‰H”V˜C  u¬f¯k©kÓ:Ô;Ø×Ñ Ô%Ø�H‰H”V˜C §¡£Ó-Ô.Ø�I‰I�cŒNØ×Ñ Ô&Ø×0Ñ0°¸¸tÓDˆCØ�H‰H”V˜C Ó%Ô&Ø�I‰I�cŒNØ×Ñ Ô$ØˆJØ×-Ñ-¨e°U¸DÓAÐArù   c                ó¢  — |j                   }t        |t        «      rt        |j                  «        ||«      S t        |t        «      rt	        |j
                   |«      S t        |«      r-| j                  |t        d|«      |t        j                  |«      S t        |«      r| j                  t        ||«      «      S | j                  |d|«      S )zPerform unary '-'.r   rß   )r  r  r:   r‡  r2   rñ   rm   r�  r;   ÚSUBrn   r  r4   rþ  ©rö   rñ   r,  rú  s       r÷   Úunary_minuszLowLevelIRBuilder.unary_minusç  s©   € à�j‰jˆÜ�eœWÔ%ä˜E×/Ñ/Ó1Ð1°3¸Ó=Ð=Ü˜œuÔ%Ü˜%Ÿ+™+˜ tÓ,Ð,Ü! #Ô&à—;‘;˜s¤G¨A¨s£O°U¼E¿I¹IÀtÓLÐLÜ  Ô%Ø—8‘8œH U¨DÓ1Ó2Ð2Ø×-Ñ-¨e°S¸$Ó?Ð?rù   c                óœ   — |j                   }t        |«      s!t        |«      st        |«      st	        |«      r|S | j                  |d|«      S )zPerform unary '+'.rÞ   )r  r{   rn   ri   rm   rþ  r  s       r÷   Ú
unary_pluszLowLevelIRBuilder.unary_plusö  sD   € à�j‰jˆä�cŒNÜ" 3Ô'Ü(¨Ô-Ü# CÔ(àˆLØ×-Ñ-¨e°S¸$Ó?Ð?rù   c                óL  — |j                   }t        |«      r{|j                  r-| j                  ||t	        d|«      t
        j                  |«      S d|j                  dz  z  dz
  }| j                  ||t	        ||«      t
        j                  |«      S | j                  |d|«      S )zPerform unary '~'.r  rÏ   rÐ   ú~)	r  rm   rŽ  r�  r:   r;   r¦  r�  rþ  )rö   rñ   r,  rú  r  s        r÷   Úunary_invertzLowLevelIRBuilder.unary_invert  sŒ   € à�j‰jˆÜ Ô$Ø�}Š}à—{‘{ 3¨¬w°r¸3Ó/?ÄÇÁÈDÓQÐQð ˜cŸh™h¨™lÑ+¨qÑ0�Ø—{‘{ 3¨¬w°t¸SÓ/AÄ5Ç9Á9ÈdÓSÐSØ×-Ñ-¨e°S¸$Ó?Ð?rù   c                óÖ   — |dk(  r| j                  ||«      S |dk(  r| j                  ||«      S |dk(  r| j                  ||«      S |dk(  r| j                  ||«      S t	        d|z  «      ‚)zPerform a unary operation.r  rß   rÞ   r  rý  )r  r  r  r  ÚRuntimeError)rö   rñ   r  r,  s       r÷   Úunary_opzLowLevelIRBuilder.unary_op  sw   € à�Š;Ø—>‘> %¨Ó.Ð.Ø�3ŠYØ×#Ñ# E¨4Ó0Ð0Ø�3ŠYØ—?‘? 5¨$Ó/Ð/Ø�3ŠYØ×$Ñ$ U¨DÓ1Ð1ÜÐ<¸rÑAÓBÐBrù   c               ó2  — t        |j                  t        «      rft        |j                  «      st	        |j                  «      r| j                  |t        |«      }t        |j                  «      rt        | ||||¬«      S | j                  |d|g|||¬«      S )zGenerate base[item].r�  Ú__getitem__)
r  r  r\   rs   ry   rO  rg   rr   r‡   rw  )rö   rt  rž  rÛ  r,  r|  s         r÷   Úget_itemzLowLevelIRBuilder.get_item  sƒ   € ô �d—i‘i¤Ô&Ü  §¡Ô+Ô/FÀtÇyÁyÔ/QØ—{‘{ 4Ô)9¸4Ó@�Ü" 4§9¡9Ô-Ü# D¨$°°dÀzÔRÐRà×#Ñ#Ø�- $ ¨°dÀzð $ó 
ð 	
rù   c                ó.  — d }g }g }|D ]t  \  }}|�>|€#|j                  |«       |j                  |«       Œ-| j                  |d||gd |¬«       ŒF|€| j                  |||«      }| j                  t        ||g|¬«       Œv |€| j                  |||«      }|S )Nr  r  r7  )r  r
  r  r§  r�   )rö   Úkey_value_pairsr,  r/  Úkeysr+  rã  rñ   s           r÷   Ú	make_dictzLowLevelIRBuilder.make_dict/  sÀ   € Ø#ˆØˆØ ˆØ)ò 	S‰JˆC�Øˆà�>Ø—K‘K Ô$Ø—M‘M %Ô(Øà×2Ñ2Ø˜M¨C°¨<ÀTÐPTð 3õ ð
 �>Ø!×.Ñ.¨t°V¸TÓB�Fà—‘Ô5¸À°ÈT�ÕRð!	Sð$ ˆ>Ø×&Ñ& t¨V°TÓ:ˆFàˆrù   c                ó2   — | j                  t        |g|«      S )aÇ  This function returns an uninitialized list.

        If the length is non-zero, the caller must initialize the list, before
        it can be made visible to user code -- otherwise the list object is broken.
        You might need further initialization with `new_list_set_item_op` op.

        Args:
            length: desired length of the new list. The rtype should be
                    c_pyssize_t_rprimitive
            line: line number
        )r§  r®   ©rö   rê  r,  s      r÷   Únew_list_op_with_lengthz)LowLevelIRBuilder.new_list_op_with_lengthJ  s   € ð �{‰{œ;¨¨°$Ó7Ð7rù   c           	     ó  — t        t        |«      t        |«      g}t        |«      t        k\  r| j	                  t
        ||z   |«      S | j	                  t        ||«      }|s|S |D �cg c]  }| j                  |t        |«      ‘Œ }}| j                  t        |gt        |«      «      }t        t        |«      «      D ]-  }| j                  t        |t        |t        «      ||   g|«       Œ/ | j                  t        |g|«      «       |S c c}w rõ   )r:   r”  rc   Ú!LIST_BUILDING_EXPANSION_THRESHOLDr§  r«   r®   rO  r€   r  rF   r­   r–  rt  r°   r<   )	rö   r+  r,  rê  Úresult_listrž  r  Úob_item_baserœ  s	            r÷   r®   zLowLevelIRBuilder.new_list_opX  sú   € Ü&¤s¨6£{Ô4JÈDÓQÐRˆÜˆv‹;Ô;Ò;Ø—;‘;œ}¨f°v©o¸tÓDÐDð —k‘k¤+¨v°tÓ<ˆÙØÐØGMÖN¸t�—‘˜DÔ"3°TÕ:ÐNˆÐNØ—x‘x¤¨[¨M¼:ÀtÓ LÓMˆÜ”s˜6“{Ó#ò 	ˆAØ×ÑÜ ¬g°aÔ9OÓ.PÐRVÐWXÑRYÐZÐ\`õð	ð 	�‰”˜K˜=¨$Ó/Ô0ØÐùò Os   Á'D
c                ó0   — | j                  t        ||«      S rõ   )rt  r¿   )rö   r+  r,  s      r÷   r¿   zLowLevelIRBuilder.new_set_opm  s   € Ø× Ñ ¤¨V°TÓ:Ð:rù   r9  c               óè   — t        t        |t        |«      «      «      }| j                  t	        |t        |«      |«      «       | j                  t        |rt        |«      «      S t        |«      «      S )z;Declare and initialize a new RArray, returning its address.)	rH   rU   r”  r  r)   r*  r=   r   rb   )rö   Ú	item_typer+  r,  r:  Úarrays         r÷   r;  zLowLevelIRBuilder.setup_rarrayp  sd   € ô œ 	¬3¨v«;Ó7Ó8ˆØ�‰”˜U¤D¨£L°$Ó7Ô8Ø�x‰xÜ±ZÔ1Ð[`Óaó
ð 	
ÜEYÐ[`Óaó
ð 	
rù   c                ó¼  — t        ||¬«      }t        «       t        «       t        «       }	}}|dk(  r||fn||f\  }
}| j                  |«      5   |«       }| j                  ||
|«       | j	                  |«       | j                  |||«      }| j                  t        |||«      «       d d d «       | j                  |	«       | j	                  |«       | j                  |«      5   |«       }| j                  |||«      }| j                  t        |||«      «       d d d «       | j                  |	«       | j	                  |	«       |S # 1 sw Y   ŒŸxY w# 1 sw Y   Œ9xY w)Nr7  Úand)	rH   r*   rh  Úadd_bool_branchr%  rO  r  r(   r   )rö   r  Ú	expr_typeÚleftÚrightr,  r  Ú	left_bodyÚ
right_bodyÚ
next_blockÚ	true_bodyÚ
false_bodyÚ
left_valueÚleft_coercedÚright_valueÚright_coerceds                   r÷   rð  z%LowLevelIRBuilder.shortcircuit_helperz  sA  € ô ˜)¨$Ô/ˆä,6«L¼*»,Ì
Ë˜z�:ˆ	ð <>Àº; ¨YÑ 7ÈYÐXbÐLcÑˆ	�:à×Ñ Ó%ñ 	9Ù›ˆJØ× Ñ  ¨Y¸
ÔCà×Ñ 	Ô*ØŸ;™; z°9¸dÓCˆLØ�H‰H”V˜F L°$Ó7Ô8÷	9ð 	�	‰	�*Ôà×Ñ˜JÔ'Ø×Ñ Ó%ñ 	:Ù›'ˆKØ ŸK™K¨°YÀÓEˆMØ�H‰H”V˜F M°4Ó8Ô9÷	:ð 	�	‰	�*Ôà×Ñ˜JÔ'Øˆ÷#	9ð 	9ú÷	:ð 	:ús   ÁAEÃ#7EÅEÅEc           	     óf  — t        |j                  «      r|}|S t        |j                  t        «      r>t	        dt
        «      }| j                  ||t        j                  |j                  «      }|S t        |j                  «      rBt	        d|j                  «      }| j                  t        ||t        j                  «      «      }|S t        |j                  «      r$| j                  t        |g|j                  «      }|S t        |j                  «      s*t!        |j                  «      st#        |j                  «      rG| j%                  ||j                  «      }t	        d«      }| j'                  ||d|j                  «      }|S t)        |j                  t*        «      rj|j                  j,                  j.                  rJ|j                  j,                  j1                  d«      r%| j3                  |dg t4        |j                  «      }|S t7        |j                  «      r7| j9                  |t;        d«      t<        j                  |j                  «      }|S t?        |j                  «      }|��Ÿ| jA                  || jC                  «       d|j                  «      }d}t)        |t*        «      r8|j,                  j1                  d«      s|j,                  jE                  d«      rd}|r|}|S tG        tH        «      }tK        «       tK        «       tK        «       }
}	}tM        |||	tL        jN                  «      }| j                  |«       | jQ                  |«       | jS                  |||j                  «      }| jU                  |«      }| j                  tW        ||«      «       | jY                  |
«       | jQ                  |	«       | j                  tW        |t	        dtH        «      «      «       | jY                  |
«       | jQ                  |
«       |S | j[                  t\        |g|j                  «      }|S )z_Return bool(value).

        The result type can be bit_rprimitive or bool_rprimitive.
        r   rê   Ú__bool__r[  r­  FT)/ri   r  rË   rh   r:   rƒ   r»  r0   rÌ  r,  rm   r  rz   r§  rÀ   rt   rl   r|   Úbuiltin_lenrÇ  r  rV   rÔ  rÕ  ro  rw  r_   rn   r¼  r2   r3   r�   r³  r…  Úis_method_finalrH   r]   r*   r,   r£  r%  r€  r  r(   r   rt  r¯   )rö   rñ   r/  rÑ  rê  r3  r  Úalways_truthyr  rï  r«  râ  Ú	remainingÚas_bools                 r÷   r  zLowLevelIRBuilder.bool_valuež  sh  € ô
 % U§Z¡ZÔ0ØˆFðv ˆôu   §
¡
¬NÔ;Ü˜1Ô2Ó3ˆDØ×'Ñ'¨¨t´\×5EÑ5EÀuÇzÁzÓRˆFðp ˆôo " %§*¡*Ô-Ü˜1˜eŸj™jÓ)ˆDØ—X‘Xœl¨5°$¼×8HÑ8HÓIÓJˆFðj ˆôi ˜uŸz™zÔ*Ø—[‘[Ô!2°U°G¸U¿Z¹ZÓHˆFðf ˆôc ˜uŸz™zÔ*Ü! %§*¡*Ô-Ü" 5§:¡:Ô.à×%Ñ% e¨U¯Z©ZÓ8ˆFÜ˜1“:ˆDØ—^‘^ F¨D°$¸¿
¹
ÓCˆFðV ˆôS �u—z‘z¤9Ô-Ø—
‘
×#Ñ#×0Ò0Ø—
‘
×#Ñ#×.Ñ.¨zÔ:ð ×)Ñ)¨%°¸RÄÐRW×R\ÑR\Ó]ˆFðH ˆôG ! §¡Ô,Ø×(Ñ(¨´°c³
Ô<M×<QÑ<QÐSX×S]ÑS]Ó^ˆFðD ˆôA -¨U¯Z©ZÓ8ˆJØÑ%Ø×/Ñ/°°t×7GÑ7GÓ7IÈ8ÐUZ×U_ÑU_Ó`�Ø %�Ü˜j¬)Ô4à%×.Ñ.×9Ñ9Ø"ôà$×-Ñ-×=Ñ=¸jÔIØ(,˜á Ø%�Fð( ˆô# &¤nÓ5�FÜ'1£|´Z³\Ä:Ã< ˜%�DÜ# H¨d°E¼6¿;¹;ÓG�FØ—H‘H˜VÔ$Ø×'Ñ'¨Ô-ð !%× 2Ñ 2°5¸*ÀeÇjÁjÓ Q�IØ"Ÿo™o¨iÓ8�GØ—H‘HœV F¨GÓ4Ô5Ø—I‘I˜c”NØ×'Ñ'¨Ô.Ø—H‘HœV F¬G°A´~Ó,FÓGÔHØ—I‘I˜c”NØ×'Ñ'¨Ô,ð ˆð ×*Ñ*¬7°U°G¸U¿Z¹ZÓH�Øˆrù   c           	     óØ  — t        |j                  «      }|€H| j                  |«      }| j                  t	        |||t        j
                  |j                  «      «       y | j                  || j                  «       d|j                  «      }t	        |||t        j
                  |j                  «      }| j                  |«       d}t        |t        «      r8|j                  j                  d«      s|j                  j                  d«      rd}|s[t        «       |_        | j!                  |j                  «       | j#                  |||j                  «      }	| j%                  |	||«       y y )Nr­  Fr8  T)r�   r  r  r  r,   r£  r,  r³  r…  r  rV   rÔ  ro  r:  r*   r  r%  r€  r*  )
rö   rñ   r  rï  Úopt_value_typer  Úis_nonerâ  r;  r<  s
             r÷   r*  z!LowLevelIRBuilder.add_bool_branchá  s!  € Ü,¨U¯Z©ZÓ8ˆØÐ!ØŸ™¨Ó/ˆJØ�H‰H”V˜J¨¨e´V·[±[À%Ç*Á*ÓMÕNð ×*Ñ*¨5°$×2BÑ2BÓ2DÀhÐPU×PZÑPZÓ[ˆGÜ˜G T¨5´&·+±+¸u¿z¹zÓJˆFØ�H‰H�VÔØ!ˆMÜ˜.¬)Ô4à%×.Ñ.×9Ñ9Øôà$×-Ñ-×=Ñ=¸jÔIØ$(�Má ä(›l�”Ø×#Ñ# F§K¡KÔ0ð !×.Ñ.¨u°nÀeÇjÁjÓQ�	Ø×$Ñ$ Y°°eÕ<ð !rù   c                ó*  — g }t        t        t        |«      t        |j                  «      «      «      D ]:  }|j                  |   }||   }| j	                  |||«      }|j                  |«       Œ< |j                  �*|j                  �J ‚|j                  D �cg c]  }||   ‘Œ	 }}d}	|j                  �ut        |j                  «      }	t        t        |j                  «      t        |«      «      D ]5  }||   }| j	                  ||j                  |«      }|j                  |«       Œ7 |j                  D ]%  }
|
\  }}t        |||«      }|j                  |«       Œ' |j                  }|t        k(  rt        }| j                  t        |j                  ||j                   |j"                  |j$                  |||	|j&                  |j(                  |j*                  ¬«      «      }|j$                  r4|D ]/  }t-        |t        t.        f«      rŒ| j1                  |t2        «       Œ1 |j                  t        k(  rMt5        |t        d|j                   |«      t4        j6                  |«      }t8        |_
        | j                  |«       |j:                  €|}n'| j                  t=        ||j:                  «      «      }|}|rRt?        |j@                  |«      s<tC        |«      r| jE                  «       }|S | j	                  ||||j$                  ¬«      }|S c c}w )zHCall function using C/native calling convention (not a Python callable).r  ©Úis_pureÚreturns_nullÚdependenciesr   r�  )#r–  Úminr”  Ú	arg_typesrO  r  ÚorderingÚvar_arg_typeÚextra_int_constantsr:   Ú
error_kindr·   r$   r  r.   Úc_function_nameÚreturn_typeÚstealsrm  rC  rD  rE  r  r@   rk  r   r0   r²  r#   Útruncated_typerJ   rË   r  ru   r  )rö   Údescr  r,  rÛ  rÐ  rœ  Úformal_typer>  Úvar_arg_idxrž  rÍ  rú  Úextra_int_constantrK  r  Úcompr/  Útruncates                      r÷   r§  zLowLevelIRBuilder.call_cü  sÊ  € ð ˆä”sœ3˜t›9¤c¨$¯.©.Ó&9Ó:Ó;ò 	 ˆAØŸ.™.¨Ñ+ˆKØ�q‘'ˆCØ—+‘+˜c ;°Ó5ˆCØ�N‰N˜3Õð		 ð �=‰=Ð$Ø×$Ñ$Ð,Ð,Ð,Ø+/¯=©=Ö9 a�w˜q“zÐ9ˆGÐ9àˆØ×ÑÐ(Ü˜dŸn™nÓ-ˆKÜœ3˜tŸ~™~Ó.´°D³	Ó:ò $�Ø˜1‘g�Ø—k‘k # t×'8Ñ'8¸$Ó?�Ø—‘˜sÕ#ð$ð
 ×,Ñ,ò 	/ˆDØ‰HˆC�Ü!(¨¨c°4Ó!8ÐØ�N‰NÐ-Õ.ð	/ð —_‘_ˆ
ØœÒ$ä"ˆJØ—‘ÜØ×$Ñ$ØØ× Ñ Ø—‘Ø× Ñ ØØØØŸ™Ø!×.Ñ.Ø!×.Ñ.ôó
ˆð ×Òð ò E�Ü! #¬´Ð'=Õ>Ø×'Ñ'¨Ô-CÕDðEð �?‰?œkÒ)Ü ¬°°4×3CÑ3CÀTÓ(JÌL×L\ÑL\Ð^bÓcˆDÜ'ˆDŒOØ�H‰H�TŒNà×ÑÐ&Ø‰Fà—x‘x¤¨°×1DÑ1DÓ EÓFˆHØˆFÙÔ1°&·+±+¸{ÔKÜ! +Ô.ð Ÿ™›�ð ˆð Ÿ™ V¨[¸$È4×K[ÑK[˜Ó\�Øˆùòs :s   ÂLc                ó˜  — d }|D ]«  }t        |j                  «      t        |«      k7  rŒ%t        d„ t        ||j                  «      D «       «      sŒL|j                  r|sŒ[|rM|j
                  |j
                  k7  sJ dj                  ||«      «       ‚|j
                  |j
                  kD  sŒ§|}Œª|}Œ­ |r| j                  ||||«      }|S y )Nc              3  óN   K  — | ]  \  }}t        |j                  |«      –— Œ y ­wrõ   ©rÍ   r  )r\  ÚactualÚformals      r÷   r^  z4LowLevelIRBuilder.matching_call_c.<locals>.<genexpr>V	  s$   è ø€ ò Ù4B°F¸F”
˜6Ÿ;™;¨×/ñùs   ‚#%úAmbiguous:
1) {}
2) {})r”  rG  r)  r˜  rm  ÚpriorityÚformatr§  )	rö   Ú
candidatesr  r,  rÛ  r|  ÚmatchingrP  r  s	            r÷   Úmatching_call_cz!LowLevelIRBuilder.matching_call_cJ	  sÓ   € ð 15ˆØò 	$ˆDÜ�4—>‘>Ó"¤c¨$£iÒ/ØÜñ ÜFIÈ$ÐPT×P^ÑP^ÓF_ôõ à×'Ò'ª:ÙØ#×,Ñ,°·±Ò=ð Ð?Y×?`Ñ?`Ø  $ó@ó Ð=ð —}‘} x×'8Ñ'8Ó8Ø#'™à#‘Hð	$ñ Ø—[‘[ ¨4°°{ÓCˆFØˆMØrù   c                óú  — |j                   r»t        |j                  |j                  |j                  |j
                  |j                  |j                   |j                  |j                  |j                  |j                  |j                  |j                  |j                  d|j                  ¬«      }| j                  ||||¬«      S d}|j                   �f|€J d«       ‚t#        |«      t#        |j                   «      k(  sJ ‚|j                  D �cg c]  }t%        ||«      ‘Œ }	}t%        |j                  |«      }n|j                  }	g }
t'        t)        t#        |«      t#        |	«      «      «      D ]4  }|	|   }||   }|€J ‚| j+                  |||«      }|
j-                  |«       Œ6 |j                  �J ‚|j
                  �J ‚|j                  rJ ‚| j/                  t1        |
|||	||¬«      «      }|j                  r4|
D ]/  }t3        |t4        t6        f«      rŒ| j9                  |t:        «       Œ1 |j                  t<        k(  rMt?        |t5        d|j                  |«      t>        j@                  |«      }tB        |_        | j/                  |«       |j                  �J ‚|}|rRtE        |jF                  |«      s<tI        |«      r| jK                  «       }|S | j+                  ||||j                  ¬«      }|S c c}w )	zAdd a primitive op.FrB  )rÛ  Nz5Generic primitive op requires explicit type arguments)r,  rG  rM  Ú	type_argsr   r�  )&rL  r¸   r?  rG  rM  rI  rO  rK  rN  rm  rH  rJ  r\  rC  rE  r§  Útype_paramsr”  rÊ   r–  rF  rO  r  r  rF   r  r:   r@   rk  r   r·   r0   r²  r#   rË   r  ru   r  )rö   rP  r  r,  rÛ  rb  Úc_descrM  Úarg_typerG  rÐ  rœ  rQ  r>  r  rT  r/  s                    r÷   rt  zLowLevelIRBuilder.primitive_opf	  sÑ  € ð ×Òô *Ø—	‘	Ø—‘Ø× Ñ Ø×!Ñ!Ø×#Ñ#Ø×$Ñ$Ø—‘Ø—‘Ø× Ñ Ø—‘Ø×(Ñ(Ø—‘ØŸ™Ø"Ø!×.Ñ.ôˆFð" —;‘;˜v t¨T¸{�;ÓKÐKð ˆØ×ÑÐ'ØÐ(ÐaÐ*aÓaÐ(Ü�y“>¤S¨×)9Ñ)9Ó%:Ò:Ð:Ð:ØKOÏ>É>ÖZ¸xœ h°	Õ:ÐZˆIÐZÜ& t×'7Ñ'7¸ÓC‰KàŸ™ˆIàˆä”sœ3˜t›9¤c¨)£nÓ5Ó6ò 	 ˆAØ# A™,ˆKØ�q‘'ˆCØÐ*Ð*Ð*Ø—+‘+˜c ;°Ó5ˆCØ�N‰N˜3Õð	 ð �}‰}Ð$Ð$Ð$Ø× Ñ Ð(Ð(Ð(Ø×+Ò+Ð+Ð+Ø—‘ÜØØØØ#Ø'Ø#ôó	
ˆð ×Òð ò E�Ü! #¬´Ð'=Õ>Ø×'Ñ'¨Ô-CÕDðEð �?‰?œkÒ)Ü ¬°°4×3CÑ3CÀTÓ(JÌL×L\ÑL\Ð^bÓcˆDÜ'ˆDŒOØ�H‰H�TŒNà×"Ñ"Ð*Ð*Ð*ØˆÙÔ1°&·+±+¸{ÔKÜ! +Ô.ð Ÿ™›�ð ˆð Ÿ™ V¨[¸$È4×K[ÑK[˜Ó\�Øˆùò_ [s   ÄK8T©r|  Ústrictc               ó8  ‡— d}|D ]Ð  }t        |j                  «      t        |«      k7  rŒ%|j                  r| j                  j                  sŒHt        ˆfd„t        ||j                  «      D «       «      sŒq|j                  r|sŒ€|rM|j                  |j                  k7  sJ dj                  ||«      «       ‚|j                  |j                  kD  sŒÌ|}ŒÏ|}ŒÒ |r| j                  ||||¬«      S ‰r)t        d„ |D «       «      r| j                  |||||d¬«      S y)ztFind primitive operation that is compatible with types of args.

        Return None if none of them match.
        Nc              3  óV   •K  — | ]   \  }}t        |j                  |‰ ¬ «      –— Œ" y­w))ÚrelaxedNrX  )r\  rY  rZ  rg  s      €r÷   r^  z:LowLevelIRBuilder.matching_primitive_op.<locals>.<genexpr>Ô	  s1   øè ø€ ò ñ #�F˜Fô ˜6Ÿ;™;¨¸F¸
×CÐCñùs   ƒ&)r[  )r,  rÛ  c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrõ   )Úis_ambiguous)r\  Úprims     r÷   r^  z:LowLevelIRBuilder.matching_primitive_op.<locals>.<genexpr>ã	  s   è ø€ ÒC°˜$×+Õ+ÑCùs   ‚Frf  )r”  rG  Úexperimentalr  Úexperimental_featuresr)  r˜  rm  r\  r]  rt  r_  rÀ  )	rö   r^  r  r,  rÛ  r|  rg  r_  rP  s	         `  r÷   rÀ  z'LowLevelIRBuilder.matching_primitive_opÀ	  s&  ø€ ð 15ˆØò 	$ˆDÜ�4—>‘>Ó"¤c¨$£iÒ/ØØ× Ò ¨¯©×)KÒ)KØÜó ô '*¨$°·±Ó&?ôõ ð ×'Ò'ª:ÙØ#×,Ñ,°·±Ò=ð Ð?Y×?`Ñ?`Ø  $ó@ó Ð=ð —}‘} x×'8Ñ'8Ó8Ø#'™à#‘Hð#	$ñ$ Ø×$Ñ$ X¨t¸$ÈKÐ$ÓXÐXÙ”cÑC¸
ÔCÔCà×-Ñ-Ø˜D $¨À
ÐSXð .ó ð ð rù   c           	     ó>   — | j                  t        |||||«      «      S )a  Generate a native integer binary op.

        Use native/C semantics, which sometimes differ from Python
        semantics.

        Args:
            type: Either int64_rprimitive or int32_rprimitive
            op: IntOp.* constant (e.g. IntOp.ADD)
        )r  r;   )rö   r  rÖ  r×  r  r,  s         r÷   r�  zLowLevelIRBuilder.int_opë	  s    € ð �x‰xœ˜d C¨¨b°$Ó7Ó8Ð8rù   c           	     óð  — t         |   }|t        j                  t        j                  fv �rt	        |t
        «      r|j                  dk7  sé| j                  |t        d«      t        j                  |«      }t        «       t        «       }}| j                  t        |||t        j                  d¬«      «       | j                  |«       |t        j                  k(  rd}	nd}	| j                  t        t        j                   |	|«      «       | j                  t#        «       «       | j                  |«       |t        j                  k(  r| j%                  |||«      S | j                  t        ||||«      «      S )a  Generate a native float binary arithmetic operation.

        This follows Python semantics (e.g. raise exception on division by zero).
        Add a FloatOp directly if you want low-level semantics.

        Args:
            op: Binary operator (e.g. '+' or '*')
        r[  Tr˜  zfloat division by zerozfloat modulo)rQ   r5   r¹  ÚMODr  r2   rñ   r¼  r3   rø  r*   r  r,   r£  r%  rG   ÚZERO_DIVISION_ERRORrN   Ú	float_mod)
rö   rÖ  r×  r  r,  rÄ  rÿ  ÚerrÚokÚmsgs
             r÷   r¾  zLowLevelIRBuilder.float_op÷	  s  € ô ˜rÑ"ˆØ”W—[‘[¤'§+¡+Ð.Ò.Ü˜s¤EÔ*¨s¯y©y¸CÒ/?Ø×'Ñ'¨¬U°3«ZÔ9J×9MÑ9MÈtÓT�Ü$›,¬
«�R�Ø—‘œ  3¨¬F¯K©K¸dÔCÔDØ×#Ñ# CÔ(ØœGŸK™KÒ'Ø2‘Cà(�CØ—‘Ô+Ô,>×,RÑ,RÐTWÐY]Ó^Ô_Ø—‘œ›Ô'Ø×#Ñ# BÔ'Ø”G—K‘KÒà—>‘> # s¨DÓ1Ð1à—8‘8œG C¨¨e°TÓ:Ó;Ð;rù   c                ó  — | j                  t        ||t        j                  |«      «      }t        t        «      }| j                  t        ||«      «       t        «       t        «       t        «       t        «       f\  }}}}	| j                  t        |t        d«      t        j                  |«      «      }
| j                  t        |
||t        j                  «      «       | j                  |«       | j                  |||«      }| j                  t        ||	|t        j                  «      «       | j                  |«       | j                  ||d|«      }| j                  t        ||«      «       | j                  t        |	«      «       | j                  |«       | j!                  t"        t        d«      |g|«      }| j                  t        ||«      «       | j                  t        |	«      «       | j                  |	«       |S )z/Perform x % y on floats using Python semantics.r[  rÞ   )r  r5   rr  rH   rf   r(   r*   r3   r2   rø  r,   r£  r%  Úis_same_float_signsr¾  r9   rt  r“   )rö   rÖ  r×  r,  Úmodr­  ÚtrickyÚadjustÚcopysignÚdoneÚis_zeroÚ
same_signsÚadjs                r÷   rt  zLowLevelIRBuilder.float_mod
  s„  € à�h‰h”w˜s C¬¯©°dÓ;Ó<ˆÜÔ'Ó(ˆØ�‰”˜˜SÓ!Ô"Ü)3«´z³|ÄZÃ\ÔS]ÓS_Ð)_Ñ&ˆ�˜ $Ø—(‘(Ô,¨S´%¸³*Ô>O×>RÑ>RÐTXÓYÓZˆØ�‰”˜ ¨6´6·;±;Ó?Ô@Ø×Ñ˜FÔ#Ø×-Ñ-¨c°3¸Ó=ˆ
Ø�‰”˜
 D¨&´&·+±+Ó>Ô?Ø×Ñ˜FÔ#Ø�m‰m˜C  c¨4Ó0ˆØ�‰”˜˜SÓ!Ô"Ø�‰”�d“ÔØ×Ñ˜HÔ%ð ×Ñ¤¬e°C«j¸#Ð->ÀÓEˆØ�‰”˜˜SÓ!Ô"Ø�‰”�d“ÔØ×Ñ˜DÔ!Øˆ
rù   c                ó<   — | j                  t        ||||«      «      S rõ   )r  r3   ©rö   rÖ  r×  r  r,  s        r÷   r¼  z LowLevelIRBuilder.compare_floats,
  s   € Ø�x‰xÔ)¨#¨s°B¸Ó=Ó>Ð>rù   c                ó¼   — t        |t        «      rt        ||j                  «      }| j	                  |j                  ||t
        j                  |j                  «      S )zTHelper to add two native integers.

        The result has the type of lhs.
        )r  rú   r:   r  r�  r;   ÚADDr,  ©rö   rÖ  r×  s      r÷   Úint_addzLowLevelIRBuilder.int_add/
  óA   € ô
 �cœ3ÔÜ˜#˜sŸx™xÓ(ˆCØ�{‰{˜3Ÿ8™8 S¨#¬u¯y©y¸#¿(¹(ÓCÐCrù   c                ó¼   — t        |t        «      rt        ||j                  «      }| j	                  |j                  ||t
        j                  |j                  «      S )zgHelper to subtract a native integer from another one.

        The result has the type of lhs.
        )r  rú   r:   r  r�  r;   r  r,  r†  s      r÷   Úint_subzLowLevelIRBuilder.int_sub8
  rˆ  rù   c                ó¼   — t        |t        «      rt        ||j                  «      }| j	                  |j                  ||t
        j                  |j                  «      S )zYHelper to multiply two native integers.

        The result has the type of lhs.
        )r  rú   r:   r  r�  r;   ÚMULr,  r†  s      r÷   Úint_mulzLowLevelIRBuilder.int_mulA
  rˆ  rù   c                ó\  — | j                  |||«      }| j                  |||«      }|t        j                  k(  ræt        |t        «      rQ|j
                  dvrC|j                  s#| j                  |||t        j                  |«      S | j                  ||||«      S t        |«      rt        }n^t        |«      rt        }nLt        |«      rt        }n:t        |«      r(| j!                  |||«       | j                  |||||«      S J |«       ‚| j#                  |||g|«      S |t        j$                  k(  ræt        |t        «      rQ|j
                  dvrC|j                  s#| j                  |||t        j$                  |«      S | j'                  ||||«      S t        |«      rt(        }n^t        |«      rt*        }nLt        |«      rt,        }n:t        |«      r(| j!                  |||«       | j                  |||||«      S J |«       ‚| j#                  |||g|«      S | j                  |||||«      S )a  Generate a binary op using Python fixed-width integer semantics.

        These may differ in overflow/rounding behavior from native/C ops.

        Args:
            type: Either int64_rprimitive or int32_rprimitive
            op: IntOp.* constant (e.g. IntOp.ADD)
        )r  r   )rO  r;   r¹  r  r:   rñ   rŽ  r�  Úinline_fixed_width_dividerr   r¤   rq   r¡   rp   rž   r}   Úcheck_for_zero_divisionr§  rr  Úinline_fixed_width_modr¥   r¢   rŸ   )rö   r  rÖ  r×  r  r,  rm  s          r÷   rº  z$LowLevelIRBuilder.fixed_width_int_opJ
  sç  € ð �k‰k˜#˜t TÓ*ˆØ�k‰k˜#˜t TÓ*ˆØ”—‘Š?Ü˜#œwÔ'¨C¯I©I¸WÑ,DØ—~’~ØŸ;™; t¨S°#´u·y±yÀ$ÓGÐGð  ×9Ñ9¸$ÀÀSÈ$ÓOÐOÜ" 4Ô(Ü&‘Ü$ TÔ*Ü&‘Ü$ TÔ*Ü&‘Ü$ TÔ*Ø×,Ñ,¨S°$¸Ô=Ø—{‘{ 4¨¨c°2°tÓ<Ð<à"˜dÓ"�uØ—;‘;˜t c¨3 Z°Ó6Ð6Ø”—‘Š?Ü˜#œwÔ'¨C¯I©I¸WÑ,DØ—~’~ØŸ;™; t¨S°#´u·y±yÀ$ÓGÐGð  ×6Ñ6°t¸SÀ#ÀtÓLÐLÜ" 4Ô(Ü#‘Ü$ TÔ*Ü#‘Ü$ TÔ*Ü#‘Ü$ TÔ*Ø×,Ñ,¨S°$¸Ô=Ø—{‘{ 4¨¨c°2°tÓ<Ð<à"˜dÓ"�uØ—;‘;˜t c¨3 Z°Ó6Ð6Ø�{‰{˜4  c¨2¨tÓ4Ð4rù   c                óˆ  — t        «       t        «       }}| j                  |t        d|«      d|«      }| j                  t	        |||t        j
                  «      «       | j                  |«       | j                  t        t        j                  d|«      «       | j                  t        «       «       | j                  |«       y )Nr   rë   z"integer division or modulo by zero)
r*   rÇ  r:   r  r,   r£  r%  rG   rs  rN   )rö   r×  r  r,  ru  rv  r  s          r÷   r�  z)LowLevelIRBuilder.check_for_zero_division�
  s”   € Ü“,¤
£ˆRˆØ—.‘. ¤g¨a°Ó&6¸¸dÓCˆØ�‰”˜  b¬&¯+©+Ó6Ô7Ø×Ñ˜CÔ Ø�‰ÜÜ"×6Ñ6Ð8\Ð^bóô	
ð
 	�‰”“ÔØ×Ñ˜BÕrù   c                ón  — t        |«      }| j                  |||t        j                  |«      }| j	                  t        ||«      «       | j                  ||||«      }t        «       t        «       t        «       }
}	}| j	                  t        ||
|t        j                  «      «       | j                  |«       | j                  |||t        j                  |«      }| j	                  t        ||t        j                  |«      «      }| j	                  t        ||
|	t        j                  «      «       | j                  |	«       | j                  ||t        d|«      t        j                  |«      }| j	                  t        ||«      «       | j	                  t!        |
«      «       | j                  |
«       |S rj  )rH   r�  r;   r¹  r  r(   Úis_same_native_int_signsr*   r,   r£  r%  rŒ  r0   rø  r:   r  r9   )rö   r  rÖ  r×  r,  r­  Údivr€  r{  r|  r~  ÚmulÚmul_eqr�  s                 r÷   r�  z+LowLevelIRBuilder.inline_fixed_width_divideŽ
  sA  € ä�t‹nˆØ�k‰k˜$  S¬%¯)©)°TÓ:ˆØ�‰”˜˜SÓ!Ô"Ø×2Ñ2°4¸¸cÀ4ÓHˆ
Ü)›|¬Z«\¼:»<˜�ˆØ�‰”˜
 D¨&´&·+±+Ó>Ô?Ø×Ñ˜FÔ#Ø�k‰k˜$  S¬%¯)©)°TÓ:ˆØ—‘œ, s¨C´·±À$ÓGÓHˆØ�‰”˜  f¬f¯k©kÓ:Ô;Ø×Ñ˜FÔ#Ø�k‰k˜$ ¤W¨Q°Ó%5´u·y±yÀ$ÓGˆØ�‰”˜˜SÓ!Ô"Ø�‰”�d“ÔØ×Ñ˜DÔ!Øˆ
rù   c           	     ó(  — t        |«      }| j                  |||t        j                  |«      }| j	                  t        ||«      «       | j                  ||||«      }t        «       t        «       t        «       }
}	}| j	                  t        ||
|t        j                  «      «       | j                  |«       | j	                  t        |t        d|«      t        j                  |«      «      }| j	                  t        ||
|	t        j                  «      «       | j                  |	«       | j                  |||t        j                  |«      }| j	                  t        ||«      «       | j	                  t        |
«      «       | j                  |
«       |S r  )rH   r�  r;   rr  r  r(   r”  r*   r,   r£  r%  r0   r:   rø  r…  r9   )rö   r  rÖ  r×  r,  r­  rz  r€  r{  r|  r~  r  r�  s                r÷   r‘  z(LowLevelIRBuilder.inline_fixed_width_mod¡
  s(  € ä�t‹nˆØ�k‰k˜$  S¬%¯)©)°TÓ:ˆØ�‰”˜˜SÓ!Ô"Ø×2Ñ2°4¸¸cÀ4ÓHˆ
Ü)›|¬Z«\¼:»<˜�ˆØ�‰”˜
 D¨&´&·+±+Ó>Ô?Ø×Ñ˜FÔ#Ø—(‘(œ<¨¬W°Q¸Ó-=¼|¿¹ÐPTÓUÓVˆØ�‰”˜  v¬v¯{©{Ó;Ô<Ø×Ñ˜FÔ#Ø�k‰k˜$  S¬%¯)©)°TÓ:ˆØ�‰”˜˜SÓ!Ô"Ø�‰”�d“ÔØ×Ñ˜DÔ!Øˆ
rù   c           	     ó,  — | j                  t        |t        d|«      t        j                  |«      «      }| j                  t        |t        d|«      t        j                  |«      «      }| j                  t        ||t        j                  |«      «      S r  )r  r0   r:   r±  rø  )rö   r  ÚaÚbr,  Úneg1Úneg2s          r÷   r”  z*LowLevelIRBuilder.is_same_native_int_signs³
  sl   € Ø�x‰xœ Q¬°°4Ó(8¼,×:JÑ:JÈDÓQÓRˆØ�x‰xœ Q¬°°4Ó(8¼,×:JÑ:JÈDÓQÓRˆØ�x‰xœ T¨4´·±À$ÓGÓHÐHrù   c                ó(  — | j                  t        |t        d«      t        j                  |«      «      }| j                  t        |t        d«      t        j                  |«      «      }| j                  t	        ||t        j
                  |«      «      S )Nr[  )r  r3   r2   ÚLTr0   rø  )rö   rš  r›  r,  rœ  r�  s         r÷   ry  z%LowLevelIRBuilder.is_same_float_signs¸
  sj   € Ø�x‰xÔ)¨!¬U°3«ZÔ9J×9MÑ9MÈtÓTÓUˆØ�x‰xÔ)¨!¬U°3«ZÔ9J×9MÑ9MÈtÓTÓUˆØ�x‰xœ T¨4´·±À$ÓGÓHÐHrù   c                ó<   — | j                  t        ||||«      «      S rõ   )r  r0   rƒ  s        r÷   r»  zLowLevelIRBuilder.comparison_op½
  s   € Ø�x‰xœ S¨#¨r°4Ó8Ó9Ð9rù   c                óž  — |j                   }d}t        |«      st        |«      st        |«      r| j	                  t
        |g|«      }n°t        |«      st        |«      rS| j                  t        |t        d«      «      }| j                  |t        «      }| j                  t        |g|«      «       nGt        |«      r| j                  t         |g|«      }n#t#        |«      r| j                  t$        |g|«      }|�<|r|S t'        dt        |«      }| j)                  t*        ||t,        j.                  |«      S t1        |t2        «      rß|rJ ‚| j5                  |dg t6        |«      }| j9                  |t6        |«      }t;        «       t;        «       }
}	| j=                  |t'        d«      d|«      }| j?                  ||	|
«       | jA                  |
«       | j                  tC        tB        jD                  d|«      «       | j                  tG        «       «       | jA                  |	«       |S t1        |tH        «      rHtK        | |«      }|r|S t'        dt        |«      }| j)                  t*        ||t,        j.                  |«      S | jM                  tN        d   |g|«      }|�|S |r| j                  tP        |g|«      S | j                  tR        |g|«      S )	z�Generate len(val).

        Return short_int_rprimitive by default.
        Return c_pyssize_t if use_pyssize_t is true (unshifted).
        NÚusedrÏ   Ú__len__r   rì   z__len__() should return >= 0zbuiltins.len)*r  rt   r|   rj   rt  r¶   rx   ro   r  r8   rT   r4  rc   r<   rl   r§  r�   rz   rÃ   r:   r�  rƒ   r;   r‘  r  rV   rw  rh   rO  r*   rÇ  r*  r%  rG   ÚVALUE_ERRORrN   r\   rˆ   rÀ  r»   r–   r•   )rö   rÍ  r,  Úuse_pyssize_trú  Ú
size_valueÚelem_addressÚoffsetrê  rv  ÚfailÚcondÚ	len_valueÚcountr  s                  r÷   r9  zLowLevelIRBuilder.builtin_lenÀ
  so  € ð �h‰hˆØˆ
Ü˜cÔ"Ô&9¸#Ô&>ÔBUÐVYÔBZØ×*Ñ*¬?¸S¸EÀ4ÓH‰JÜ˜sÔ#Ô'>¸sÔ'CØŸ8™8¤M°#´{ÀFÓ$KÓLˆLØŸ™ |Ô5KÓLˆJØ�H‰H”Y ˜u dÓ+Õ,Ü Ô$ØŸ™Ô%9¸C¸5À$ÓG‰JÜ˜sÔ#ØŸ™Ô%8¸3¸%ÀÓFˆJàÐ!ÙØ!Ð!Ü˜QÔ 6¸Ó=ˆFØ—;‘;Ô3°ZÀÌ×IYÑIYÐ[_Ó`Ð`ä�cœ9Ô%á$Ð$Ð$Ø×)Ñ)¨#¨y¸"¼nÈdÓSˆFØ—[‘[ ¬¸Ó>ˆFÜ!“|¤Z£\�ˆBØ—>‘> &¬'°!«*°d¸DÓAˆDØ× Ñ   r¨4Ô0Ø×Ñ Ô%Ø�H‰HÜ"Ü&×2Ñ2Ð4RÐTXóôð
 �H‰H”[“]Ô#Ø×Ñ Ô#ØˆMä˜œTÔ"Ü& t¨SÓ1ˆIÙØ Ð Ü˜AÔ5°tÓ<ˆEØ—;‘;Ô3°YÀÄu×GWÑGWÐY]Ó^Ð^à×'Ñ'¬°^Ñ(DÀsÀeÈTÓRˆØˆ>ØˆIñ Ø—;‘;Ô5¸°u¸dÓCÐCà—;‘;œ~°¨u°dÓ;Ð;rù   c                óœ   — |r4t        t        |«      t        «      }| j                  t        |g|z   |«      S | j                  t
        g |«      S rõ   )r:   r”  rc   r§  rÇ   rÆ   )rö   r—  r,  r�  s       r÷   r  zLowLevelIRBuilder.new_tupleü
  sC   € ÙÜ!¤# e£*Ô.DÓEˆDØ—;‘;œ|¨d¨V°e©^¸TÓBÐBà—;‘;Ô;¸RÀÓFÐFrù   c                ó2   — | j                  t        |g|«      S )aÌ  This function returns an uninitialized tuple.

        If the length is non-zero, the caller must initialize the tuple, before
        it can be made visible to user code -- otherwise the tuple object is broken.
        You might need further initialization with `new_tuple_set_item_op` op.

        Args:
            length: desired length of the new tuple. The rtype should be
                    c_pyssize_t_rprimitive
            line: line number
        )r§  rÈ   r  s      r÷   Únew_tuple_with_lengthz'LowLevelIRBuilder.new_tuple_with_length  s   € ð �{‰{Ô3°f°X¸tÓDÐDrù   c                ó2   — | j                  t        |g|«      S rõ   )rt  r”   )rö   rZ  r,  s      r÷   r“  zLowLevelIRBuilder.int_to_float  s   € Ø× Ñ ¤°1°#°tÓ<Ð<rù   c                ój   — t         r-t        j                  dk\  r| j                  t        |g|«       yyy)zFMake an object immortal on free-threaded builds (to avoid contention).)é   é   N)r   ÚsysÚversion_infort  rµ   )rö   r�  r,  s      r÷   Úset_immortal_if_free_threadedz/LowLevelIRBuilder.set_immortal_if_free_threaded  s.   € å¤× 0Ñ 0°GÒ ;Ø×Ñœo°¨s°DÕ9ð !<Ðrù   c                óˆ  — g }g }|j                   D ]5  }t        |t        «      r|j                  |«       Œ%|j                  |«       Œ7 t	        «       }	t        ||¬«      }
t        |«      D ]à  \  }}|t        |«      dz
  k  xs |}|rU| j                  ||j                  |«      }t	        «       t	        «       }}| j                  |||«       | j                  |«       | j                  |||«      } ||«      }| j                  |||«      }| j                  t        |
||«      «       | j                  |	«       |sŒÐ| j                  «       Œâ |ra| j                  |t         |d¬«      } ||«      }| j                  |||«      }| j                  t        |
||«      «       | j                  |	«       | j                  |	«       |
S )al  Generate isinstance() + specialized operations for union items.

        Say, for Union[A, B] generate ops resembling this (pseudocode):

            if isinstance(obj, A):
                result = <result of process_item(cast(A, obj)>
            else:
                result = <result of process_item(cast(B, obj)>

        Args:
            obj: value with a union type
            rtype: the union type
            result_type: result of the operation
            process_item: callback to generate op for a single union item (arg is coerced
                to union item type)
            line: line number
        r7  rÏ   T)r™  )r—  r  rV   r  r*   rH   Ú	enumerater”  ræ  rÔ  r*  r%  rO  r  r(   r   r€   )rö   rÙ  r@  rÛ  Úprocess_itemr,  Ú
fast_itemsÚ
rest_itemsrž  Ú
exit_blockr/  rœ  Ú
more_typesr  Ú
true_blockÚfalse_blockrÐ  ÚtempÚtemp2s                      r÷   rá  z(LowLevelIRBuilder.decompose_union_helper  s¤  € ð6 ˆ
Øˆ
Ø—K‘Kò 	(ˆDÜ˜$¤	Ô*Ø×!Ñ! $Õ'ð ×!Ñ! $Õ'ð	(ô  “\ˆ
Ü˜+¨DÔ1ˆÜ  Ó,ò 	1‰GˆAˆtØœS ›_¨qÑ0Ñ0Ò>°JˆJÙà×+Ñ+¨C°·±ÀÓE�Ü*4«,¼
»˜K�
Ø×$Ñ$ R¨°[ÔAØ×#Ñ# JÔ/Ø—k‘k # t¨TÓ2ˆGÙ Ó(ˆDØ—K‘K  k°4Ó8ˆEØ�H‰H”V˜F E¨4Ó0Ô1Ø�I‰I�jÔ!ÚØ×#Ñ# KÕ0ð	1ñ ð —k‘k #Ô'8¸$Àd�kÓKˆGÙ Ó(ˆDØ—K‘K  k°4Ó8ˆEØ�H‰H”V˜F E¨4Ó0Ô1Ø�I‰I�jÔ!Ø×Ñ˜JÔ'Øˆrù   c                óš   — | j                  ||||||«      }|�|S t        j                  |g «      }| j                  ||g|z   |||¬«      }	|	S )ar  Translate a method call which is handled nongenerically.

        These are special in the sense that we have code generated specifically for them.
        They tend to be method calls which have equivalents in C that are more direct
        than calling with the PyObject api.

        Return None if no translation found; otherwise return the target register.
        r�  )Ú(_translate_special_low_level_method_callr½   rE  rÀ  )
rö   Úbase_regr?  r  rÛ  r,  r|  Úlow_level_oprÆ  rt  s
             r÷   r
  z/LowLevelIRBuilder.translate_special_method_callZ  sr   € ð" ×DÑDØ�d˜D +¨t°Zó
ˆð Ð#ØÐÜ#2×#6Ñ#6°t¸RÓ#@Ð Ø×1Ñ1Ø$ x j°4Ñ&7¸¸{ÐWað 2ó 
ˆð Ðrù   c                ó0  — |dk(  r‘t        |«      dk(  rƒ|d   }t        |j                  t        «      rdt	        |j                  «      st        |j                  «      r:t        |j                  «      r| j                  |t        |«      }t        | |||«      S y )Nr  rÏ   r   )	r”  r  r  r\   rr   r{   rO  rg   r‡   )rö   rÄ  r?  r  rÛ  r,  r|  r>  s           r÷   rÃ  z:LowLevelIRBuilder._translate_special_low_level_method_callv  sw   € ð �=Ò ¤S¨£Y°!¢^Ø�q‘'ˆCÜ˜(Ÿ-™-¬Ô.Ü# C§H¡HÔ-´¸3¿8¹8Ô1Dä˜SŸX™XÔ&ØŸ+™+ cÔ+;¸TÓB�CÜ# D¨(°C¸Ó>Ð>Ørù   c                ób  — |j                   }|j                   }t        |«      rt        |«      r| j                  ||||«      S t        |«      rt        |«      r| j	                  ||||«      S t        |«      }t        |«      }d}	|�A|�t        ||«      r| j                  |«      rd}	t        ||«      r5| j                  |«      r$d}	n!|�t        ||«      r| j                  |«      rd}	|	r| j                  ||||«      S t        |t        «      r||k(  sy|j                  }
|
j                  d«       xs. |
j                  d«       xs |
j                  xs |
j                  }|ry|
j                  d«      s|dk(  rdnd}| j!                  ||||«      S | j#                  |t$        |   |g||«      S )	z Add an equality comparison operation.

        Note that this doesn't cover all possible types.

        Args:
            expr_op: either '==' or '!='
        FNTÚ__eq__Ú__ne__rë   r¬  r­  )r  rz   rÕ  rj   rç  r�   rÌ   Ú_never_equal_to_noneÚ_translate_fast_optional_eq_cmpr  rV   rÔ  r:  Úinherits_pythonÚis_augmentedro  r³  rw  r   )rö   rÁ  rÂ  Úexpr_opr,  rÃ  r@  ÚloptÚroptÚfast_opt_eqrÔ  Úcmp_varies_at_runtimeÚidentity_ref_ops                r÷   r²  z"LowLevelIRBuilder.translate_eq_cmp‰  sÃ  € ð —	‘	ˆØ—	‘	ˆä˜UÔ#Ô(9¸%Ô(@Ø×'Ñ'¨¨d°G¸TÓBÐBÜ˜uÔ%Ô*=¸eÔ*DØ×%Ñ% d¨D°'¸4Ó@Ð@ä" 5Ó)ˆÜ" 5Ó)ˆð ˆØÐØÐ¤L°°tÔ$<À×AZÑAZÐ[_ÔA`Ø"�Ü˜D %Ô(¨T×-FÑ-FÀtÔ-LØ"‘ØÐÜ˜D %Ô(¨T×-FÑ-FÀtÔ-LØ"�ÙØ×7Ñ7¸¸dÀGÈTÓRÐRä˜5¤)Ô,°¸%²Øà—>‘>ˆð
 ×(Ñ(¨Ó2Ð2ò %Ø×+Ñ+¨HÓ5Ð5ò%à×'Ñ'ò%ð ×$Ñ$ð	 	ñ !ð à×"Ñ" 8Ô,à&-°¢o™d¸8ˆOØ×'Ñ'¨¨d°OÀTÓJÐJà×#Ñ# D¬*°WÑ*=À¸vÀuÈdÓSÐSrù   c                ó2   — t        |«      xs t        |«      S )z+Are the values of type never equal to None?)rz   rj   )rö   rú  s     r÷   rÊ  z&LowLevelIRBuilder._never_equal_to_noneÃ  s   € ô ! Ó%ÒAÔ)<¸SÓ)AÐArù   c           
     ó,  — t        |j                  t        «      s||}}t        |j                  «      }|sJ ‚t	        t
        |¬«      }| j                  t        || j                  «       t        j                  |«      «      }t        «       }t        «       }	t        «       }
| j                  t        |||	t        j                  «      «       | j                  |«       t        |j                  t        «      sB|dk(  r| j                  «       n| j                  «       }| j                  t!        |||«      «       nl|dk(  rt        j                  nt        j"                  }| j                  t        || j                  «       ||«      «      }| j                  t!        |||«      «       | j%                  |
«       | j                  |	«       t        |j                  t        «      sJ| j'                  | j)                  |||dd¬«      |||«      }|€J ‚| j                  t!        |||«      «       �nHt        «       }t        «       }| j                  t        || j                  «       t        j                  |«      «      }| j                  t        |||t        j                  «      «       | j                  |«       |dk(  r| j                  «       n| j                  «       }| j                  t!        |||«      «       | j%                  |
«       | j                  |«       | j'                  | j)                  |||dd¬«      | j)                  |||dd¬«      ||«      }|€J ‚| j                  t!        |||«      «       | j%                  |
«       | j                  |
«       |S )z}Generate eq/ne fast path between 'X | None' and ('X | None' or X).

        Assume 'X' never compares equal to None.
        r7  rë   Tr{  )r  r  r[   r�   rH   r_   r  r0   r…  rø  r*   r,   r£  r%  rï  r  r(   rÌ  r   r²  r€  )rö   rÁ  rÂ  rÎ  r,  r  r­  r  Úl_noneÚ
l_not_nonerÏ  rÍ  r  rÛ  Úr_noneÚ
r_not_nones                   r÷   rË  z1LowLevelIRBuilder._translate_fast_optional_eq_cmpÈ  sÖ  € ô ˜$Ÿ)™)¤VÔ,Ø˜t�$ˆDÜ'¨¯	©	Ó2ˆ	ÙÐˆyÜ”¨TÔ2ˆð �h‰h”| D¨$×*:Ñ*:Ó*<¼l¿o¹oÈtÓTÓUˆÜ“ˆÜ“\ˆ
Ü‹lˆØ�‰”˜˜V Z´·±Ó=Ô>Ø×Ñ˜FÔ#Ü˜$Ÿ)™)¤VÔ,Ø")¨T¢/�$—*‘*”,°t·y±y³{ˆCØ�H‰H”V˜C  dÓ+Õ,à$+¨t¢O”—’¼×9IÑ9IˆBØ—(‘(œ<¨¨d×.>Ñ.>Ó.@À"ÀdÓKÓLˆCØ�H‰H”V˜C  dÓ+Ô,Ø�	‰	�#Œà×Ñ˜JÔ'Ü˜$Ÿ)™)¤VÔ,à×&Ñ&Ø×"Ñ" 4¨°DÀTÐUYÐ"ÓZØØØó	ˆBð �>Ð!�>Ø�H‰H”V˜C  TÓ*Ö+ä“\ˆFÜ#›ˆJà—(‘(œ<¨¨d×.>Ñ.>Ó.@Ä,Ç/Á/ÐSWÓXÓYˆCØ�H‰H”V˜C ¨´V·[±[ÓAÔBØ×Ñ Ô'à")¨T¢/�$—*‘*”,°t·y±y³{ˆCØ�H‰H”V˜C  dÓ+Ô,Ø�I‰I�cŒNØ×Ñ 
Ô+à×&Ñ&Ø×"Ñ" 4¨°DÀTÐUYÐ"ÓZØ×"Ñ" 4¨°DÀTÐUYÐ"ÓZØØó	ˆBð �>Ð!�>Ø�H‰H”V˜C  TÓ*Ô+Ø�	‰	�#ŒØ×Ñ˜CÔ Øˆ
rù   c                óâ   — |dk(  rt         j                  nt         j                  }| j                  |t        |«      }| j                  |t        |«      }| j                  t        ||||«      «      S )zƒCreate equality comparison operation between object identities

        Args:
            expr_op: either 'is' or 'is not'
        r¬  )r0   rø  rÌ  rO  r€   r  )rö   rÁ  rÂ  rÎ  r,  r  rÖ  r×  s           r÷   r³  z!LowLevelIRBuilder.translate_is_op	  s[   € ð !(¨4¢Œ\�_Š_´\×5EÑ5EˆØ�k‰k˜$Ô 1°4Ó8ˆØ�k‰k˜$Ô 1°4Ó8ˆØ�x‰xœ S¨#¨r°4Ó8Ó9Ð9rù   c                ó  — t        |«      }|dkD  rVt        |t        «      }t        t	        ||«      «      D ��cg c]  }|D ]  }|‘Œ Œ }}}| j                  t        |g|z   |«      S | j                  t        g |«      S c c}}w )z9Create a dictionary(possibly empty) using keys and valuesr   )r”  r:   rc   r*  r˜  r§  r‹   rŽ   )	rö   r  r+  r,  r�  r¦  rŸ  rœ  r—  s	            r÷   r  zLowLevelIRBuilder._create_dict  s   € ô �4‹yˆØ�!Š8Ü '¨Ô.DÓ EˆJä $¤S¨¨vÓ%6Ó 7×C˜1ÀÒC¸A’QÐC�QÐCˆEÑCØ—;‘;œ}¨z¨l¸UÑ.BÀDÓIÐIà—;‘;œ{¨B°Ó5Ð5ùó Ds   ¹A>c               óF   — t        | ||||¬«      }|j                  «        |S )aQ  Generate for loop over a pointer or native int range.

        Roughly corresponds to "for i in range(start, end, step): ....". Only
        positive values for step are supported.

        The loop index register is generated automatically and is available
        via the return value. Do not modify it!

        Example usage that clears a memory area:

          for_loop = builder.begin_for(start_ptr, end_ptr, int32_rprimitive.size)

          # For loop body
          builder.set_mem(for_loop.index, int32_rprimitive, Integer(0, int32_rprimitive))

          for_loop.finish()
        r„  )Ú
ForBuilderÚbegin)rö   Ústartr«  Ústepr…  r›  s         r÷   Ú	begin_forzLowLevelIRBuilder.begin_for"  s$   € ô$ �t˜U C¨°fÔ=ˆØ	�‰Œ	Øˆrù   c                óx   — | j                   €J d«       ‚| j                   j                  || j                  |«       y )Nz-cannot generate errors in this compiler phase)r  rˆ  r  )rö   rw  r,  s      r÷   rˆ  zLowLevelIRBuilder.error8  s4   € Ø�{‰{Ð&ÐWÐ(WÓWÐ&Ø�‰×Ñ˜#˜t×/Ñ/°Õ6rù   )r  zErrors | Noner  r‰   rû   rü   )r  rr  r  rr  rû   rü   )r  rD   rû   rO   )r  rH   r  úValue | intrû   rü   )r  r*   rû   rü   )r$  r*   rû   rü   )r+  úlist[Value]r,  rú   r)  Úboolrû   rü   )r2  rO   r3  rZ   r/  rå  rû   rO   )r2  rO   r3  rZ   rñ   rO   rû   rü   )r:  rO   r;  rr  rû   rO   )r  )r?  rr  r@  rZ   r,  rú   rû   rO   )r?  rr  r,  rú   rû   úValue | None)
r2  rO   rK  rX   r;  rr  r/  rå  rû   rO   )r2  rO   rK  rX   r;  rr  rñ   rO   r,  rú   rû   rü   )rR  úBasicBlock | Nonerû   rü   )rû   rç  )rû   rH   )r,  rú   rò   rú   rû   rü   )rû   rú   )r,  rú   rd  rú   rû   rü   )r,  rú   rû   zIterator[None])rñ   rO   rò   rú   rû   rü   )rñ   rO   ro  rú   rû   rü   )ru  zstr | Valuerû   rü   )rn  rO   rû   rO   )rn  rO   r  rZ   r,  rú   r|  rå  r}  rå  rû   rO   )F)rn  rO   r  rZ   r,  rú   r™  rå  r|  rå  rû   rO   )rn  rO   r  rZ   r,  rú   rû   rO   )
rn  rO   r  rW   r³  r*   r,  rú   rû   rü   )rn  rO   r  rZ   r¼  rú   r³  r*   r½  r*   r,  rú   rû   rH   )r  rZ   r,  rú   rû   rü   )rn  rO   r,  rú   rû   rO   )rÙ  rO   rÚ  rr  rÛ  rZ   r,  rú   r/  rå  ro  rú   rû   rO   )rÙ  rO   r@  r[   rÚ  rr  rÛ  rZ   r,  rú   rû   rO   )rÙ  rO   rÚ  rr  r,  rú   rû   rO   )rÙ  rO   rñ  zlist[ClassIR]r,  rú   rû   rO   )rÙ  rO   r,  rú   rû   rO   )rÙ  rO   rù  rO   r,  rú   rû   rO   )rÙ  rO   rÔ  r   r,  rú   rû   rO   )
r  z+Sequence[tuple[Value, ArgKind, str | None]]r,  rú   r  rå  r  rå  rû   z!tuple[Value | None, Value | None])NN)r+  rO   r,  rä  r,  rú   r-  úlist[ArgKind] | Noner.  úSequence[str | None] | Nonerû   rO   )r+  rO   r,  rä  r,  rú   r-  rè  r.  ré  rû   ræ  )r.  ré  rû   rO   )rÙ  rO   rJ  rr  r,  rä  r,  rú   r-  rè  r.  ré  rû   rO   )rÙ  rO   rJ  rr  r,  rä  r,  rú   r-  rè  r.  ré  rû   ræ  )rU  r!   r  úSequence[Value]r-  úlist[ArgKind]r.  úSequence[str | None]r,  rú   rQ  úlist[Register] | Nonerû   rO   )r  rê  r-  rë  r.  rì  rT  r"   r,  rú   rQ  rí  rû   rä  )NNF)rt  rO   r?  rr  r,  rä  rÛ  úRType | Noner,  rú   r-  rè  r.  úlist[str | None] | Noner|  rå  rû   rO   )rt  rO   r|  r[   r?  rr  r,  rä  rz  rî  r,  rú   r-  rè  r.  rï  rû   rO   )r,  rú   rû   rO   )rñ   rú   r,  rú   rû   rO   )rñ   r’  r,  rú   rû   rO   )rñ   rr  r,  rú   rû   rO   )rñ   Úbytesr,  rú   rû   rO   )rñ   Úcomplexr,  rú   rû   rO   )rú  rZ   r›  rr  r  ú
str | Nonerœ  rr  r,  rú   r�  rò  rû   rO   )r?  rr  rû   rO   )r¦  r   rû   rO   )r§  rr  rû   rO   )
rÁ  rO   rÂ  rO   r  rr  r,  rú   rû   rO   )
rÁ  rO   rÂ  ræ  r  rr  r,  rú   rû   ræ  )rÍ  rO   r,  rú   rÎ  rå  rû   rO   )
rÖ  rO   r×  rO   r  rr  r,  rú   rû   rO   )
r÷  rO   rž  rO   r  rr  r,  rú   rû   rO   )rñ   rO   r  rr  r,  rú   rû   rO   )rñ   rO   r,  rú   rÿ  rå  rû   rO   )rñ   rO   r,  rú   rû   rO   )rt  rO   rž  rO   rÛ  rî  r,  rú   r|  rå  rû   rO   )r  zSequence[DictEntry]r,  rú   rû   rO   )rê  rO   r,  rú   rû   rO   )r+  rä  r,  rú   rû   rO   )
r&  rZ   r+  rê  r,  rú   r:  rå  rû   rO   )r  rr  r+  rZ   r,  úCallable[[], Value]r-  ró  r,  rú   rû   rO   rà  )rñ   rO   r  r*   rï  r*   rû   rü   rõ   )
rP  r¸   r  rä  r,  rú   rÛ  rî  rû   rO   )NF)r^  zlist[CFunctionDescription]r  rä  r,  rú   rÛ  rî  r|  rå  rû   ræ  )rP  rE   r  rä  r,  rú   rÛ  rî  rb  zlist[RType] | Nonerû   rO   )r^  zlist[PrimitiveDescription]r  rä  r,  rú   rÛ  rî  r|  rå  rg  rå  rû   ræ  )r  rZ   rÖ  rO   r×  rO   r  rú   r,  rú   rû   rO   )rÖ  rO   r×  rO   r,  rú   rû   rO   )
rÖ  rO   r×  rO   r  rú   r,  rú   rû   rO   )rÖ  rO   r×  rã  rû   rO   )r  rW   rÖ  rO   r×  rO   r  rú   r,  rú   rû   rO   )r×  rO   r  rZ   r,  rú   rû   rü   )
r  rZ   rÖ  rO   r×  rO   r,  rú   rû   rO   )
r  rZ   rš  rO   r›  rO   r,  rú   rû   rO   )rš  rO   r›  rO   r,  rú   rû   rO   )rÍ  rO   r,  rú   r¥  rå  rû   rO   )r—  rä  r,  rú   rû   rO   )rZ  rO   r,  rú   rû   rO   )r�  rO   r,  rú   rû   rü   )rÙ  rO   r@  r[   rÛ  rZ   r¹  zCallable[[Value], Value]r,  rú   rû   rO   )rÄ  rO   r?  rr  r  rä  rÛ  rî  r,  rú   r|  rå  rû   ræ  )
rÁ  rO   rÂ  rO   rÎ  rr  r,  rú   rû   ræ  )rú  rZ   rû   rå  )
rÁ  rO   rÂ  rO   rÎ  rr  r,  rú   rû   rO   )r  rä  r+  rä  r,  rú   rû   rO   )
rß  rO   r«  rO   rà  rO   r…  rå  rû   rÝ  )rw  rr  r,  rú   rû   rü   )…rý   rþ   rÿ   Ú__doc__rø   r  r  r  r   r%  r'  r-  r4  r8  r<  rA  rC  rH  rM  rP  rS  rW  rö   r   r`  rb  rf  r   rh  rk  rp  rv  rz  r€  rO  r‰  rº  r¤  r¨  r‹  rŠ  r�  rÑ  rÜ  r×  rØ  rò  rö  rû  ræ  r   r2  r(  r=  rM  rI  rV  rS  rw  rs  r  r  rï  r…  r‰  rŒ  r�  r‘  rs  r”  r–  r&   r   r¢  rþ  r¥  rÇ  r¿  r¢  rÕ  rç  r±  r·  r¶  rµ  rþ  r  r  r  r  r  r  r  r  r®   r¿   r;  rð  r  r*  r§  r`  rt  rÀ  r�  r¾  rt  r¼  r‡  rŠ  r�  rº  r�  r�  r‘  r”  ry  r»  r9  r  r¯  r“  r¶  rá  r
  rÃ  r²  rÊ  rË  r³  r  rá  rˆ  r  rù   r÷   r  r    sÊ
  „ ñó %ó'óó)ó
#ó
"ó#ð
 KPõ 7ð INõ Aó:ó0ô8ó7óð JOñOØðOØ")ðOØ25ðOØBFðOà	óOð%Øð%Ø")ð%Ø25ð%Ø>Cð%ØKNð%à	ó%ó,ó)óð <Rõ ]ó(ó[ð ò	7ó ð	7ó&ó5ó9óð !Øñbàðbð ðbð ð	bð ðbð ðbð 
óbð* ðið !ñiàðið ðið ð	ið
 ðið ðið 
óióV4ðl''Øð''Ø'1ð''ØCMð''ØUXð''à	ó''ðR1àð1ð ð1ð ð	1ð
 #ð1ð "ð1ð ð1ð 
ó1óf
 óó66ópó4ðD Ø2ñ5àð5ð ð5ð ð	5ð
 ð5ð ð5ð ð5ð 
ó5ðBYØðYØ!'ðYØ/2ðYØAFðYØNQðYà	óYóBóóóLóð6i)à9ði)ð ði)ð
 ði)ð ði)ð 
+ói)ð` +/Ø15ðcàðcð  ðcð ð	cð
 (ðcð /ðcð 
ócðL +/Ø15ð$àð$ð  ð$ð ð	$ð
 (ð$ð /ð$ð 
ó$óL	-ðdàðdð ðdð  ð	dð
 ðdð (ðdð /ðdð 
ódð2'àð'ð ð'ð  ð	'ð
 ð'ð (ð'ð /ð'ð 
ó'ðb .2ñ0àð0ð ð0ð !ð	0ð
 (ð0ð ð0ð +ð0ð 
ó0ð< .2ñ\àð\ð !ð\ð (ð	\ð
 ð\ð ð\ð +ð\ð 
ó\ðJ +/Ø-1Ø ð;Wàð;Wð ð;Wð  ð	;Wð
 "ð;Wð ð;Wð (ð;Wð +ð;Wð ð;Wð 
ó;Wðz`àð`ð ð`ð ð	`ð
  ð`ð #ð`ð ð`ð (ð`ð +ð`ð 
ó`ô21ô1ô1ôTôHôIô-ô"ôBôDôEð #'Ø)ØØ $ðàðð ðð  ð	ð
 ðð ðð ðð 
óó(Yó6ó
Uósój VôD
ó:cóxcô
0ódó	Hó;óð INõ GBóR@ó
@ó@ó
Cð& !ñ
àð
ð ð
ð "ð	
ð
 ð
ð ð
ð 
ó
ó(ó68óó*;ð [`ñ
Øð
Ø(7ð
Ø?Bð
ØSWð
à	ó
ð"àð"ð ð"ð "ð	"ð
 #ð"ð ð"ð 
ó"óHAóF=ð@ %)ðLà"ðLð ðLð ð	Lð
 "ðLð 
óLðf %)Ø ðà.ðð ðð ð	ð
 "ðð ðð 
óðB %)Ø(,ðXà"ðXð ðXð ð	Xð
 "ðXð &ðXð 
óXð~ %)ð)ð !Øñ)à.ð)ð ð)ð ð	)ð
 "ð)ð ð)ð ð)ð 
ó)ôV
9ó<ó:ó0?óDóDóDð55Øð55Ø%*ð55Ø16ð55Ø<?ð55ØGJð55à	ó55ón óó&ó$Ió
Ió
:ô:<óxGóEó=ó:ð=àð=ð ð=ð ð	=ð
 /ð=ð ð=ð 
ó=ðL !ðàðð ðð ð	ð
 "ðð ðð ðð 
óðF !ðàðð ðð ð	ð
 "ðð ðð ðð 
óó&8TótBð
?Øð?Ø!&ð?Ø14ð?Ø<?ð?à	ó?óB	:ó
6óô,7rù   r  c                óP   — |€t        | «      S d}|D ]  }|t        k(  sŒ|dz  }Œ |S )Nr   rÏ   )r”  r   )r,  r-  rA  r  s       r÷   r<  r<  =  s=   € ØÐÜ�:‹ÐØ€GØò ˆØ”7‹?Ø�q‰L‰Gðð €Nrù   c                  ó@   — e Zd ZdZ	 	 	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zdd„Zy)rÝ  zBuilder for simple for loops.c               óØ   — || _         || _        || _        || _        || _        t        |j                  «      | _        t        «       | _	        t        «       | _
        t        «       | _        y rõ   )Úbuilderrß  r«  rà  r…  rH   r  Úindexr*   ÚtopÚbodyÚ	loop_exit)rö   rø  rß  r«  rà  r…  s         r÷   rø   zForBuilder.__init__J  sR   € ð ˆŒØˆŒ
ØˆŒØˆŒ	ØˆŒÜ˜eŸj™jÓ)ˆŒ
Ü“<ˆŒÜ“LˆŒ	Ü#›ˆ�rù   c                ó  — | j                   }|j                  | j                  | j                  «       |j	                  | j
                  «       | j                  rt        j                  nt        j                  }t        | j                  | j                  |d¬«      }|j                  |«       |j                  t        || j                  | j                  t        j                  «      «       |j	                  | j                  «       y r6  )rø  r  rù  rß  r'  rú  r…  r0   r±  ÚULTr«  r  r,   rû  rü  r£  )rö   rø  r  rT  s       r÷   rÞ  zForBuilder.beginW  s¥   € Ø—,‘,ˆØ�‰�t—z‘z 4§:¡:Ô.Ø×!Ñ! $§(¡(Ô+Ø!%§¢Œ\×Ò´,×2BÑ2BˆÜ˜DŸJ™J¨¯©°"¸2Ô>ˆØ�‰�DÔØ�‰”F˜4 §¡¨D¯N©N¼F¿K¹KÓHÔIØ×!Ñ! $§)¡)Õ,rù   c                ó  — | j                   }|j                  | j                  |j                  | j                  | j                  «      «       |j                  | j                  «       |j                  | j                  «       y rõ   )	rø  r  rù  r‡  rà  r   rú  r%  rü  )rö   rø  s     r÷   ÚfinishzForBuilder.finisha  sR   € Ø—,‘,ˆØ�‰�t—z‘z 7§?¡?°4·:±:¸t¿y¹yÓ#IÔJØ�‰�T—X‘XÔØ×Ñ˜tŸ~™~Õ.rù   N)rø  r  rß  rO   r«  rO   rà  rO   r…  rå  rû   rü   )rû   rü   )rý   rþ   rÿ   rô  rø   rÞ  r   r  rù   r÷   rÝ  rÝ  G  sD   „ Ù'ð&Ø(ð&Ø16ð&Ø=Bð&ØJOð&Ø\`ð&à	ó&ó-ô/rù   rÝ  )r,  rä  r-  rè  rû   rú   )ùrô  Ú
__future__r   r´  Úcollections.abcr   r   r   Ú
contextlibr   Útypingr   r	   r
   Úmypy.argmapr   Ú
mypy.nodesr   r   r   r   Úmypy.operatorsr   r   Ú
mypy.typesr   r   Úmypyc.commonr   r   r   r   r   r   r   r   r   r   Úmypyc.errorsr   Úmypyc.ir.class_irr   r    Úmypyc.ir.func_irr!   r"   Úmypyc.ir.opsr#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   Úmypyc.ir.rtypesrS   rT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   rl   rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   Úmypyc.irbuild.utilr…   Úmypyc.irbuild.vecr†   r‡   rˆ   Úmypyc.optionsr‰   Úmypyc.primitives.bytes_opsrŠ   Úmypyc.primitives.dict_opsr‹   rŒ   r�   rŽ   r�   r�   Úmypyc.primitives.exc_opsr‘   r’   Úmypyc.primitives.float_opsr“   r”   Úmypyc.primitives.generic_opsr•   r–   r—   r˜   r™   rš   r›   rœ   r�   Úmypyc.primitives.int_opsrž   rŸ   r    r¡   r¢   r£   r¤   r¥   r¦   r§   r¨   r©   rª   Úmypyc.primitives.list_opsr«   r¬   r­   r®   Úmypyc.primitives.misc_opsr¯   r°   r±   r²   r³   r´   rµ   r¶   Úmypyc.primitives.registryr·   r¸   r¹   rº   r»   r¼   r½   r¾   Úmypyc.primitives.set_opsr¿   Úmypyc.primitives.str_opsrÀ   rÁ   rÂ   rÃ   rÄ   Úmypyc.primitives.tuple_opsrÅ   rÆ   rÇ   rÈ   rÉ   Úmypyc.rt_expandtyperÊ   Úmypyc.rt_subtyperË   Úmypyc.sametyperÌ   Úmypyc.subtyperÍ   rD  Ú	DictEntryr!  rÑ   Ú__annotations__ræ   rí   rï   r  r<  rÝ  r  rù   r÷   ú<module>r$     sÝ  ðòõ #ã 
ß 8Ñ 8Ý %ß )Ñ )å .ß <Ó <ß 7ß )÷÷ ÷ õ  ß ;ß 4÷1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1÷ 1ó 1÷d3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3÷ 3õh 1ß HÑ HÝ )Ý 4÷÷ ÷ Jß C÷
÷ 
õ 
÷÷ ÷ õ ÷ ]Ó \÷	÷ 	ó 	÷	÷ 	ó 	õ 0÷õ ÷õ õ -Ý /Ý 'Ý $à�%˜$‘, Ð%Ñ&€	ð %'Ð !ð )*¨m¸aÑ.?À!Ñ.CÑ(DÐ  Ó Dò%Ð ˜Eó ò0 ]€�Ó \÷ñ ÷r,7ñ r,7ójY÷/ò /rù   