Ë
    pPêj²õ  ã            	      ó˜  — U d Z ddlmZ ddlZddlmZ ddlmZ ddl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mZ dd	lmZ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'm(Z( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJ ddlKmLZLmMZM ddlNmOZO ddlPmQZQ dZRdeSd<   e$ee%ee#ee&eiZTdeSd<   dddddddddœZUdeSd<    G d„ d«      ZV G d „ d!«      ZW G d"„ d#«      ZX G d$„ d%eX«      ZY G d&„ d'eX«      ZZ G d(„ d)eX«      Z[ G d*„ d+eX«      Z\ G d,„ d-«      Z]dd.œd2d/„Z^d3d0„Z_d4d1„Z`y)5zUtilities for emitting C code.é    )ÚannotationsN)ÚCallable)ÚFinal)Úc_string_initializer)ÚLiteralsÚliteral_sort_key)ÚATTR_PREFIXÚBITMAP_BITSÚFAST_ISINSTANCE_MAX_SUBCLASSESÚHAVE_IMMORTALÚMODULE_PREFIXÚNATIVE_PREFIXÚPREFIXÚ
REG_PREFIXÚSTATIC_PREFIXÚTYPE_PREFIXÚTYPE_VAR_PREFIX)ÚClassIRÚall_concrete_classes)ÚFUNC_CLASSMETHODÚFUNC_STATICMETHODÚFuncDeclÚFuncIRÚget_text_signature)ÚNAMESPACE_MODULEÚNAMESPACE_STATICÚNAMESPACE_TYPEÚNAMESPACE_TYPE_VARÚ
BasicBlockÚValue)!Ú	RInstanceÚ
RPrimitiveÚRTupleÚRTypeÚRUnionÚRVecÚint_rprimitiveÚis_bool_or_bit_rprimitiveÚis_bytearray_rprimitiveÚis_bytes_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_native_rprimitiveÚis_none_rprimitiveÚis_object_rprimitiveÚis_optional_typeÚis_range_rprimitiveÚis_set_rprimitiveÚis_short_int_rprimitiveÚis_str_rprimitiveÚis_tuple_rprimitiveÚis_uint8_rprimitiveÚobject_rprimitiveÚoptional_value_typeÚvec_api_by_item_typeÚvec_item_type_tags)ÚNameGeneratorÚexported_name)Úbuiltin_names)Úis_same_typeFr   ÚDEBUG_ERRORSÚ
PREFIX_MAPÚVEC_I64ÚVEC_I32ÚVEC_I16ÚVEC_U8Ú	VEC_FLOATÚVEC_BOOLÚVEC_TÚ
VEC_NESTED)ÚVecI64ÚVecI32ÚVecI16ÚVecU8ÚVecFloatÚVecBoolÚVecTÚ	VecNestedÚVEC_MACRO_PREFIXc                  ó<   — e Zd ZdZ	 dddddœ	 	 	 	 	 	 	 	 	 	 	 dd„Zy)ÚHeaderDeclarationan  A representation of a declaration in C.

    This is used to generate declarations in header files and
    (optionally) definitions in source files.

    Attributes:
      decl: C source code for the declaration.
      defn: Optionally, C source code for a definition.
      dependencies: The names of any objects that must be declared prior.
      is_type: Whether the declaration is of a C type. (C types will be declared in
               external header files and not marked 'extern'.)
      needs_export: Whether the declared object needs to be exported to
                    other modules in the linking table.
    NF)ÚdependenciesÚis_typeÚneeds_exportc               óˆ   — t        |t        «      r|gn|| _        || _        |xs
 t	        «       | _        || _        || _        y ©N)Ú
isinstanceÚstrÚdeclÚdefnÚsetr[   r\   r]   )Úselfrb   rc   r[   r\   r]   s         úW/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/codegen/emit.pyÚ__init__zHeaderDeclaration.__init__w   s=   € ô )¨¬sÔ3�T‘F¸ˆŒ	ØˆŒ	Ø(Ò1¬C«EˆÔØˆŒØ(ˆÕó    r_   )rb   zstr | list[str]rc   zlist[str] | Noner[   zset[str] | Noner\   Úboolr]   ri   ÚreturnÚNone©Ú__name__Ú
__module__Ú__qualname__Ú__doc__rg   © rh   rf   rZ   rZ   g   s[   „ ñð$ "&ð)ð
 )-ØØ"ñ)àð)ð ð)ð
 &ð)ð ð)ð ð)ð 
ô)rh   rZ   c                  ó0   — e Zd ZdZ	 	 d	 	 	 	 	 	 	 	 	 dd„Zy)ÚEmitterContextz-Shared emitter state for a compilation group.Nc                óœ   — d| _         || _        || _        |xs i | _        t	        «       | _        i | _        t        «       | _        || _	        y)zÆSetup shared emitter state.

        Args:
            names: The name generator to use
            group_map: Map from module names to group name
            group_name: Current group name
        r   N)
Útemp_counterÚnamesÚ
group_nameÚ	group_maprd   Ú
group_depsÚdeclarationsr   ÚliteralsÚstrict_traceback_checks)re   rv   r|   rw   rx   s        rf   rg   zEmitterContext.__init__Š   sI   € ð ˆÔØˆŒ
Ø$ˆŒØ"š bˆŒä$'£EˆŒð ;=ˆÔä ›
ˆŒà'>ˆÕ$rh   )NN)
rv   rB   r|   ri   rw   ú
str | Nonerx   zdict[str, str | None] | Nonerj   rk   rl   rq   rh   rf   rs   rs   ‡   sB   „ Ù7ð "&Ø26ð ?àð ?ð "&ð ?ð ð	 ?ð
 0ð ?ð 
ô ?rh   rs   c                  ó   — e Zd ZdZy)ÚErrorHandlerz3Describes handling errors in unbox/cast operations.N©rm   rn   ro   rp   rq   rh   rf   r   r   ­   s   „ Ú=rh   r   c                  ó   — e Zd ZdZy)ÚAssignHandlerzAssign an error value on error.Nr€   rq   rh   rf   r‚   r‚   ±   s   „ Ú)rh   r‚   c                  ó   — e Zd ZdZdd„Zy)ÚGotoHandlerzGoto label on error.c                ó   — || _         y r_   ©Úlabel©re   r‡   s     rf   rg   zGotoHandler.__init__¸   ó	   € Øˆ�
rh   N)r‡   ra   rj   rk   rl   rq   rh   rf   r„   r„   µ   s
   „ Ùôrh   r„   c                  ó,   — e Zd ZdZ	 	 	 	 	 	 	 	 	 	 dd„Zy)ÚTracebackAndGotoHandlerz+Add traceback item and goto label on error.c                ó<   — || _         || _        || _        || _        y r_   )r‡   Úsource_pathÚmodule_nameÚtraceback_entry)re   r‡   r�   rŽ   r�   s        rf   rg   z TracebackAndGotoHandler.__init__¿   s#   € ð ˆŒ
Ø&ˆÔØ&ˆÔØ.ˆÕrh   N)
r‡   ra   r�   ra   rŽ   ra   r�   útuple[str, int]rj   rk   rl   rq   rh   rf   r‹   r‹   ¼   s2   „ Ù5ð/Øð/Ø'*ð/Ø9<ð/ØO^ð/à	ô/rh   r‹   c                  ó   — e Zd ZdZdd„Zy)ÚReturnHandlerz!Return a constant value on error.c                ó   — || _         y r_   )Úvalue)re   r”   s     rf   rg   zReturnHandler.__init__Ë   r‰   rh   N)r”   ra   rj   rk   rl   rq   rh   rf   r’   r’   È   s
   „ Ù+ôrh   r’   c                  ó  — e Zd ZdZ	 	 	 dK	 	 	 	 	 	 	 	 	 dLd„ZdMd„ZdMd„ZdNd„ZdOd„ZdPd„Z	dQd	„Z
dRddœdSd„ZdTd„ZdUd„ZdVd„ZdWd„ZdXd„ZdXd„ZdYd„ZdZd„Zd[d„Zef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`d„Zdad „Z dbd!„Z!dcd"„Z"	 	 	 	 	 	 	 	 	 	 	 	 ddd#„Z#ded$„Z$	 	 	 	 	 	 	 	 	 	 	 	 	 	 dfd%„Z%d&d'œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dgd(„Z&dhd)„Z'd*d+œ	 	 	 	 	 	 	 	 	 	 	 did,„Z(djd-„Z)d^d.„Z*dkd/„Z+d&d0œdld1„Z,d&d&d2œ	 	 	 	 	 	 	 	 	 dmd3„Z-dnd4„Z.d&dd*d&dd*d5œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dod6„Z/	 	 	 	 	 	 	 	 	 	 	 	 dpd7„Z0	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dqd8„Z1	 	 	 	 	 	 	 	 	 	 	 	 	 	 drd9„Z2dsd:„Z3d&dd*d&d&d;œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dtd<„Z4dud=„Z5dvd>„Z6	 dw	 	 	 	 	 	 	 	 	 	 	 dxd?„Z7dyd@„Z8d_dA„Z9d_dB„Z:d_dC„Z;	 	 	 	 	 	 	 	 dzdD„Z<	 	 	 	 	 	 	 	 	 	 	 	 d{dE„Z=	 	 d|	 	 	 	 	 	 	 	 	 	 	 	 	 d}dF„Z>	 	 	 	 	 	 	 	 d~dG„Z?	 	 	 	 	 	 	 	 	 	 ddH„Z@d
dIœ	 	 	 	 	 	 	 	 	 d€dJ„ZAy)�ÚEmitterzHelper for C code generation.Nc                ó¬   — || _         |xs t        j                  d d | _        |j                  | _        |xs i | _        g | _        d| _        || _        y )Né   r   )	ÚcontextÚsysÚversion_infoÚcapi_versionrv   Úvalue_namesÚ	fragmentsÚ_indentÚfilepath)re   r™   r�   rœ   r    s        rf   rg   zEmitter.__init__Ò   sR   € ð ˆŒØ(Ò@¬C×,<Ñ,<¸R¸aÐ,@ˆÔØ—]‘]ˆŒ
Ø&Ò,¨"ˆÔØ$&ˆŒØˆŒØ ˆ�rh   c                ó.   — | xj                   dz  c_         y )Né   ©rŸ   ©re   s    rf   ÚindentzEmitter.indentã   s   € Ø�Š˜ÑŽrh   c                óP   — | xj                   dz  c_         | j                   dk\  sJ ‚y )Nr¢   r   r£   r¤   s    rf   ÚdedentzEmitter.dedentæ   s"   € Ø�Š˜Ñ�Ø�|‰|˜qÒ Ð Ñ rh   c                ó    — d|j                   z  S )NzCPyL%sr†   rˆ   s     rf   r‡   zEmitter.labelê   s   € Ø˜%Ÿ+™+Ñ%Ð%rh   c                ó.   — t         | j                  |   z   S r_   )r   r�   )re   Úregs     rf   rª   zEmitter.regí   s   € Ü˜D×,Ñ,¨SÑ1Ñ1Ð1rh   c                ó   — t         |z   S r_   )r	   )re   Únames     rf   ÚattrzEmitter.attrð   s   € Ü˜TÑ!Ð!rh   c                ól   ‡— t        |«      Št        ˆfd„dD «       «      st        ‰«      dk\  ryd‰› d�S )zãBuild a C comment with a literal value's string representation.

        This is a debugging aid that makes generated C easier to read.

        If it contains illegal characters or is too long, return an empty string.
        c              3  ó&   •K  — | ]  }|‰v –— Œ
 y ­wr_   rq   )Ú.0ÚxÚ	formatteds     €rf   ú	<genexpr>z,Emitter.object_annotation.<locals>.<genexpr>û   s   øè ø€ Ò: !ˆq�IŒ~Ñ:ùs   ƒ)z/*z*/ú é   Ú z /* z */)Ústable_literal_reprÚanyÚlen)re   ÚobjÚliner²   s      @rf   Úobject_annotationzEmitter.object_annotationó   s<   ø€ ô (¨Ó,ˆ	ÜÓ:Ð'9Ô:Ô:¼cÀ)»nÐPSÒ>SØØ�i�[ Ð$Ð$rh   r¶   )Úannc               ó  — |j                  d«      r| j                  «        |�| j                  ||«      nd}| j                  j	                  | j
                  dz  |z   |z   dz   «       |j                  d«      r| j                  «        y y )Nú}r¶   ú ú
ú{)Ú
startswithr§   r¼   rž   ÚappendrŸ   Úendswithr¥   )re   r»   r½   Úcomments       rf   Ú	emit_linezEmitter.emit_lineÿ   ss   € Ø�?‰?˜3ÔØ�K‰KŒMØ7:°�$×(Ñ(¨¨dÔ3ÈBˆØ�‰×Ñ˜dŸl™l¨SÑ0°4Ñ7¸'ÑAÀDÑHÔIØ�=‰=˜ÔØ�K‰K�Mð rh   c                ó4   — |D ]  }| j                  |«       Œ y r_   )rÇ   )re   Úlinesr»   s      rf   Ú
emit_lineszEmitter.emit_lines  s   € Øò 	!ˆDØ�N‰N˜4Õ ñ	!rh   c                óÀ   — t        |t        «      r|}n-|j                  dk(  s|j                  sy | j                  |«      }| j                  j                  |› d�«       y )Nr   z: ;
)r`   ra   r‡   Ú
referencedrž   rÄ   )re   r‡   Útexts      rf   Ú
emit_labelzEmitter.emit_label  sN   € Ü�eœSÔ!Ø‰Dà�{‰{˜aÒ u×'7Ò'7Øà—:‘:˜eÓ$ˆDà�‰×Ñ   e˜nÕ-rh   c                óN   — | j                   j                  |j                   «       y r_   )rž   Úextend)re   Úemitters     rf   Úemit_from_emitterzEmitter.emit_from_emitter  s   € Ø�‰×Ñ˜g×/Ñ/Õ0rh   c           	     ó°   — |j                  dd«      }| j                  ddj                  d|z  gt        |«      z   «      z  «       | j                  d«       y )NrÁ   z\nzprintf(%s);ú, z"%s"zfflush(stdout);)ÚreplacerÇ   ÚjoinÚlist)re   ÚfmtÚargss      rf   Úemit_printfzEmitter.emit_printf  sH   € Ø�k‰k˜$ Ó&ˆØ�‰�} t§y¡y°&¸3±,°Ä$ÀtÃ*Ñ1LÓ'MÑMÔNØ�‰Ð(Õ)rh   c                ór   — | j                   xj                  dz  c_        d| j                   j                  z  S )Né   z__tmp%d©r™   ru   r¤   s    rf   Ú	temp_namezEmitter.temp_name  s,   € Ø�‰×!Ò! QÑ&Õ!Ø˜4Ÿ<™<×4Ñ4Ñ4Ð4rh   c                ór   — | j                   xj                  dz  c_        d| j                   j                  z  S )NrÜ   z__LL%drÝ   r¤   s    rf   Ú	new_labelzEmitter.new_label"  s,   € Ø�‰×!Ò! QÑ&Õ!Ø˜$Ÿ,™,×3Ñ3Ñ3Ð3rh   c                óð   — | j                   j                  }|j                  |«      }|rM|| j                   j                  k7  r4| j                   j                  j                  |«       dt        |«      › d�S y)a  Get the group prefix for a module (relative to the current group).

        The prefix should be prepended to the object name whenever
        accessing an object from this module.

        If the module lives is in the current compilation group, there is
        no prefix.  But if it lives in a different group (and hence a separate
        extension module), we need to access objects from it indirectly via an
        export table.

        For example, for code in group `a` to call a function `bar` in group `b`,
        it would need to do `exports_b.CPyDef_bar(...)`, while code that is
        also in group `b` can simply do `CPyDef_bar(...)`.

        Thus the prefix for a module in group `b` is 'exports_b.' if the current
        group is *not* b and just '' if it is.
        Úexports_ú.r¶   )r™   rx   Úgetrw   ry   ÚaddrC   )re   rŽ   ÚgroupsÚtarget_group_names       rf   Úget_module_group_prefixzEmitter.get_module_group_prefix&  si   € ð$ —‘×'Ñ'ˆØ"ŸJ™J {Ó3ÐÙÐ!2°d·l±l×6MÑ6MÒ!MØ�L‰L×#Ñ#×'Ñ'Ð(9Ô:ØœmÐ,=Ó>Ð?¸qÐAÐAàrh   c                ó8   — | j                  |j                  «      S )z#Get the group prefix for an object.)rè   rŽ   )re   rº   s     rf   Úget_group_prefixzEmitter.get_group_prefix@  s   € ð ×+Ñ+¨C¯O©OÓ<Ð<rh   c                óæ   — | j                   j                  j                  |j                  «      }|r@|| j                   j                  k7  r&| j                   j
                  j                  |«       yyy)a/  Record `cl`'s defining group as a cross-group dep, if any.

        Call this when emitting code that refers to `cl`'s struct
        layout: the .c file consuming that layout needs the defining
        group's `__native_*.h` included, and group_deps drives which
        headers get pulled in.
        N)r™   rx   rä   rŽ   rw   ry   rå   )re   ÚclÚtarget_groups      rf   Úregister_group_depzEmitter.register_group_depE  sV   € ð —|‘|×-Ñ-×1Ñ1°"·.±.ÓAˆÙ˜L¨D¯L©L×,CÑ,CÒCØ�L‰L×#Ñ#×'Ñ'¨Õ5ð Dˆ<rh   c                óŒ   — |sdn| j                  |«      }|rdnd}| j                  j                  |xs d|«      }|› |› |› |› �S )a  Create name of a C static variable.

        These are used for literals and imported modules, among other
        things.

        The caller should ensure that the (id, module) pair cannot
        overlap with other calls to this method within a compilation
        group.
        r¶   Ú*)rè   rv   Úprivate_name)re   ÚidÚmoduleÚprefixÚ
lib_prefixÚ
star_maybeÚsuffixs          rf   Ústatic_namezEmitter.static_nameQ  sT   € ñ  &‘R¨4×+GÑ+GÈÓ+Oˆ
ñ '‘S¨Bˆ
Ø—‘×(Ñ(¨ª°2°rÓ:ˆØ�˜j˜\¨&¨°&°Ð:Ð:rh   c                óZ   — | j                  |j                  |j                  t        ¬«      S )N©rô   )rø   r¬   rŽ   r   )re   rì   s     rf   Útype_struct_namezEmitter.type_struct_nameb  s"   € Ø×Ñ §¡¨¯©ÄÐÓLÐLrh   c                ó   — |j                   S r_   )Ú_ctype©re   Úrtypes     rf   ÚctypezEmitter.ctypee  s   € Ø�|‰|Ðrh   c                óB   — | j                  |«      }|d   dk(  r|S |dz   S )z*Adds a space after ctype for non-pointers.éÿÿÿÿrð   rÀ   )r   )re   rÿ   r   s      rf   Úctype_spacedzEmitter.ctype_spacedh  s+   € à—
‘
˜5Ó!ˆØ�‰9˜ÒØˆLà˜3‘;Ðrh   c                óÂ   — t        |t        «      r)| j                  |› d�«       | j                  |› d�«       y | j                  |› d| j                  |«      › d�«       y )Nz
.len = -1;ú.items = NULL;ú = ú;)r`   r&   rÇ   Úc_undefined_value)re   Útargetrÿ   s      rf   Úset_undefined_valuezEmitter.set_undefined_valuep  sW   € Ü�eœTÔ"Ø�N‰N˜f˜X ZÐ0Ô1Ø�N‰N˜f˜X ^Ð4Õ5à�N‰N˜f˜X S¨×)?Ñ)?ÀÓ)FÐ(GÀqÐIÕJrh   c                óî   — |j                   syt        |t        «      r|j                  S t        |t        «      r| j                  |«      S t        |t        «      rd| j                  |«      › d�S J |«       ‚)NÚNULLú(z) { -1, NULL })Ú
is_unboxedr`   r"   Úc_undefinedr#   Útuple_undefined_valuer&   r   rþ   s     rf   r  zEmitter.c_undefined_valuew  sm   € Ø×ÒØÜ˜œzÔ*Ø×$Ñ$Ð$Ü˜œvÔ&Ø×-Ñ-¨eÓ4Ð4Ü˜œtÔ$Ø�t—z‘z %Ó(Ð)Ð)9Ð:Ð:Ø�eÓˆurh   c                ó$   — | j                  |«      S r_   )r  rþ   s     rf   Úc_error_valuezEmitter.c_error_value‚  s   € Ø×%Ñ% eÓ,Ð,rh   c                óH   — t         › |j                  | j                  «      › �S r_   )r   Úcnamerv   ©re   Úfns     rf   Únative_function_namezEmitter.native_function_name…  s   € Ü� §¡¨$¯*©*Ó!5Ð 6Ð7Ð7rh   c                óJ   — | j                  |«      › | j                  |«      › �S )a  Return the C expression for a call to `fn`'s native (CPyDef_) entry.

        For cross-group references under `separate=True`, this prepends the
        exports-table indirection (e.g. `exports_other.CPyDef_foo`). Same as
        `native_function_name()` for in-group calls.
        )rê   r  r  s     rf   Únative_function_callzEmitter.native_function_callˆ  s+   € ð ×'Ñ'¨Ó+Ð,¨T×-FÑ-FÀrÓ-JÐ,KÐLÐLrh   c                ój   — | j                  |«      › t        › |j                  | j                  «      › �S )zîReturn the C expression for a call to `fn`'s Python-wrapper (CPyPy_) entry.

        Like `native_function_call`, but for the PyObject-level wrapper that
        boxes/unboxes arguments. Used from slot generators (tp_init, etc.).
        )rê   r   r  rv   r  s     rf   Úwrapper_function_callzEmitter.wrapper_function_call‘  s1   € ð ×'Ñ'¨Ó+Ð,¬V¨H°R·X±X¸d¿j¹jÓ5IÐ4JÐKÐKrh   c                ó²  — d|j                   › �d|j                   › �d|j                   › d�g}t        |j                  «      dk(  r|j                  d«       n>d}|j                  D ]-  }|j                  | j	                  |«      › d|› d�«       |d	z  }Œ/ |j                  d
|j                   › d�«       |j                  d«       |j                  d«       |S )Nz#ifndef MYPYC_DECLARED_z#define MYPYC_DECLARED_ztypedef struct z {r   zint empty_struct_error_flag;Úfr  rÜ   z} z#endifr¶   )Ústruct_namer¹   ÚtypesrÄ   r  )re   ÚrtupleÚresultÚiÚtyps        rf   Útuple_c_declarationzEmitter.tuple_c_declaration™  sá   € à% f×&8Ñ&8Ð%9Ð:Ø% f×&8Ñ&8Ð%9Ð:Ø˜f×0Ñ0Ð1°Ð5ð
ˆô
 ˆv�|‰|Ó Ò!ð �M‰MÐ8Õ9àˆAØ—|‘|ò �Ø—‘ ×!2Ñ!2°3Ó!7Ð 8¸¸!¸¸AÐ>Ô?Ø�Q‘‘ðð 	�‰˜˜F×.Ñ.Ð/¨qÐ1Ô2Ø�‰�hÔØ�‰�bÔàˆrh   c                ó0   — |t         z  }|dk(  ryd|dz   › �S )z.Return C field name used for attribute bitmap.r   ÚbitmaprÜ   )r
   )re   ÚindexÚns      rf   Úbitmap_fieldzEmitter.bitmap_field®  s'   € à”[Ñ ˆØ�Š6ØØ˜˜A™�wÐÐrh   c                óv   — d|j                  | j                  «      › d�}| j                  |«      }d|› |› d|› �S )z5Return reference to the attribute definedness bitmap.r  ú *)ú)->)r  rv   r)  )re   rº   rì   r'  Úcastr­   s         rf   Úattr_bitmap_exprzEmitter.attr_bitmap_exprµ  sE   € à�2—>‘> $§*¡*Ó-Ð.¨cÐ2ˆØ× Ñ  Ó'ˆØ�4�&˜˜˜S  Ð'Ð'rh   c                ó2   — | j                  |||||d¬«       y)zâMark an attribute as defined in the attribute bitmap.

        Assumes that the attribute is tracked in the bitmap (only some attributes
        use the bitmap). If 'value' is not equal to the error value, do nothing.
        F©ÚclearN©Ú_emit_attr_bitmap_update)re   r”   rº   rÿ   rì   r­   s         rf   Úemit_attr_bitmap_setzEmitter.emit_attr_bitmap_set»  s   € ð 	×%Ñ% e¨S°%¸¸TÈÐ%ÕOrh   c                ó2   — | j                  d||||d¬«       y)z}Mark an attribute as undefined in the attribute bitmap.

        Unlike emit_attr_bitmap_set, clear unconditionally.
        r¶   Tr0  Nr2  )re   rº   rÿ   rì   r­   s        rf   Úemit_attr_bitmap_clearzEmitter.emit_attr_bitmap_clearÅ  s   € ð
 	×%Ñ% b¨#¨u°b¸$ÀdÐ%ÕKrh   c                ó\  — |r(| j                  ||d«      }| j                  d|› d�«       |j                  j                  |«      }d|t        dz
  z  z  }	| j                  |||«      }
|r| j                  |
› d|	› d�«       n| j                  |
› d|	› d�«       |r| j                  d«       y y )	Nú==úif (unlikely(ú)) {rÜ   z &= ~r  z |= r¿   )Úerror_value_checkrÇ   Úbitmap_attrsr'  r
   r.  )re   r”   rº   rÿ   rì   r­   r1  Úcheckr'  Úmaskr&  s              rf   r3  z Emitter._emit_attr_bitmap_updateÌ  s´   € ñ Ø×*Ñ*¨5°%¸Ó>ˆEØ�N‰N˜]¨5¨'°Ð7Ô8Ø—‘×%Ñ% dÓ+ˆØ�Uœk¨A™oÑ.Ñ/ˆØ×&Ñ& s¨B°Ó6ˆÙØ�N‰N˜f˜X U¨4¨&°Ð2Õ3à�N‰N˜f˜X T¨$¨¨qÐ1Ô2ÙØ�N‰N˜3Õð rh   F)Úunlikelyc               óP  — | j                  |||«      }|rd|› d�}|j                  rj|j                  j                  |«      }	d|	t        dz
  z  z  }
| j                  |	«      }d|j                  | j                  «      › d|› �}|› d|› d|› d|
› d�}| j                  d	|› d
�«       y )Nz	unlikely(ú)rÜ   r  r+  z && !((r,  z & úif (ú) {)	r;  Úerror_overlapr<  r'  r
   r)  r  rv   rÇ   )re   rÿ   Ú	attr_exprÚcomparerº   r­   rì   r?  r=  r'  ÚbitÚobj_exprs               rf   Úemit_undefined_attr_checkz!Emitter.emit_undefined_attr_checkÜ  s¼   € ð ×&Ñ& u¨i¸ÓAˆÙØ ˜w aÐ(ˆEØ×ÒØ—O‘O×)Ñ)¨$Ó/ˆEØ˜¤¨q¡Ñ1Ñ2ˆCØ×$Ñ$ UÓ+ˆDØ˜2Ÿ>™>¨$¯*©*Ó5Ð6°c¸#¸Ð?ˆHØ�g˜W X J¨c°$°°s¸3¸%¸qÐAˆEØ�‰˜˜e˜W DÐ)Õ*rh   c                óê   — t        |t        «      r | j                  ||| j                  |d¬«      S t        |t        «      r|dk(  r|› d�S |dk(  r|› d�S J |«       ‚|› d|› d| j                  |«      › �S )NF©Úcheck_exceptionr8  z.len < 0z!=z	.len >= 0rÀ   )r`   r#   Útuple_undefined_check_condr  r&   )re   rÿ   r”   rF  s       rf   r;  zEmitter.error_value_checkò  s–   € Ü�eœVÔ$Ø×2Ñ2Ø�u˜d×0Ñ0°'È5ð 3ó ð ô ˜œtÔ$Ø˜$ŠØ˜ Ð)Ð)Ø˜D’Ø˜ 	Ð*Ð*Ø!˜'Ó!�5à�W˜A˜g˜Y a¨×(:Ñ(:¸5Ó(AÐ'BÐCÐCrh   TrK  c          	     ó  — t        |j                  «      dk(  rdj                  || |t        «      «      S |j                  rd}|j                  d   }nAt        |j                  «      D ]"  \  }}|j                  rŒ|j                  |   } n J d«       ‚t        |t        «      r| j                  ||d|› �z   ||«      S t        |t        «      r|› d|› d|› d�S |› d|› d|› d ||«      › �}	|j                  r|r|	dz  }	|	S )	Nr   z {}.empty_struct_error_flag {} {}z&not expecting tuple with error overlapú.fz.len z -1rÀ   z && PyErr_Occurred())
r¹   r  Úformatr'   rD  Ú	enumerater`   r#   rM  r&   )
re   r   Útuple_expr_in_cÚc_type_compare_valrF  rL  r"  Ú	item_typer#  r=  s
             rf   rM  z"Emitter.tuple_undefined_check_cond   s.  € ô ˆv�|‰|Ó Ò!à5×<Ñ<Ø Ñ*<¼^Ó*Lóð ð ×ÒØˆAØŸ™ Q™‰Iä# F§L¡LÓ1ò G‘��3Ø×(Ó(Ø &§¡¨Q¡�IÙðGð
 GÐFÓF�uÜ�i¤Ô(Ø×2Ñ2Ø˜?¨r°!°¨XÑ5Ð7IÈ7óð ô ˜	¤4Ô(Ø%Ð& b¨¨¨5°°	¸Ð=Ð=à&Ð' r¨!¨¨A¨g¨Y°aÑ8JÈ9Ó8UÐ7VÐWˆEØ×#Ò#©ØÐ/Ñ/�ØˆLrh   c                óD   — d|j                   › d| j                  |«      › �S )z0Undefined tuple value suitable in an expression.r  z) )r  Úc_initializer_undefined_value)re   r   s     rf   r  zEmitter.tuple_undefined_value$  s(   € à�6×%Ñ%Ð& b¨×)KÑ)KÈFÓ)SÐ(TÐUÐUrh   c                ó,  — t        |t        «      r^|j                  sdt        j                  › d�S dj                  |j                  D �cg c]  }| j                  |«      ‘Œ c}«      }d|› d�S t        |t        «      ry| j                  |«      S c c}w )zKUndefined value represented in a form suitable for variable initialization.z{ z }rÔ   z{ -1, NULL })	r`   r#   r  r'   r  rÖ   rV  r&   r  )re   rÿ   ÚtÚitemss       rf   rV  z%Emitter.c_initializer_undefined_value(  s†   € ä�eœVÔ$Ø—;’;ð œ^×7Ñ7Ð8¸Ð<Ð<Ø—I‘IÈeÏkÉkÖZÈ˜t×AÑAÀ!ÕDÒZÓ[ˆEØ˜˜˜sÐ#Ð#Ü˜œtÔ$Ø!à×)Ñ)¨%Ó0Ð0ùò [s   Á
Bc                óT  — |j                   | j                  j                  vr†t        «       }|j                  D ].  }t        |t        «      sŒ|j                  |j                   «       Œ0 t        | j                  |«      |d¬«      | j                  j                  |j                   <   y y )NT)r[   r\   )
r  r™   rz   rd   r  r`   r#   rå   rZ   r$  )re   Ú
tuple_typer[   r#  s       rf   Údeclare_tuple_structzEmitter.declare_tuple_struct8  s�   € Ø×!Ñ!¨¯©×)BÑ)BÑBÜ›5ˆLØ!×'Ñ'ò 6�ä˜c¤6Õ*Ø ×$Ñ$ S§_¡_Õ5ð6ô
 ARØ×(Ñ(¨Ó4À<ÐY]ôAˆD�L‰L×%Ñ% j×&<Ñ&<Ò=ð Crh   )Úrarec               ó  — t        |«      r,|r| j                  d|z  «       y| j                  d|z  «       yt        |t        «      r5t	        |j
                  «      D ]  \  }}| j                  |› d|› �|«       Œ yt        |t        «      r+t        |j                     }| j                  |› d|› d�«       y|j                  s<|j                  st        s| j                  d|z  «       y| j                  d|z  «       yy)	zýIncrement reference count of C expression `dest`.

        For composite unboxed structures (e.g. tuples) recursively
        increment reference counts for each component.

        If rare is True, optimize for code size and compilation speed.
        zCPyTagged_IncRef(%s);zCPyTagged_INCREF(%s);rO  z_INCREF(ú);zCPy_INCREF(%s);zCPy_INCREF_NO_IMM(%s);N)r2   rÇ   r`   r#   rQ  r  Úemit_inc_refr&   rX   rý   r  Úmay_be_immortalr   )re   Údestrÿ   r]  r"  rT  rô   s          rf   r`  zEmitter.emit_inc_refD  sá   € ô ˜UÔ#ÙØ—‘Ð6¸Ñ=Õ>à—‘Ð6¸Ñ=Õ>Ü˜œvÔ&Ü )¨%¯+©+Ó 6ò =‘��9Ø×!Ñ! T F¨"¨Q¨C .°)Õ<ñ=ä˜œtÔ$Ü% e§l¡lÑ3ˆFØ�N‰N˜f˜X X¨d¨V°2Ð6Õ7Ø×!Ò!à×$Ò$­MØ—‘Ð0°4Ñ7Õ8à—‘Ð7¸$Ñ>Õ?ð "rh   ©Úis_xdecr]  c               ó–  — |rdnd}t        |«      r4|r| j                  d|› d|› d�«       y| j                  d|› d|› d�«       yt        |t        «      r8t	        |j
                  «      D ]  \  }}| j                  |› d|› �|||¬«       Œ! yt        |t        «      r+t        |j                     }| j                  |› d	|› d�«       y|j                  s_|r| j                  d
|› d|› d�«       y|j                  st        s| j                  d
|› d|› d�«       y| j                  d
|› d|› d�«       y|j                  r
J d|› �«       ‚y)zýDecrement reference count of C expression `dest`.

        For composite unboxed structures (e.g. tuples) recursively
        decrement reference counts for each component.

        If rare is True, optimize for code size and compilation speed.
        ÚXr¶   Ú
CPyTagged_zDecRef(r_  zDECREF(rO  rc  z_DECREF(ÚCPy_zDECREF_NO_IMM(zdec_ref not implemented for N)r2   rÇ   r`   r#   rQ  r  Úemit_dec_refr&   rX   rý   r  ra  r   Úis_refcounted)	re   rb  rÿ   rd  r]  r±   r"  rT  rô   s	            rf   ri  zEmitter.emit_dec_ref_  sU  € ñ ‰C ˆÜ˜UÔ#ÙØ—‘ ¨A¨3¨g°d°V¸2Ð>Õ?ð —‘ ¨A¨3¨g°d°V¸2Ð>Õ?Ü˜œvÔ&Ü )¨%¯+©+Ó 6ò Y‘��9Ø×!Ñ! T F¨"¨Q¨C .°)ÀWÐSWÐ!ÕXñYä˜œtÔ$Ü% e§l¡lÑ3ˆFØ�N‰N˜f˜X X¨d¨V°2Ð6Õ7Ø×!Ò!ÙØ—‘  a S¨°¨v°RÐ8Õ9ð ×(Ò(µØ—N‘N T¨!¨¨G°D°6¸Ð#<Õ=à—N‘N T¨!¨¨N¸4¸&ÀÐ#CÕDØ× Ò Ø@Ð8¸¸Ð@Ó@�5ð !rh   c                óZ   — t        |«      }|�d| j                  |«      z  S t        |«      S )Nz
%s or None)r?   Úpretty_namera   )re   r#  Ú
value_types      rf   rl  zEmitter.pretty_nameƒ  s1   € Ü(¨Ó-ˆ
ØÐ!Ø $×"2Ñ"2°:Ó">Ñ>Ð>Ü�3‹xˆrh   )Údeclare_destÚerrorÚraise_exceptionÚoptionalÚsrc_typeÚlikelyc               ó  — |xs
 t        «       }|r¶t        |«      r«t        |«      s t        |«      }
|
€J ‚t	        |
|«      r…|r| j                  d|› d�«       d}|	rd|› d�}| j                  ||||j                  |«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt        |«      sdt        |«      sYt        |«      sNt        |«      sCt        |«      s8t        |«      s-t!        |«      s"t#        |«      st%        |«      st'        |«      �r|r| j                  d|› d�«       t        |«      rd}n…t        |«      rd}nwt        |«      rd}nit        |«      rd}n[t        |«      rd}nMt        |«      rd}n?t!        |«      rd}n1t#        |«      st'        |«      rd}nt%        |«      rd}n
J d|› �«       ‚d}|	rd|› d�}| j                  ||||j                  ||«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt)        |«      r†|r| j                  d|› d�«       d}|	rd|› d�}| j                  ||||j                  ||«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt+        |«      r†|r| j                  d|› d�«       d}|	rd|› d�}| j                  ||||j                  ||«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt-        |«      r–|r&| j                  | j/                  |«      › d|› d�«       d}|	rd|› d�}| j                  ||||j                  |«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt1        |t2        «      �r3|r| j                  d|› d�«       t5        |j6                  «      }|rt9        |«      t:        dz   kD  r,dj                  || j=                  |j6                  «      «      }ngd}t?        dt9        |«      «      D ]
  }|d|z  z  }Œ t9        |«      dkD  rd|z  }|j                  ||D �cg c]  }| j=                  |«      ‘Œ c}¬«      }|	rd|› d�}| j                  |||||«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       ytA        |«      r…|r| j                  d|› d�«       d }|	rd|› d�}| j                  ||||j                  |«      |«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt        |«      rX|r| j                  d|› d�«       | j                  |||d!|«       | j                  |› d|› d�«       |r| j                  d
«       yytC        |«      rœ|r| j                  d|› d�«       |jD                  jG                  d"d«      d#   }d$|› d%|› d&�}|	rd|› d�}| j                  |||||«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yt1        |tH        «      r| jK                  ||||||||«       yt1        |tL        «      r|rJ ‚| jO                  ||||||«       yt1        |tP        «      �r |r| j                  d|› d�«       tS        jT                  |jV                  «      }|jY                  «       }|r
d'|› d(|› d)�}nq|d*k(  r| j[                  |«      }d'|› d+|› d,|› d�}nN|j]                  «       }|t^        v rta        t^        |   «      }n| j[                  |«      }d'|› d-|› d,|› d.|› d/|› d�}|	rd|› d�}| j                  |||||«       | j                  d|› d|› d�d	«       | j                  |||||«       | j                  d
«       yJ d0|z  «       ‚c c}w )1au  Emit code for casting a value of given type.

        Somewhat strangely, this supports unboxed types but only
        operates on boxed versions.  This is necessary to properly
        handle types such as Optional[int] in compatibility glue.

        By default, assign NULL (error value) to dest if the value has
        an incompatible type and raise TypeError. These can be customized
        using 'error' and 'raise_exception'.

        Always copy/steal the reference in 'src'.

        Args:
            src: Name of source C variable
            dest: Name of target C variable
            typ: Type of value
            declare_dest: If True, also declare the variable 'dest'
            error: What happens on error
            raise_exception: If True, also raise TypeError on failure
            likely: If the cast is likely to succeed (can be False for unions)
        Nú
PyObject *r  z({} != Py_None)z(likelyrA  ú    r  úelse {r¿   ÚPyListÚPyDictÚPySetÚPyFrozenSetÚ	PyUnicodeÚPyRangeÚCPyFloatÚPyLongÚPyBoolzunexpected primitive type: z({}_Check({}))z(PyBytes_Check({}))z(PyByteArray_Check({}))rÀ   z(PyTuple_Check({}))rÜ   z(PyObject_TypeCheck({}, {}))z (Py_TYPE({src}) == {targets[0]})z% || (Py_TYPE({src}) == {targets[%d]})z(%s))ÚsrcÚtargetsz({} == Py_None)r¶   rã   r  z(CPyz_Check(ú))z	(Py_TYPE(z) == z.boxed_type)r   z4) == VecTApi.boxed_type && VEC_T_BUF(((VecTObject *)z)->vec)->item_type == zC) == VecNestedApi.boxed_type && VEC_NESTED_BUF(((VecNestedObject *)z' && VEC_NESTED_BUF(((VecNestedObject *)z)->vec)->depth == zCast not implemented: %s)1r‚   r7   r6   r?   rE   rÇ   Úemit_arg_checkrP  rÊ   Úemit_cast_error_handlerr3   r+   r9   r.   r;   r8   r-   r2   r(   r,   r*   r)   r<   r   r`   r!   r   Úclass_irr¹   r   rû   Úranger5   r4   r¬   Úrsplitr%   Úemit_union_castr#   Úemit_tuple_castr&   r@   rä   rT  ÚdepthÚvec_item_type_cÚunwrap_item_typerA   ra   )re   r�  rb  r#  rn  ro  rp  rq  rr  rs  rm  r=  rô   ÚconcreteÚfull_strr"  ÚirÚ
short_nameÚapi_namer‹  Úitem_type_cÚ	unwrappedÚ
type_values                          rf   Ú	emit_castzEmitter.emit_cast‰  sä  € ðD Ò(œ›ˆñ Ô(¨Ô2Ô;OÐPSÔ;TÜ,¨XÓ6ˆJØÐ)Ð)Ð)Ü˜J¨Ô,ÙØ—N‘N Z°¨v°QÐ#7Ô8Ø)�ÙØ% e W¨AÐ.�EØ×#Ñ# C¨¨s°E·L±LÀÓ4EÀxÔPØ—‘ $ t f¨C°¨u°AÐ 6¸ÔAØ×,Ñ,¨U°C¸¸sÀOÔTØ—‘˜sÔ#Øô ˜sÔ#Ü! #Ô&Ü  Ô%Ü& sÔ+Ü  Ô%Ü" 3Ô'Ü" 3Ô'Ü  Ô%Ü(¨Ô-Ü# CÕ(áØ—‘ ¨D¨6°Ð3Ô4Ü! #Ô&Ø!‘Ü# CÔ(Ø!‘Ü" 3Ô'Ø ‘Ü(¨Ô-Ø&‘Ü" 3Ô'Ø$‘Ü$ SÔ)Ø"‘Ü$ SÔ)Ø#‘Ü" 3Ô'Ô+?ÀÔ+Dà!‘Ü*¨3Ô/Ø!‘àAÐ ;¸C¸5ÐAÓA�uØ$ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°·±¸VÀSÓ0IÈ8ÔTØ�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ  Ô%ÙØ—‘ ¨D¨6°Ð3Ô4Ø)ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°·±¸SÀ#Ó0FÈÔQØ�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ$ SÔ)ÙØ—‘ ¨D¨6°Ð3Ô4Ø-ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°·±¸SÀ#Ó0FÈÔQØ�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ  Ô%ÙØ—‘ $§*¡*¨S£/Ð!2°!°D°6¸Ð;Ô<Ø)ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°·±¸SÓ0AÀ8ÔLØ�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ˜œYÕ'ÙØ—‘ ¨D¨6°Ð3Ô4Ü+¨C¯L©LÓ9ˆHñ
 œs 8›}Ô/MÐPQÑ/QÒQØ6×=Ñ=Ø˜×.Ñ.¨s¯|©|Ó<ó‘ð >�Ü˜q¤# h£-Ó0ò L�AØÐ GÈ!Ñ KÑK‘HðLä�x“= 1Ò$Ø%¨Ñ0�HØ Ÿ™ØÈ(Ö%SÀB d×&;Ñ&;¸BÕ&?Ò%Sð (ó �ñ Ø! % ¨Ð*�Ø×Ñ  T¨3°°xÔ@Ø�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ Ô$ÙØ—‘ ¨D¨6°Ð3Ô4Ø%ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°·±¸SÓ0AÀ8ÔLØ�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ! #Ô&ÙØ—‘ ¨D¨6°Ð3Ô4Ø×Ñ  T¨3°°HÔ=Ø�N‰N˜d˜V 3 s e¨1Ð-Ô.ÙØ—‘˜sÕ#ð ä! #Ô&áØ—‘ ¨D¨6°Ð3Ô4ØŸ™Ÿ™¨¨aÓ0°Ñ4ˆJØ˜:˜, g¨c¨U°"Ð5ˆEÙØ! % ¨Ð*�Ø×Ñ  T¨3°°xÔ@Ø�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3ÕÜ˜œVÔ$Ø× Ñ Ø�T˜3 ¨e°X¸xÈõô ˜œVÔ$ÙÐ�<Ø× Ñ   d¨C°¸uÀhÕOÜ˜œTÕ"ÙØ—‘ ¨D¨6°Ð3Ô4ä+×/Ñ/°·±Ó>ˆHØ—I‘I“KˆEÙà# C 5¨¨h¨Z°|ÐD‘Ø˜!’à"×2Ñ2°3Ó7�à ˜uð %0Ø03¨uÐ4JÈ;È-ÐWXðZñ ð  ×0Ñ0Ó2�	ØÔ 2Ñ2Ü!$Ô%7¸	Ñ%BÓ!C‘Jà!%×!5Ñ!5°cÓ!:�Jà ˜uð %:Ø:=¸Ð>TÐU_ÐT`ð a:Ø:=¸Ð>PÐQVÐPWÐWXðZð ñ
 Ø! % ¨Ð*�Ø×Ñ  T¨3°°xÔ@Ø�O‰O˜d 4 &¨¨C¨5°Ð2°HÔ=Ø×(Ñ(¨°°T¸3ÀÔPØ�N‰N˜3Õà:Ð4°sÑ:Ó:�5ùò_ &Ts   Óa?
c                ó  — |rŠt        |t        «      rS| j                  |j                  |j                  |j
                  ||¬«       | j                  d|j                  z  «       y | j                  d| j                  |«      › d|› d�«       t        |t        «      r| j                  d|z  «       y t        |t        «      r| j                  d|j                  z  «       y t        |t        «      rd| j                  d|z  «       | j                  |j                  |j                  |j
                  «       | j                  d|j                  z  «       y t        |t        «      sJ |«       ‚| j                  d|j                  z  «       y )N)r#  r�  úgoto %s;úCPy_TypeError("ú", ú); z
%s = NULL;ú
return %s;)r`   r‹   Úemit_type_error_tracebackr�   rŽ   r�   rÇ   r‡   rl  r‚   r„   Úemit_tracebackr’   r”   )re   ro  r�  rb  r#  rp  s         rf   r…  zEmitter.emit_cast_error_handlerj  s>  € ñ Ü˜%Ô!8Ô9à×.Ñ.Ø×%Ñ% u×'8Ñ'8¸%×:OÑ:OÐUXÐ^að /ô ð —‘˜z¨E¯K©KÑ7Ô8ØØ�N‰N˜_¨T×-=Ñ-=¸cÓ-BÐ,CÀ3ÀsÀeÈ3ÐOÔPÜ�eœ]Ô+Ø�N‰N˜<¨$Ñ.Õ/Ü˜œ{Ô+Ø�N‰N˜:¨¯©Ñ3Õ4Ü˜Ô6Ô7Ø�N‰N˜<¨$Ñ.Ô/Ø×Ñ × 1Ñ 1°5×3DÑ3DÀe×F[ÑF[Ô\Ø�N‰N˜:¨¯©Ñ3Õ4ä˜e¤]Ô3Ð:°UÓ:Ð3Ø�N‰N˜<¨%¯+©+Ñ5Õ6rh   c	           
     óæ  — |r| j                  d|› d�«       | j                  «       }	|ra| j                  d|› d�«       | j                  |› d| j                  |«      › d�«       | j                  d|	› d�«       | j                  d«       |j                  D ]2  }
| j	                  |||
dddd¬	«       | j                  d|› d
|	› d�«       Œ4 | j                  |||||«       | j                  |	«       y)zTEmit cast to a union type.

        The arguments are similar to emit_cast.
        ru  r  rB  ú == NULL) {r  úgoto r¿   F)rn  rp  rq  rs  z != NULL) goto N)rÇ   rà   r  rY  r–  r…  rÎ   )re   r�  rb  r#  rn  ro  rq  rr  rp  Ú
good_labelÚitems              rf   r‰  zEmitter.emit_union_cast‚  s  € ñ Ø�N‰N˜Z¨ v¨QÐ/Ô0Ø—^‘^Ó%ˆ
ÙØ�N‰N˜T #  lÐ3Ô4Ø�N‰N˜d˜V 3 t×'9Ñ'9¸#Ó'>Ð&?¸qÐAÔBØ�N‰N˜U : ,¨aÐ0Ô1Ø�N‰N˜3ÔØ—I‘Iò 
	FˆDØ�N‰NØØØØ"Ø %ØØð ô ð �N‰N˜T $  °z°lÀ!ÐDÕEð
	Fð 	×$Ñ$ U¨C°°s¸OÔLØ�‰˜
Õ#rh   c           	     óÆ  — |r| j                  d|› d�«       | j                  «       }| j                  dj                  |t	        |j
                  «      ¬«      |› d�d|› d�d«       t        |j
                  «      D ];  \  }}	| j                  d|› d	|› d
�||	ddd¬«       | j                  d|› d|› d�«       Œ= | j                  |› d|› d�«       | j                  |«       y)zTEmit cast to a tuple type.

        The arguments are similar to emit_cast.
        ru  r  zJif (unlikely(!(PyTuple_Check({r}) && PyTuple_GET_SIZE({r}) == {size}))) {{)ÚrÚsizez = NULL;r¡  r¿   zPyTuple_GET_ITEM(rÔ   rA  F)rn  rp  rq  rB  z == NULL) goto r  N)	rÇ   rà   rÊ   rP  r¹   r  rQ  r–  rÎ   )
re   r�  rb  r#  rn  ro  rr  Ú	out_labelr"  r£  s
             rf   rŠ  zEmitter.emit_tuple_cast¨  s  € ñ Ø�N‰N˜Z¨ v¨QÐ/Ô0ð —N‘NÓ$ˆ	Ø�‰ØX×_Ñ_ØœC §	¡	›Nð `ó ð ˆf�HÐØ�I�;˜aÐ Øô	
ô ! §¡Ó+ò 
	E‰GˆAˆtà�N‰NØ# C 5¨¨1¨#¨QÐ/ØØØ"Ø %Øð ô ð �N‰N˜T $  °y°kÀÐCÕDð
	Eð 	�‰˜$˜˜s 3 % qÐ)Ô*Ø�‰˜	Õ"rh   c                óü   — |r;| j                  d|› d�«       | j                  |› d| j                  |«      › d�«       |dk7  r&| j                  dj                  |rdnd|«      «       y |r| j                  d«       y y )	NrB  r   r  r  r¶   z{}if {}z} else rw  )rÇ   r  rP  )re   r�  rb  r#  r=  rq  s         rf   r„  zEmitter.emit_arg_checkÒ  sw   € ÙØ�N‰N˜T #  lÐ3Ô4Ø�N‰N˜d˜V 3 t×'9Ñ'9¸#Ó'>Ð&?¸qÐAÔBØ�BŠ;Ø�N‰N˜9×+Ñ+¹©IÀrÈ5ÓQÕRÙØ�N‰N˜8Õ$ð rh   )rn  ro  rp  rq  Úborrowc          
     óx  — |xs
 t        «       }t        |t         «      r|› d| j                  |«      › d�}	nFt        |t        «      rd|j                  z  }	n&t        |t
        «      sJ |«       ‚d|j                  z  }	|	}
|rd| j                  |«      › d|› d�}||
z   }
t        |«      st        |«      r—|r| j                  d|› d�«       | j                  |||d	|› d
�|«       |r| j                  d|› d|› d�«       n| j                  d|› d|› d�«       | j                  d«       | j                  |
«       | j                  d«       y)t        |«      rp|r| j                  d|› d�«       | j                  |||d|› d�|«       | j                  |
«       | j                  d«       |› d�}| j                  d|› d|› d�«       y)t        |«      rh|r| j                  d|› d�«       | j                  |||d|› d�|«       | j                  |
«       | j                  d«       | j                  d|› d�«       y)t        |«      rW|rJ ‚|r| j                  d|› d�«       | j                  |› d|› d�«       t        |t         «      s| j                  |||
«       y)y)t!        |«      rW|rJ ‚|r| j                  d|› d�«       | j                  |› d|› d�«       t        |t         «      s| j                  |||
«       y)y)t#        |«      rW|rJ ‚|r| j                  d|› d�«       | j                  |› d|› d�«       t        |t         «      s| j                  |||
«       y)y)t%        |«      rW|rJ ‚|r| j                  d|› d�«       | j                  |› d |› d�«       t        |t         «      s| j                  |||
«       y)y)t'        |«      rJ|rJ ‚|r| j                  d!|› d�«       | j                  |› d"|› d�«       | j)                  d#|› d$�|
d«       y)t        |t*        «      �ró| j-                  |«       |r&| j                  | j/                  |«      › d%|› d�«       |rL| j                  d#|› d&�«       | j                  |› d| j                  |«      › d�«       | j                  d'«       g }| j1                  «       }| j3                  |||d(|d)¬*«       | j                  d+|› d,�«       | j                  |
«       | j                  d'«       |j4                  s| j                  |› d-�«       t7        |j4                  «      D ]ë  \  }}| j1                  «       }| j                  d.|› d/|› d0|› d�«       | j1                  «       }|j8                  rX| j;                  «       }|j=                  ||f«       | j?                  ||||xr t        |t         «       t        |«      d(|¬1«       n-|s| jA                  |tB        «       | jE                  |||d(¬2«       | j                  |› d3|› d|› d�«       Œí | j                  d«       |rÁ| j;                  «       }| j                  d4|› d�«       |D ]†  \  }}| jG                  |«       |s7t7        |j4                  d)| «      D ]  \  }}| jI                  |› d3|› �|«       Œ | j                  |	«       t        |t         «      sŒr| j                  d4|› d�«       Œˆ | jG                  |«       |r| j                  d«       y)y)t        |tJ        «      �r‡|r&| j                  | j/                  |«      › d%|› d�«       |rL| j                  d#|› d&�«       | j                  |› d| j                  |«      › d�«       | j                  d'«       tM        jN                  |jP                  «      }|�| j                  |› d|› d5|› d�«       n‰|jS                  «       }|jU                  «       }|tV        v rtY        tV        |   «      }n| j[                  |«      }|d6k(  r| j                  |› d7|› d0|› d�«       n| j                  |› d8|› d0|› d0|› d�«       | j                  d9|› d:�«       | j                  |
«       | j                  d«       |r| j                  d«       y)y)J d;|z  «       ‚)<a  Emit code for unboxing a value of given type (from PyObject *).

        By default, assign error value to dest if the value has an
        incompatible type and raise TypeError. These can be customized
        using 'error' and 'raise_exception'.

        Generate a new reference unless 'borrow' is True.

        Args:
            src: Name of source C variable
            dest: Name of target C variable
            typ: Type of value
            declare_dest: If True, also declare the variable 'dest'
            error: What happens on error
            raise_exception: If True, also raise TypeError on failure
            optional: If True, NULL src value is allowed and will map to error value
            borrow: If True, create a borrowed reference

        r  r  r˜  rœ  r™  rš  r›  z
CPyTagged z(likely(PyLong_Check(z)))rv  z = CPyTagged_BorrowFromObject(r_  z = CPyTagged_FromObject(rw  r¿   zchar z(unlikely(!PyBool_Check(z))) {z} elsez == Py_Truez
(unlikely(z != Py_None)) {z = 1;zint64_t z = CPyLong_AsInt64(zint32_t z = CPyLong_AsInt32(zint16_t z = CPyLong_AsInt16(zuint8_t z = CPyLong_AsUInt8(zdouble z = PyFloat_AsDouble(rB  z == -1.0 && PyErr_Occurred()) {rÀ   r   ú} else {TN)rn  ro  rr  r9  z == NULL)) {z.empty_struct_error_flag = 0;ru  z = PyTuple_GET_ITEM(rÔ   )rp  ro  rn  r©  ©rn  rO  r¡  z.unbox(r   z = VecTApi.unbox(z = VecNestedApi.unbox(zif (VEC_IS_ERROR(r:  zUnboxing not implemented: %s).r‚   r`   r  r„   r‡   r’   r”   rl  r2   r:   rÇ   r„  r(   r5   r1   Ú/emit_unbox_failure_with_overlapping_error_valuer0   r/   r=   r-   rÊ   r#   r\  r   rÞ   rŠ  r  rQ  r  rà   rÄ   Ú
emit_unboxr`  r>   r–  rÎ   ri  r&   r@   rä   rT  r‹  r�  rA   ra   rŒ  )re   r�  rb  r#  rn  ro  rp  rq  r©  Úerror_actionÚfailureÚ	raise_excÚ
conversionÚitem_error_labelsÚ	cast_tempr"  rT  ÚtempÚtemp2Úitem_error_labelÚ
done_labelÚfailed_itemÚprevious_indexÚprevious_typeÚspecialized_api_namer‹  r”  r•  s                               rf   r®  zEmitter.emit_unboxÛ  s¶  € ð> Ò(œ›ˆä�eœ]Ô+Ø"˜V 3 t×'9Ñ'9¸#Ó'>Ð&?¸qÐA‰LÜ˜œ{Ô+Ø%¨¯©Ñ3‰Lä˜e¤]Ô3Ð:°UÓ:Ð3Ø'¨%¯+©+Ñ5ˆLØˆÙØ)¨$×*:Ñ*:¸3Ó*?Ð)@ÀÀCÀ5ÈÐLˆIØ 'Ñ)ˆGÜ˜SÔ!Ô%<¸SÔ%AÙØ—‘ ¨D¨6°Ð3Ô4Ø×Ñ  T¨3Ð2GÈÀuÈCÐ0PÐRZÔ[ÙØ—‘  d VÐ+IÈ#ÈÈbÐQÕRà—‘  d VÐ+CÀCÀ5ÈÐKÔLØ�N‰N˜8Ô$Ø�N‰N˜7Ô#Ø�N‰N˜3ÕÜ& sÔ+áØ—‘  t f¨A˜Ô/Ø×Ñ  T¨3Ð2JÈ3È%ÈvÐ0VÐX`ÔaØ�N‰N˜7Ô#Ø�N‰N˜8Ô$Ø˜5 Ð,ˆJØ�N‰N˜T $  s¨:¨,°aÐ8Õ9Ü Ô$áØ—‘  t f¨A˜Ô/Ø×Ñ  T¨3°*¸S¸EÐAQÐ0RÐT\Ô]Ø�N‰N˜7Ô#Ø�N‰N˜8Ô$Ø�N‰N˜T $  uÐ-Õ.Ü  Ô%áÐ�<ÙØ—‘ ¨$¨¨qÐ1Ô2Ø�N‰N˜d˜VÐ#6°s°e¸2Ð>Ô?Ü˜e¤]Ô3Ø×DÑDÀTÈ3ÐPWÕXð 4ä  Ô%áÐ�<ÙØ—‘ ¨$¨¨qÐ1Ô2Ø�N‰N˜d˜VÐ#6°s°e¸2Ð>Ô?Ü˜e¤]Ô3Ø×DÑDÀTÈ3ÐPWÕXð 4ä  Ô%áÐ�<ÙØ—‘ ¨$¨¨qÐ1Ô2Ø�N‰N˜d˜VÐ#6°s°e¸2Ð>Ô?Ü˜e¤]Ô3Ø×DÑDÀTÈ3ÐPWÕXð 4ä  Ô%áÐ�<ÙØ—‘ ¨$¨¨qÐ1Ô2Ø�N‰N˜d˜VÐ#6°s°e¸2Ð>Ô?Ü˜e¤]Ô3Ø×DÑDÀTÈ3ÐPWÕXð 4ä  Ô%ÙÐ�<ÙØ—‘ ¨¨¨aÐ0Ô1à�N‰N˜d˜VÐ#7¸°u¸BÐ?Ô@Ø�O‰O˜d 4 &Ð(HÐIÈ7ÐTWÕXÜ˜œVÕ$Ø×%Ñ% cÔ*ÙØ—‘ $§*¡*¨S£/Ð!2°!°D°6¸Ð;Ô<ÙØ—‘  c U¨,Ð7Ô8Ø—‘ $  s¨4×+=Ñ+=¸cÓ+BÐ*CÀ1ÐEÔFØ—‘˜zÔ*à79ÐØŸ™Ó(ˆIØ× Ñ Ø�Y °$¸eÈdð !ô ð �N‰N˜]¨9¨+°]ÐCÔDð
 �N‰N˜7Ô#Ø�N‰N˜:Ô&Ø—9’9Ø—‘ $ Ð'DÐEÔFÜ )¨#¯)©)Ó 4ò :‘��9Ø—~‘~Ó'�à—‘ ¨D¨6Ð1EÀcÀUÈ"ÈQÈCÈrÐRÔSØŸ™Ó(�à×'Ò'Ø'+§~¡~Ó'7Ð$Ø%×,Ñ,Ð.>ÀÐ-BÔCØ—O‘OØØØ!ð
 )8Ò(`Ä
È5ÔR_Ó@`Ð<`Ü)Ð*:Ó;Ø%)Ø%ð $õ ñ "Ø×)Ñ)¨$Ô0AÔBØ—N‘N 4¨°	È�NÔMØ—‘ $  r¨!¨¨C°¨w°aÐ8Õ9ð5:ð6 �N‰N˜3ÔÙ Ø!Ÿ^™^Ó-�
Ø—‘  z l°!Ð4Ô5Ø5Fò 	>Ñ1Ð$ kØ—O‘OÐ$4Ô5ñ "Ü=FÀsÇyÁyÐQ]ÐR]ÐG^Ó=_ò ZÑ9˜N¨MØ ×-Ñ-°°°b¸Ð8HÐ.IÈ=ÕYðZà—N‘N <Ô0Ü! %¬Õ7ØŸ™¨¨z¨l¸!Ð'<Õ=ð	>ð —‘ 
Ô+ÙØ—‘˜sÕ#ð ä˜œTÕ"ÙØ—‘ $§*¡*¨S£/Ð!2°!°D°6¸Ð;Ô<áØ—‘  c U¨,Ð7Ô8Ø—‘ $  s¨4×+=Ñ+=¸cÓ+BÐ*CÀ1ÐEÔFØ—‘˜zÔ*ä#7×#;Ñ#;¸C¿M¹MÓ#JÐ Ø#Ð/Ø—‘ $  sÐ+?Ð*@ÀÈÀuÈBÐOÕPàŸ	™	›�Ø×0Ñ0Ó2�	ØÔ 2Ñ2Ü!$Ô%7¸	Ñ%BÓ!C‘Jà!%×!5Ñ!5°cÓ!:�JØ˜A’:Ø—N‘N d VÐ+<¸S¸EÀÀJÀ<ÈrÐ#RÕSà—N‘N d VÐ+AÀ#ÀÀbÈÈÐTVÐW\ÐV]Ð]_Ð#`Ôaà�N‰NÐ.¨t¨f°EÐ:Ô;Ø�N‰N˜7Ô#Ø�N‰N˜3ÔáØ—‘˜sÕ#ð ð ?Ð8¸3Ñ>Ó>�5rh   c                ó†   — |j                  «       }| j                  |«      }|€J ‚d|› �}|j                  «       rd|› d�}|S )Nz(size_t)r  z | 1))r�  Ú
type_c_ptrÚis_optional)re   r#  rT  r¾  r•  s        rf   rŒ  zEmitter.vec_item_type_c®  sT   € Ø×(Ñ(Ó*ˆ	Ø—_‘_ YÓ/ˆ
àÐ%Ð%Ð%Ø 
˜|Ð,ˆ
Ø�?‰?ÔØ˜Z˜L¨Ð.ˆJØÐrh   c                óÄ   — t        |t        «      r%|j                  rdt        |j                     d   z   S t        |t
        «      r| j                  |j                  «      S y )Nú&rÜ   )r`   r"   rj  rD   r¬   r!   rû   r†  )re   r#  s     rf   r¾  zEmitter.type_c_ptr¸  sO   € Ü�cœ:Ô&¨3×+<Ò+<Øœ s§x¡xÑ0°Ñ3Ñ3Ð3Ü˜œYÔ'Ø×(Ñ(¨¯©Ó6Ð6Ørh   c                ó^  — |rd}nd}t        |«      st        |«      r| j                  |› |› d|› d�«       yt        |«      r3| j	                  |› |› d|› d�«       |s| j                  |t        «       yyt        |«      r0| j	                  |› |› d�«       |s| j                  |t        «       yyt        |«      st        |«      st        |«      r| j                  |› |› d|› d�«       yt        |«      r| j                  |› |› d	|› d�«       yt        |«      r| j                  |› |› d
|› d�«       yt        |t        «      �r&| j                  |«       |j                   s| j                  |› |› d�«       y| j                  |› |› dt#        |j                   «      › d�«       | j                  d|› d�«       | j                  d«       t%        t#        |j                   «      «      D ]~  }|j&                  s| j                  d|› d|› d|› d|› �«       Œ-| j)                  «       }| j+                  |› d|› �||j                   |   d¬«       | j                  d|› d|› d|› d�«       Œ€ yt        |t,        «      rŠt/        j0                  |j2                  «      }	|	�|	}
nI|j5                  «       dkD  rd}
n3d}
| j7                  |«      }| j                  |› |› d|
› d|› d|› d�	«       y| j                  |› |› d|
› d|› d�«       y|j&                  rJ ‚| j                  |› |› d|› d�«       y)zÏEmit code for boxing a value of given type.

        Generate a simple assignment if no boxing is needed.

        The source reference count is stolen for the result (no need to decref afterwards).
        ru  r¶   z = CPyTagged_StealAsObject(r_  r  z ? Py_True : Py_False;z = Py_None;z = PyLong_FromLong(z = PyLong_FromLongLong(z = PyFloat_FromDouble(z% = CPyTuple_LoadEmptyTupleConstant();z = PyTuple_New(r9  z
 == NULL))z    CPyError_OutOfMemory();zPyTuple_SET_ITEM(rÔ   rO  Tr¬  Nr   ÚVecNestedApiÚVecTApiz.box(r  )r2   r:   rÇ   r(   rÊ   r`  r>   r5   r0   r/   r=   r1   r-   r`   r#   r\  r  r¹   r‡  r  rÞ   Úemit_boxr&   r@   rä   rT  r‹  rŒ  )re   r�  rb  r#  rn  Ú
can_borrowÚdeclarationr"  Ú
inner_namer¼  ÚapirT  s               rf   rÅ  zEmitter.emit_box¿  s0  € ñ Ø&‰KàˆKÜ˜SÔ!Ô%<¸SÔ%Aà�N‰N˜k˜]¨4¨&Ð0KÈCÈ5ÐPRÐSÕTÜ& sÔ+ð �O‰O˜{˜m¨D¨6°°S°EÐ9OÐPÔQÙØ×!Ñ! $Ô(9Õ:ð ä Ô$ð �O‰O˜{˜m¨D¨6°Ð=Ô>ÙØ×!Ñ! $Ô(9Õ:ð ä  Ô%Ô)<¸SÔ)AÔEXÐY\ÔE]Ø�N‰N˜k˜]¨4¨&Ð0CÀCÀ5ÈÐKÕLÜ  Ô%Ø�N‰N˜k˜]¨4¨&Ð0GÈÀuÈBÐOÕPÜ  Ô%Ø�N‰N˜k˜]¨4¨&Ð0FÀsÀeÈ2ÐNÕOÜ˜œVÕ$Ø×%Ñ% cÔ*Ø—9’9Ø—‘ + ¨t¨fÐ4YÐZÕ[à—‘ + ¨t¨f°OÄCÈÏ	É	ÃNÐCSÐSUÐVÔWØ—‘ ¨t¨f°JÐ?Ô@Ø—‘Ð<Ô=ô œs 3§9¡9›~Ó.ò X�AØŸ>š>ØŸ™Ð):¸4¸&ÀÀ1À#ÀRÈÀuÈBÈqÈcÐ'RÕSà%)§^¡^Ó%5˜
ØŸ™¨¨¨R°¨s m°ZÀÇÁÈ1ÁÐ\`˜ÔaØŸ™Ð):¸4¸&ÀÀ1À#ÀRÈ
À|ÐSUÐ'VÕWñXô ˜œTÔ"Ü#7×#;Ñ#;¸C¿M¹MÓ#JÐ Ø#Ð/Ø*‘Ø—‘“˜q’Ø$‘à�ð !×0Ñ0°Ó5�	Ø—‘ + ¨t¨f°C¸°u¸EÀ#ÀÀbÈÈÐSUÐVÔWØØ�N‰N˜k˜]¨4¨&°°C°5¸¸c¸UÀ"ÐEÕFà—~’~Ð%Ð%à�N‰N˜k˜]¨4¨&°°C°5¸Ð:Õ;rh   c                óä  — t        |t        «      rMt        |j                  «      dk(  ry| j	                  ||| j
                  d«      }| j                  d|› d�«       n�t        |t        «      r| j                  d|› d�«       n[|j                  r(| j                  d|› d| j                  |«      › d�«       n'| j                  d|› d| j                  |«      › d�«       | j                  |d	«       y)
zMEmit code for checking a native function return value for uncaught exception.r   Nr8  rB  rC  z.len < 0) {ú == ú && PyErr_Occurred()) {r¿   )
r`   r#   r¹   r  rM  r  rÇ   r&   rD  rÊ   )re   r”   rÿ   r°  Úconds        rf   Úemit_error_checkzEmitter.emit_error_check  sÙ   € ä�eœVÔ$Ü�5—;‘;Ó 1Ò$Øà×6Ñ6°u¸eÀT×EWÑEWÐY]Ó^�Ø—‘  d V¨4Ð0Õ1Ü˜œtÔ$Ø�N‰N˜T % ¨Ð5Õ6Ø× Ò ð �N‰N˜T % ¨¨T×-?Ñ-?ÀÓ-FÐ,GÐG_Ð`Õaà�N‰N˜T % ¨¨T×-?Ñ-?ÀÓ-FÐ,GÀtÐLÔMØ�‰˜ Õ%rh   c           	     óT  — |j                   syt        |t        «      rK|j                  dk(  r<| j	                  d|› d�«       | j	                  d|› d�«       | j	                  d«       yt        |t
        «      r5t        |j                  «      D ]  \  }}| j                  |› d|› �|«       Œ yt        |t        «      r/t        |j                     }| j	                  d	|› d
|› d|› d�«       y| j                  |«      dk(  r| j	                  d|› d�«       yJ dt        |«      z  «       ‚)z­Emit code for GC visiting a C variable reference.

        Assume that 'target' represents a C expression that refers to a
        struct member, such as 'self->x'.
        Núbuiltins.intúif (CPyTagged_CheckLong(r:  z Py_VISIT(CPyTagged_LongAsObject(ú));r¿   rO  rB  z.items) { Py_VISIT(ú_BUF(z)); }ru  z	Py_VISIT(r_  z&emit_gc_visit() not implemented for %s)rj  r`   r"   r¬   rÇ   r#   rQ  r  Úemit_gc_visitr&   rX   rý   r   Úrepr©re   r	  rÿ   r"  rT  rô   s         rf   rÔ  zEmitter.emit_gc_visit  s  € ð ×"Ò"àÜ˜œzÔ*¨u¯z©z¸^Ò/KØ�N‰NÐ5°f°X¸UÐCÔDØ�N‰NÐ=¸f¸XÀSÐIÔJØ�N‰N˜3ÕÜ˜œvÔ&Ü )¨%¯+©+Ó 6ò @‘��9Ø×"Ñ" f X¨R°¨sÐ#3°YÕ?ñ@ä˜œtÔ$Ü% e§l¡lÑ3ˆFØ�N‰N˜T & Ð)=¸f¸XÀUÈ6È(ÐRXÐYÕZØ�Z‰Z˜Ó ,Ò.à�N‰N˜Y v h¨bÐ1Õ2àPÐBÄTÈ%Ã[ÑPÓP�5rh   c                óZ  — |j                   syt        |t        «      r‚|j                  dk(  rs| j	                  d|› d�«       | j	                  d|› d�«       | j	                  |› d| j                  |«      › d�«       | j	                  d«       | j	                  d	«       yt        |t        «      r5t        |j                  «      D ]  \  }}| j                  |› d
|› �|«       Œ yt        |t        «      rgt        |j                     }| j	                  d|› d�«       | j	                  d|› d|› d�«       | j	                  d|› d�«       | j	                  d	«       y| j                  |«      dk(  r*| j                  |«      dk(  r| j	                  d|› d�«       yJ dt        |«      z  «       ‚)z²Emit code for clearing a C attribute reference for GC.

        Assume that 'target' represents a C expression that refers to a
        struct member, such as 'self->x'.
        NrÐ  rÑ  r:  úCPyTagged __tmp = r  r  ú*Py_XDECREF(CPyTagged_LongAsObject(__tmp));r¿   rO  rB  z	.items) {z    Py_DECREF(rÓ  rÒ  rv  r  ru  r  z	Py_CLEAR(r_  z&emit_gc_clear() not implemented for %s)rj  r`   r"   r¬   rÇ   r  r#   rQ  r  Úemit_gc_clearr&   rX   rý   r   rÕ  rÖ  s         rf   rÚ  zEmitter.emit_gc_clear3  sˆ  € ð ×"Ò"àÜ˜œzÔ*¨u¯z©z¸^Ò/KØ�N‰NÐ5°f°X¸UÐCÔDØ�N‰NÐ/°¨x°qÐ9Ô:Ø�N‰N˜f˜X S¨×)?Ñ)?ÀÓ)FÐ(GÀqÐIÔJØ�N‰NÐGÔHØ�N‰N˜3ÕÜ˜œvÔ&Ü )¨%¯+©+Ó 6ò @‘��9Ø×"Ñ" f X¨R°¨sÐ#3°YÕ?ñ@ä˜œtÔ$Ü% e§l¡lÑ3ˆFØ�N‰N˜T & ¨Ð4Ô5Ø�N‰N˜^¨F¨8°5¸¸ÀÐDÔEØ�N‰N˜T & ¨Ð8Ô9Ø�N‰N˜3ÕØ�Z‰Z˜Ó ,Ò.°4×3IÑ3IÈ%Ó3PÐTZÒ3Zà�N‰N˜Y v h¨bÐ1Õ2àPÐBÄTÈ%Ã[ÑPÓP�5rh   c                ó   — t        |t        «      r5t        |j                  «      D ]  \  }}| j	                  |› d|› �|«       Œ y|j
                  s"| j                  |› d|j                  › d�«       yt        |t        «      r¹|j                  dk(  rª| j                  d|› d�«       | j                  d|› d�«       | j                  |› d| j                  |«      › d�«       | j                  d«       | j                  d	«       | j                  |› d| j                  |«      › d�«       | j                  d
«       y| j                  ||«       y)a  Emit attribute clear before object is added into freelist.

        Assume that 'target' represents a C expression that refers to a
        struct member, such as 'self->x'.

        Unlike emit_gc_clear(), initialize attribute value to match a freshly
        allocated object.
        rO  r  r  rÐ  rÑ  r:  rØ  rÙ  r«  r¿   N)r`   r#   rQ  r  Úemit_reuse_clearrj  rÇ   r  r"   r¬   r  rÚ  )re   r	  rÿ   r"  rT  s        rf   rÜ  zEmitter.emit_reuse_clearQ  s0  € ô �eœVÔ$Ü )¨%¯+©+Ó 6ò C‘��9Ø×%Ñ%¨¨°°1°#Ð&6¸	ÕBñCà×$Ò$Ø�N‰N˜f˜X S¨×):Ñ):Ð(;¸1Ð=Õ>Ü˜œzÔ*¨u¯z©z¸^Ò/KØ�N‰NÐ5°f°X¸UÐCÔDØ�N‰NÐ/°¨x°qÐ9Ô:Ø�N‰N˜f˜X S¨×)?Ñ)?ÀÓ)FÐ(GÀqÐIÔJØ�N‰NÐGÔHØ�N‰N˜:Ô&Ø�N‰N˜f˜X S¨×)?Ñ)?ÀÓ)FÐ(GÀqÐIÔJØ�N‰N˜3Õà×Ñ˜v uÕ-rh   c                ó*   — | j                  d|||«      S )NÚCPy_AddTraceback)Ú_emit_traceback)re   r�   rŽ   r�   s       rf   rž  zEmitter.emit_tracebackj  s   € ð ×#Ñ#Ð$6¸À[ÐRaÓbÐbrh   c               ó^   — d}d| j                  |«      › d�}| j                  ||||||¬«      S )NÚCPy_TypeErrorTracebackú")Útype_strr�  )rl  rß  )re   r�   rŽ   r�   r#  r�  Úfuncrã  s           rf   r�  z!Emitter.emit_type_error_tracebacko  sI   € ð (ˆØ�t×'Ñ'¨Ó,Ð-¨QÐ/ˆØ×#Ñ#Ø�+˜{¨OÀhÐTWð $ó 
ð 	
rh   c                ó0  — | j                   j                  r|d   dk\  sJ d«       ‚| j                  d|«      }d||j                  dd«      |d   |d   |fz  }|r|sJ ‚|d|› d|› �z  }|d	z  }| j	                  |«       t
        r| j	                  d
«       y y )NrÜ   r   z,Traceback cannot have a negative line numberÚglobalsz%s("%s", "%s", %d, %sú\z\\rÔ   r_  z7assert(PyErr_Occurred() != NULL && "failure w/o err!");)r™   r|   rø   rÕ   rÇ   rF   )	re   rä  r�   rŽ   r�   rã  r�  Úglobals_staticr»   s	            rf   rß  zEmitter._emit_traceback~  s¾   € ð �<‰<×/Ò/Ø" 1Ñ%¨Ò*ÐZÐ,ZÓZÐ*Ø×)Ñ)¨)°[ÓAˆØ&ØØ×Ñ  fÓ-Ø˜AÑØ˜AÑØð*
ñ 
ˆñ ÙˆJ�3Ø�b˜˜
 " S EÐ*Ñ*ˆDØ�‰ˆØ�‰�tÔÝØ�N‰NÐTÕUð rh   c                ó–   — | j                  d|› d| j                  |«      › d�«       | j                  |«       | j                  d«       y )NrB  rË  rÌ  r¿   )rÇ   r  )re   rb  r#  r°  s       rf   r­  z7Emitter.emit_unbox_failure_with_overlapping_error_value™  sD   € ð 	�‰˜˜d˜V 4¨×(:Ñ(:¸3Ó(?Ð'@Ð@XÐYÔZØ�‰�wÔØ�‰�sÕrh   c                ó  — | j                  |j                  j                  d t        ¬«      }d|› d�}t        › |j                  | j                  «      › �}d|› �}d|› �}ddg}	|j                  r/|j                  j                  t        k(  r|	j                  d«       n:|j                  r.|j                  j                  t        k(  r|	j                  d	«       d
t        |«      › d�}
|j                  r|j                  j                  t        k7  rdnd}d}| j                  d|› d|› d|› d|› d|› ddj                  |	«      › d|
› d|j                  › d|› d|› d�«       | j                  d|› d�«       | j                  |«       |S )Nrú   zCPyImport_GetModuleCache(&rA  Úwrapper_z(PyCFunction)ÚMETH_FASTCALLÚMETH_KEYWORDSÚMETH_STATICÚ
METH_CLASSz
PyDoc_STR(ÚtrueÚfalseÚCO_COROUTINEz
PyObject* z = CPyFunction_New(z, "z", "rš  rÔ   z | r_  zif (unlikely(!rƒ  )rø   rb   rŽ   r   r   r  rv   Ú
class_nameÚkindr   rÄ   r   Únative_function_doc_initializerrÇ   rÖ   r»   )re   r  r¬   r    Ú
error_stmtró   r  Úwrapper_nameÚcfuncÚ
func_flagsÚdocÚhas_self_argÚ
code_flagss                rf   Úemit_cpyfunction_instancez!Emitter.emit_cpyfunction_instance   sÍ  € ð ×!Ñ! "§'¡'×"5Ñ"5°tÄMÐ!ÓRˆØ-¨f¨X°QÐ7ˆÜ�(˜2Ÿ8™8 D§J¡JÓ/Ð0Ð1ˆØ! % Ð)ˆØ ˜wÐ'ˆØ% Ð7ˆ
Ø�=Š=˜RŸW™WŸ\™\Ô->Ò>Ø×Ñ˜mÕ,Ø�]Š]˜rŸw™wŸ|™|Ô/?Ò?Ø×Ñ˜lÔ+ØÔ:¸2Ó>Ð?¸qÐAˆØ!#§¢°2·7±7·<±<ÔCTÒ3T‘vÐZaˆà#ˆ
Ø�‰Ø˜˜Ð&9¸&¸ÀÀXÀJÈdÐSWÐRXÐX[Ð\aÐ[bÐbdÐej×eoÑeoÐpzÓe{Ðd|Ð|~ð  @Cð  Dð  DFð  GI÷  GNñ  GNð  FOð  OQð  R\ð  Q]ð  ]_ð  `lð  _mð  moð  pô	
ð 	�‰˜¨ ~°RÐ8Ô9Ø�‰�zÔ"ØÐrh   rú   c          	     ó  — | j                  |«      }d|› �}| j                  d|› d|› d�«       | j                  d|› d�«       | j                  d|› d|› d�«       | j                  d«       | j                  |› |› d	|› d
|› d�«       y )NÚ_base_zPyTypeObject *r  z
->tp_base;zwhile (z#->tp_flags & Py_TPFLAGS_HEAPTYPE) {rv  r¿   z->r  r_  )rû   rÇ   )re   Ú
derived_clÚtp_funcrÙ   rô   Útype_objÚbase_vars          rf   Úemit_base_tp_function_callz"Emitter.emit_base_tp_function_call¸  s›   € ð ×(Ñ(¨Ó4ˆØ˜G˜9Ð%ˆØ�‰˜¨ z°°X°J¸jÐIÔJØ�‰˜  
Ð*NÐOÔPØ�‰˜˜h˜Z s¨8¨*°JÐ?Ô@Ø�‰�sÔØ�‰˜&˜ ( ¨2¨g¨Y°a¸°v¸RÐ@ÕArh   )NNN)
r™   rs   r�   zdict[Value, str] | Nonerœ   ztuple[int, int] | Noner    r}   rj   rk   )rj   rk   )r‡   r   rj   ra   )rª   r    rj   ra   )r¬   ra   rj   ra   )rº   Úobjectr»   ra   rj   ra   )r¶   )r»   ra   r½   r  rj   rk   )rÉ   ra   rj   rk   )r‡   zBasicBlock | strrj   rk   )rÑ   r–   rj   rk   )rØ   ra   rÙ   ra   rj   rk   )rj   ra   )rŽ   ra   rj   ra   )rº   zClassIR | FuncDeclrj   ra   )rì   r   rj   rk   )rò   ra   ró   r}   rô   ra   rj   ra   )rì   r   rj   ra   )rÿ   r$   rj   ra   )r	  ra   rÿ   r$   rj   rk   )r  r   rj   ra   )r   r#   rj   ú	list[str])r'  Úintrj   ra   )rº   ra   rì   r   r'  r  rj   ra   )r”   ra   rº   ra   rÿ   r$   rì   r   r­   ra   rj   rk   )
rº   ra   rÿ   r$   rì   r   r­   ra   rj   rk   )r”   ra   rº   ra   rÿ   r$   rì   r   r­   ra   r1  ri   rj   rk   )rÿ   r$   rE  ra   rF  ra   rº   ra   r­   ra   rì   r   r?  ri   rj   rk   )rÿ   r$   r”   ra   rF  ra   rj   ra   )r   r#   rR  ra   rS  zCallable[[RType], str]rF  ra   rL  ri   rj   ra   )r   r#   rj   ra   )r[  r#   rj   rk   )rb  ra   rÿ   r$   r]  ri   rj   rk   )
rb  ra   rÿ   r$   rd  ri   r]  ri   rj   rk   )r#  r$   rj   ra   )r�  ra   rb  ra   r#  r$   rn  ri   ro  úErrorHandler | Nonerp  ri   rq  ri   rr  úRType | Noners  ri   rj   rk   )ro  r   r�  ra   rb  ra   r#  r$   rp  ri   rj   rk   )r�  ra   rb  ra   r#  r%   rn  ri   ro  r   rq  ri   rr  r	  rp  ri   rj   rk   )r�  ra   rb  ra   r#  r#   rn  ri   ro  r   rr  r	  rj   rk   )r�  ra   rb  ra   r#  r$   r=  ra   rq  ri   rj   rk   )r�  ra   rb  ra   r#  r$   rn  ri   ro  r  rp  ri   rq  ri   r©  ri   rj   rk   )r#  r&   rj   ra   )r#  zRPrimitive | RInstancerj   r}   )FF)r�  ra   rb  ra   r#  r$   rn  ri   rÆ  ri   rj   rk   )r”   ra   rÿ   r$   r°  ra   rj   rk   )r�   ra   rŽ   ra   r�   r�   rj   rk   )r�   ra   rŽ   ra   r�   r�   r#  r$   r�  ra   rj   rk   )r¶   r¶   )rä  ra   r�   ra   rŽ   ra   r�   r�   rã  ra   r�  ra   rj   rk   )rb  ra   r#  r$   r°  ra   rj   rk   )
r  r   r¬   ra   r    ra   rö  ra   rj   ra   )
r   r   r  ra   rÙ   ra   rô   ra   rj   rk   )Brm   rn   ro   rp   rg   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.  r4  r6  r3  rI  r;  rM  r  rV  r\  r`  ri  rl  r–  r…  r‰  rŠ  r„  r®  rŒ  r¾  rÅ  rÎ  rÔ  rÚ  rÜ  rž  r�  rß  r­  rý  r  rq   rh   rf   r–   r–   Ï   sü  „ Ù'ð
 04Ø/3Ø#ð!àð!ð -ð!ð -ð	!ð
 ð!ð 
ó!ó"ó!ó&ó2ó"ó
%ð¸õ ó!ó	.ó1ó*ó
5ó4óó4=ó

6ð FSô ;ó"MóóóKó	ó-ó8óMóLóó* ó(ðPØðPØ"ðPØ+0ðPØ6=ðPØEHðPà	óPóLð Øð Ø"ð Ø+0ð Ø6=ð ØEHð ØQUð à	ó ð2 ñ+àð+ð ð+ð ð	+ð
 ð+ð ð+ð ð+ð ð+ð 
ó+ó,Dð* !%ñ"àð"ð ð"ð 3ð	"ð
 ð"ð ð"ð 
ó"óHVó1ó 
ð EJõ @ð8 ;@Èeñ!AØð!AØ %ð!AØ37ð!AØGKð!Aà	ó!AóHð #Ø%)Ø $ØØ!%Øñ_;àð_;ð ð_;ð ð	_;ð ð_;ð #ð_;ð ð_;ð ð_;ð ð_;ð ð_;ð 
ó_;ðB7Ø!ð7Ø(+ð7Ø36ð7Ø=Bð7ØUYð7à	ó7ð0$$àð$$ð ð$$ð ð	$$ð
 ð$$ð ð$$ð ð$$ð ð$$ð ð$$ð 
ó$$ðL(#àð(#ð ð(#ð ð	(#ð
 ð(#ð ð(#ð ð(#ð 
ó(#óT%ð #Ø%)Ø $ØØñQ?àðQ?ð ðQ?ð ð	Q?ð ðQ?ð #ðQ?ð ðQ?ð ðQ?ð ðQ?ð 
óQ?ófóð _dðG<ØðG<Ø!ðG<Ø(-ðG<Ø=AðG<ØW[ðG<à	óG<óR&ó$Qó2Qó<.ð2cØðcØ-0ðcØCRðcà	ócð

àð
ð ð
ð )ð	
ð ð
ð ð
ð 
ó
ð* ØðVàðVð ðVð ð	Vð
 )ðVð ðVð ðVð 
óVð6ØðØ#ðØ.1ðà	óðØðØ #ðØ/2ðØ@Cðà	óð2 NPñBØ!ðBØ,/ðBØ7:ðBØGJðBà	ôBrh   r–   )Úindentedc               óÀ  — |rdnd}g }g }d}| D ]x  }|r |dz   t        |«      z   t        |«      z   dk  r#|j                  |«       |t        |«      dz   z  }ŒH|j                  |dj                  |«      z   «       |g}t        |«      }Œz |sddj                  |«      z  S |j                  |dj                  |«      z   «       dd	j                  |«      z   d
z   |z   dz   S )a4  Construct an initializer for a C array variable.

    Components are C expressions valid in an initializer.

    For example, if components are ["1", "2"], the result
    would be "{1, 2}", which can be used like this:

        int a[] = {1, 2};

    If the result is long, split it into multiple lines.
    rv  r¶   r   r˜   éF   rÔ   z{%s}z{
    z,
    rÁ   r¿   )r¹   rÄ   rÖ   )Ú
componentsr
  r¥   ÚresÚcurrentÚcur_lenÚcs          rf   Úc_array_initializerr  È  sé   € ñ !‰W b€FØ
€CØ€GØ€GØò ˆÙ˜' A™+¬¨F«Ñ3´c¸!³fÑ<¸rÒAØ�N‰N˜1ÔØ”s˜1“v ‘zÑ!‰Gà�J‰J�v §	¡	¨'Ó 2Ñ2Ô3Ø�cˆGÜ˜!“f‰Gðñ à˜Ÿ	™	 'Ó*Ñ*Ð*à‡J�Jˆv˜Ÿ	™	 'Ó*Ñ*Ô+Ø�y—~‘~ cÓ*Ñ*¨TÑ1°FÑ:¸SÑ@Ð@rh   c                ó`   — t        | «      }|€y|› d�}t        |j                  dd¬«      «      S )Nr  z
--

ÚasciiÚbackslashreplace)Úerrors)r   r   Úencode)rä  Útext_sigÚ	docstrings      rf   rõ  rõ  è  s=   € Ü! $Ó'€HØÐØØ�*˜HÐ%€IÜ 	× 0Ñ 0°ÐASÐ 0Ó TÓUÐUrh   c                ó<  — t        | t        «      r2| sydj                  d„ t        | t        ¬«      D «       «      }d|z   dz   S t        | t
        «      r@t        | «      dk(  rdt        | d	   «      z   d
z   S ddj                  d„ | D «       «      z   dz   S t        | «      S )zËReturn a single-line repr of a literal value.

    Behaves like repr() for most values, but renders frozenset members in a
    deterministic order (frozenset iteration order is hash-seed dependent).
    zfrozenset()rÔ   c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr_   ©r·   ©r°   r£  s     rf   r³   z&stable_literal_repr.<locals>.<genexpr>ù  s   è ø€ Òb¸Ô-¨d×3Ñbùó   ‚)Úkeyzfrozenset({z})rÜ   r  r   z,)c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr_   r  r  s     rf   r³   z&stable_literal_repr.<locals>.<genexpr>þ  s   è ø€ ÒI¸TÔ2°4×8ÑIùr  rA  )	r`   Ú	frozensetrÖ   Úsortedr   Útupler¹   r·   rÕ  )rº   rY  s     rf   r·   r·   ð  s˜   € ô �#”yÔ!ÙØ Ø—	‘	ÑbÄÀsÔP`Ô@aÔbÓbˆØ˜uÑ$ tÑ+Ð+Ü	�CœÔ	Üˆs‹8�qŠ=ØÔ,¨S°©VÓ4Ñ4°tÑ;Ð;Ø�T—Y‘YÑIÀSÔIÓIÑIÈCÑOÐOÜ�‹9Ðrh   )r  r  r
  ri   rj   ra   )rä  r   rj   ra   )rº   r  rj   ra   )arp   Ú
__future__r   rš   Úcollections.abcr   Útypingr   Úmypyc.codegen.cstringr   Úmypyc.codegen.literalsr   r   Úmypyc.commonr	   r
   r   r   r   r   r   r   r   r   r   Úmypyc.ir.class_irr   r   Úmypyc.ir.func_irr   r   r   r   r   Úmypyc.ir.opsr   r   r   r   r   r    Úmypyc.ir.rtypesr!   r"   r#   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   Úmypyc.namegenrB   rC   Úmypyc.primitives.registryrD   Úmypyc.sametyperE   rF   Ú__annotations__rG   rX   rZ   rs   r   r‚   r„   r‹   r’   r–   r  rõ  r·   rq   rh   rf   ú<module>r2     sQ  ðÚ $å "ã 
Ý $Ý å 6ß =÷÷ ÷ ñ ÷ <÷õ ÷÷ ÷"÷ "÷ "÷ "÷ "÷ "÷ "÷ "õ "÷F 7Ý 3Ý 'ð €ˆeÓ ð �mØ�KØ�mØ˜ð	€
ˆEó ð ØØØØØØØñ	Ð �%ó 	÷)ñ )÷@#?ñ #?÷L>ñ >ô*�Lô *ô�,ô ô	/˜lô 	/ô�Lô ÷vBñ vBðr' DIõ Aó@Vôrh   