Ë
    pPêj.Ì  ã                  ón  — d 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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 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-m.Z.m/Z/ dd	l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB dd
lCmDZD ddlEmFZF ddlGmHZHmIZI ddlJmKZKmLZLmMZMmNZN ddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZV ddlWmXZXmYZY ddlZm[Z[m\Z\m]Z]m^Z^ ddl_m`Z`maZambZbmcZc ddldmeZe ddlfmgZg ddlhmiZi ddljmkZk ddllmmZm eg df   Zn	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d@d„Zo	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dAd„Zp	 	 	 	 	 	 	 	 	 	 dBd„ZqdCd„Zr	 	 	 	 	 	 dDd„ZsdCd„Ztddœ	 	 	 	 	 	 	 	 	 dEd„Zu	 	 	 	 	 	 	 	 	 	 dFd „ZvdGd!„Zw	 	 dH	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dId#„Zx G d$„ d"«      Zy G d%„ d&ey«      Zz G d'„ d(ey«      Z{ G d)„ d*ey«      Z|dJd+„Z} G d,„ d-ey«      Z~ G d.„ d/ey«      Z G d0„ d1e«      Z€ G d2„ d3e«      Z� G d4„ d5e«      Z‚ G d6„ d7ey«      Zƒ G d8„ d9ey«      Z„ G d:„ d;ey«      Z… G d<„ d=ey«      Z†dKd>„Z‡	 	 	 	 	 	 	 	 	 	 	 	 dLd?„Zˆy)MzÕHelpers for generating for loops and comprehensions.

We special case certain kinds for loops such as "for x in range(...)"
for better efficiency.  Each for loop generator class below deals one
such special case.
é    )Úannotations)ÚCallable)ÚClassVarÚcast)ÚARG_POSÚCallExprÚDictionaryComprehensionÚ
ExpressionÚGeneratorExprÚListExprÚLvalueÚ
MemberExprÚNameExprÚRefExprÚSetExprÚStarExprÚ	TupleExprÚ	TypeAliasÚVar)ÚLiteralTypeÚ	TupleTypeÚget_proper_typeÚget_proper_types)ÚGENERATOR_HELPER_NAMEÚIS_FREE_THREADED)Ú	ERR_NEVERÚ
BasicBlockÚBranchÚIntegerÚIntOpÚLoadAddressÚLoadErrorValueÚ
LoadGlobalÚLoadLiteralÚ
MethodCallÚRaiseStandardErrorÚRegisterÚTupleGetÚTupleSetÚValue)Ú	RInstanceÚRTupleÚRTypeÚRVecÚbool_rprimitiveÚc_pyssize_t_rprimitiveÚint_rprimitiveÚis_dict_rprimitiveÚis_fixed_width_rtypeÚis_immutable_rprimitiveÚis_list_rprimitiveÚis_sequence_rprimitiveÚis_short_int_rprimitiveÚis_str_rprimitiveÚis_tuple_rprimitiveÚobject_pointer_rprimitiveÚobject_rprimitiveÚshort_int_rprimitive)Ú	IRBuilder)Úconstant_fold_expr)ÚAssignmentTargetÚAssignmentTargetTuple)Ú
vec_appendÚ
vec_createÚvec_get_item_unsafeÚvec_init_item_unsafe)Údict_check_size_opÚdict_item_iter_opÚdict_key_iter_opÚdict_next_item_opÚdict_next_key_opÚdict_next_value_opÚdict_value_iter_op)Úno_err_occurred_opÚpropagate_if_error_op)Úaiter_opÚanext_opÚiter_opÚnext_op)Úlist_append_opÚlist_get_item_int64_opÚlist_get_item_unsafe_opÚnew_list_set_item_op)Ústop_async_iteration_op)ÚCFunctionDescription)Ú
set_add_op)Ústr_get_item_unsafe_op)Útuple_get_item_unsafe_opNc           	     ól  — t        «       }t        «       }t        «       }	t        «       }
|�|	n|
}t        | ||||||¬«      }| j                  ||
«       t        «       }| j                  |«       |j	                  «        | j                  |«       |j                  «         |«        | j                  |«       |j                  «        | j                  |«       |j                  |«       | j                  «        |�)| j                  |	«        |«        | j                  |
«       | j                  |
«       y)a  Generate IR for a loop.

    Args:
        index: the loop index Lvalue
        expr: the expression to iterate over
        body_insts: a function that generates the body of the loop
        else_insts: a function that generates the else block instructions
    N)Úis_async)r   Úmake_for_loop_generatorÚpush_loop_stackÚgoto_and_activateÚgen_conditionÚactivate_blockÚ
begin_bodyÚgen_stepÚgotoÚadd_cleanupÚpop_loop_stack)ÚbuilderÚindexÚexprÚ
body_instsÚ
else_instsr\   ÚlineÚ
body_blockÚ
step_blockÚ
else_blockÚ
exit_blockÚnormal_loop_exitÚfor_genÚcondition_blocks                 ú^/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypyc/irbuild/for_helpers.pyÚfor_loop_helperru   c   s  € ô$ “€Jä“€Jä“€Jä“€Jð &0Ð%;‘zÀÐä%Ø�˜˜jÐ*:¸DÈ8ô€Gð ×Ñ˜J¨
Ô3Ü “l€OØ×Ñ˜oÔ.ð ×ÑÔð ×Ñ˜:Ô&Ø×ÑÔÙ„Lð ×Ñ˜jÔ)Ø×ÑÔà‡L�L�Ô!à×ÑÐ(Ô)Ø×ÑÔàÐØ×Ñ˜zÔ*ÙŒØ�‰�ZÔ à×Ñ˜:Õ&ó    c                ó|  — t        |j                  «      s-t        |j                  t        «      sJ ||j                  f«       ‚| j	                  |«      }t        «       }t        «       }	t        «       }
t        «       }t        | |||
|d«      }|j                  ||d|¬«       | j                  |	|
«       t        |t        «      r2|j                  dkD  r#| j                  |«       | j                  |«       n| j                  |«       |j                  «        | j                  |«       |j                  «         || j!                  |j"                  |«      «       | j                  |	«       |j%                  «        | j                  |«       |j'                  |
«       | j)                  «        | j                  |
«       y)a}  Generate IR for a sequence iteration.

    This function only works for sequence type. Compared to for_loop_helper,
    it would feed iteration index to body_insts.

    Args:
        index: the loop index Lvalue
        expr: the expression to iterate over
        body_insts: a function that generates the body of the loop.
                    It needs a index as parameter.
    F)ÚreverseÚlengthr   N)r6   ÚtypeÚ
isinstancer.   Úget_sequence_typer   ÚForSequenceÚinitr^   r   Úvaluerd   ra   r_   r`   rb   ÚreadÚindex_targetrc   re   rf   )rg   rh   ri   Úexpr_regrj   rl   ry   Útarget_typerm   rn   rp   rs   rr   s                rt   Úfor_loop_helper_with_indexr„   ¡   sj  € ô( " (§-¡-Ô0´J¸x¿}¹}ÌdÔ4Sð ØØ�‰ðVó ÐSð ×+Ñ+¨DÓ1€Kä“€JÜ“€JÜ“€JÜ “l€Oä˜' 5¨*°jÀ$ÈÓN€GØ‡L�L�˜;°¸f€LÔEà×Ñ˜J¨
Ô3ä�&œ'Ô" v§|¡|°aÒ'7Ø�‰�ZÔ Ø×Ñ˜Õ/à×!Ñ! /Ô2à×ÑÔà×Ñ˜:Ô&Ø×ÑÔÙˆw�|‰|˜G×0Ñ0°$Ó7Ô8à×Ñ˜jÔ)Ø×ÑÔØ‡L�L�Ô!à×Ñ˜
Ô#Ø×ÑÔà×Ñ˜:Õ&rv   c           	     ó‚  ‡ ‡‡‡‡— t        ‰j                  «      dk(  �rt        ‰j                  «      dk(  �rýt        ‰j                  d   «      dk(  �rá‰j                  Š‰j                  d   }‰ j                  |«      }t        |«      st        |t        t        f«      syt        |t        «      �r.t        ‰ j                  |   «      }t        |t        «      sJ |«       ‚|j                  syt        |j                  «      }t        d„ |D «       «      r6|D �cg c]*  }t!        t#        t$        |«      j&                  t(        «      ‘Œ, }	}nc‰ j+                  |«      }
t-        |«      D ��cg c]<  \  }}t        |t$        «      rt!        |j&                  t(        «      nt/        |
|‰«      ‘Œ> }	}}t1        t3        ‰ j4                  |	«      «      }‰ j7                  |‰«      }
n‰ j+                  |«      }
t9        ‰ ||
‰d¬«      } ||‰«      Šdˆ ˆˆˆˆfd„}t;        ‰ ‰j                  d   ||
|‰|«       ‰S yc c}w c c}}w )	a	  Generate a new tuple or list from a simple generator expression.

    Currently we only optimize for simplest generator expression, which means that
    there is no condition list in the generator and only one original sequence with
    one index is allowed.

    e.g.  (1) tuple(f(x) for x in a_list/a_tuple/a_str/a_bytes/an_rtuple)
          (2) list(f(x) for x in a_list/a_tuple/a_str/a_bytes/an_rtuple)
          (3) [f(x) for x in a_list/a_tuple/a_str/a_bytes/an_rtuple]

    Args:
        empty_op_llbuilder: A function that can generate an empty sequence op when
            passed in length. See `new_list_op_with_length` and `new_tuple_op_with_length`
            for detailed implementation.
        set_item_op: A primitive that can modify an arbitrary position of a sequence.
            The op should have three arguments:
                - Self
                - Target position
                - New Value
            See `new_list_set_item_op` and `new_tuple_set_item_op` for detailed
            implementation.
    é   r   Nc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­w©N)r{   r   )Ú.0Útyps     rt   ú	<genexpr>z=sequence_from_generator_preallocate_helper.<locals>.<genexpr>  s   è ø€ ÒH°C”:˜c¤;×/ÑHùó   ‚T©Úuse_pyssize_tc                óž   •— ‰j                  ‰«      5  ‰j                  ‰j                  «      }d d d «        ‰‰| ‰«       y # 1 sw Y   ŒxY wrˆ   )Úenter_borrow_scopeÚacceptÚ	left_expr)Ú
item_indexÚerg   Úgenrl   Úset_item_opÚ	target_ops     €€€€€rt   Úset_itemz<sequence_from_generator_preallocate_helper.<locals>.set_item&  sF   ø€ Ø×+Ñ+¨DÓ1ñ 2Ø—N‘N 3§=¡=Ó1�÷2á˜	 :¨q°$Õ7÷2ð 2ús   “AÁA)r“   r*   ÚreturnÚNone)ÚlenÚ	sequencesÚindicesÚ	condlistsrl   Ú	node_typer6   r{   r,   r.   r   Útypesr   Úitemsr   Úallr$   r   r   r   r;   r‘   Ú	enumerater(   ÚlistÚmapÚaddÚ	new_tupleÚget_expr_length_valuer„   )rg   r•   Úempty_op_llbuilderr–   Úsequence_exprÚrtypeÚproper_typeÚproper_typesrŠ   Úget_item_opsÚsequenceÚir¡   ry   r˜   rl   r—   s   `` `           @@rt   Ú*sequence_from_generator_preallocate_helperr±   Û   s  ü€ ô8 ˆ3�=‰=Ó˜QÓ¤3 s§{¡{Ó#3°qÓ#8¼SÀÇÁÈqÑAQÓ=RÐVWÓ=WØ�x‰xˆØŸ™ aÑ(ˆØ×!Ñ! -Ó0ˆÜ& uÔ-´¸EÄFÌDÀ>Ô1RØä�eœVÕ$ô *¨'¯-©-¸Ñ*FÓGˆKÜ˜k¬9Ô5ÐB°{ÓBÐ5ð ×$Ò$Øä+¨K×,=Ñ,=Ó>ˆLô ÑH¸<ÔHÔHð  ,ö àô  ¤¤[°#Ó 6× <Ñ <Ô>OÕPð �ñ  ð #Ÿ>™>¨-Ó8�ô #,¨LÓ"9÷ ñ ˜˜3ô & c¬;Ô7ô $ C§I¡IÔ/@ÔAä% h°°4Ó8ñ9ð �ñ  ô œ˜WŸ[™[¨,Ó7Ó8ˆEØ×(Ñ(¨°Ó5‰Hð —~‘~ mÓ4ˆHä& w°¸xÈÐ]aÔbˆá& v¨tÓ4ˆ	÷	8ñ 	8ô
 	#Ø�S—[‘[ ‘^ ]°H¸hÈÈfô	
ð ÐØùòI ùó s   Ä/H6Å+AH;c                óÈ  ‡ ‡‡— t        ‰ ‰«      r‰ j                  «       S dˆ fd„}t        ‰ ‰‰ j                  j                  |¬«      }|�|S ‰ j                  g ‰j                  «      Št        t        ‰j                  ‰j                  ‰j                  ‰j                  «      «      }dˆ ˆˆfd„}t        ‰ ||‰j                  «       ‰ j                  ‰‰j                  «      S )Nc                ó:   •— ‰j                  t        | ||g|«       y rˆ   )Úcall_crU   ©ÚxÚyÚzrl   rg   s       €rt   r˜   z.translate_list_comprehension.<locals>.set_item7  s   ø€ Ø�‰Ô+¨a°°A¨Y¸Õ=rv   ©r©   r–   c                 ó¶   •— ‰j                  ‰j                  «      } ‰j                  t        ‰j	                  ‰‰j
                  «      | g‰j
                  «       y rˆ   )r‘   r’   Úprimitive_oprR   r€   rl   )r”   rg   r•   Úlist_opss    €€€rt   Úgen_inner_stmtsz5translate_list_comprehension.<locals>.gen_inner_stmtsH  sC   ø€ Ø�N‰N˜3Ÿ=™=Ó)ˆØ×Ñœ^¨g¯l©l¸8ÀSÇXÁXÓ.NÐPQÐ-RÐTW×T\ÑT\Õ]rv   ©
r¶   r*   r·   r*   r¸   r*   rl   Úintr™   rš   ©r™   rš   )Ú)raise_error_if_contains_unreachable_namesÚnoner±   rg   Únew_list_op_with_lengthÚnew_list_oprl   r¤   Úzipr�   rœ   rž   r\   Úcomprehension_helperr€   )rg   r•   r˜   ÚvalÚloop_paramsr½   r¼   s   ``    @rt   Útranslate_list_comprehensionrÉ   3  s¶   ú€ Ü0°¸#Ô>Ø�|‰|‹~Ðõ>ô 5ØØØ"Ÿ?™?×BÑBØô	€Cð €Øˆ
à×"Ñ" 2 s§x¡xÓ0€Hä”s˜3Ÿ;™;¨¯©°s·}±}ÀcÇlÁlÓSÓT€K÷^ô ˜ +¨ÀÇÁÔIØ�<‰<˜ #§(¡(Ó+Ð+rv   c                óª   — t        d„ |j                  D «       «      r7t        t        j                  d|j                  «      }| j                  |«       yy)zÊRaise a runtime error and return True if generator contains unreachable names.

    False is returned if the generator can be safely transformed without crashing.
    (It may still be unreachable!)
    c              3  ó\   K  — | ]$  }t        |t        «      xr |j                  d u –— Œ& y ­wrˆ   )r{   r   Únode)r‰   Úss     rt   r‹   z<raise_error_if_contains_unreachable_names.<locals>.<genexpr>X  s'   è ø€ Ò
K¸!Œ:�aœÓ"Ò5 q§v¡v° ~Ó5Ñ
Kùs   ‚*,z+mypyc internal error: should be unreachableTF)Úanyr�   r&   ÚRUNTIME_ERRORrl   r¦   )rg   r•   Úerrors      rt   rÁ   rÁ   P  sG   € ô Ñ
K¸s¿{¹{Ô
KÔKÜ"Ü×,Ñ,Ø9Ø�H‰Hó
ˆð
 	�‰�EÔØàrv   c                ón  ‡ ‡‡— t        ‰ ‰«      r‰ j                  «       S ‰ j                  g ‰j                  «      Št	        t        ‰j                  ‰j                  ‰j                  ‰j                  «      «      }dˆ ˆˆfd„}t        ‰ ||‰j                  «       ‰ j                  ‰‰j                  «      S )Nc                 ó¶   •— ‰j                  ‰j                  «      } ‰j                  t        ‰j	                  ‰‰j
                  «      | g‰j
                  «       y rˆ   )r‘   r’   r»   rX   r€   rl   )r”   rg   r•   Úset_opss    €€€rt   r½   z4translate_set_comprehension.<locals>.gen_inner_stmtsk  s?   ø€ Ø�N‰N˜3Ÿ=™=Ó)ˆØ×ÑœZ¨'¯,©,°wÀÇÁÓ*IÈ1Ð)MÈsÏxÉxÕXrv   rÀ   )rÁ   rÂ   Ú
new_set_oprl   r¤   rÅ   r�   rœ   rž   r\   rÆ   r€   )rg   r•   rÈ   r½   rÓ   s   ``  @rt   Útranslate_set_comprehensionrÕ   d  sƒ   ú€ Ü0°¸#Ô>Ø�|‰|‹~Ðà× Ñ   S§X¡XÓ.€GÜ”s˜3Ÿ;™;¨¯©°s·}±}ÀcÇlÁlÓSÓT€K÷Yô ˜ +¨ÀÇÁÔIØ�<‰<˜ §¡Ó*Ð*rv   ©Úcapacityc          
     óž  ‡ ‡‡‡‡— dˆ fd„}t        ‰ ‰ˆ ˆˆfd„|¬«      }|�|S t        ‰«      Š‰ j                  ‰t        ‰ j                  ‰d‰j
                  ‰¬«      ‰j
                  «       t        t        ‰j                  ‰j                  ‰j                  ‰j                  «      «      }dˆ ˆˆfd„}t        ‰ ||‰j
                  «       ‰S )	Nc                ó8   •— t        ‰j                  | |||«       y rˆ   )rD   rg   rµ   s       €rt   r˜   z-translate_vec_comprehension.<locals>.set_itemv  s   ø€ Ü˜WŸ_™_¨a°°A°tÕ<rv   c                ó8   •— t        ‰j                  ‰| |‰¬«      S )NrÖ   )rB   rg   )ry   rl   rg   r×   Úvec_types     €€€rt   ú<lambda>z-translate_vec_comprehension.<locals>.<lambda>}  s   ø€ ´
Ø�O‰O˜X v¨t¸hô1
€ rv   r¹   r   rÖ   c            	     ó¶   •— ‰j                  ‰j                  «      } ‰j                  ‰t        ‰j                  ‰| ‰j
                  «      ‰j
                  «       y rˆ   )r‘   r’   ÚassignrA   rg   rl   )r”   rg   r•   Úvecs    €€€rt   r½   z4translate_vec_comprehension.<locals>.gen_inner_stmts‹  s<   ø€ Ø�N‰N˜3Ÿ=™=Ó)ˆØ�‰�sœJ w§¡¸¸QÀÇÁÓIÈ3Ï8É8ÕTrv   r¾   rÀ   )r±   r'   rÞ   rB   rg   rl   r¤   rÅ   r�   rœ   rž   r\   rÆ   )	rg   rÛ   r•   r×   r˜   rÇ   rÈ   r½   rß   s	   ````    @rt   Útranslate_vec_comprehensionrà   s  s¯   ü€ õ=ô 5ØØõ
ð ô€Cð €Øˆ
ä
�8Ó
€CØ‡N�NØŒZ˜Ÿ™¨°1°c·h±hÈÔRÐTW×T\ÑT\ôô ”s˜3Ÿ;™;¨¯©°s·}±}ÀcÇlÁlÓSÓT€K÷Uô ˜ +¨ÀÇÁÔIØ€Jrv   c                óL   ‡ ‡‡‡‡— dˆ ˆˆfd„Š	 	 	 	 	 	 dˆ ˆˆˆfd„Š ‰|«       y)a  Helper function for list comprehensions.

    Args:
        loop_params: a list of (index, expr, [conditions]) tuples defining nested loops:
            - "index" is the Lvalue indexing that loop;
            - "expr" is the expression for the object to be iterated over;
            - "conditions" is a list of conditions, evaluated in order with short-circuiting,
                that must all be true for the loop body to be executed
        gen_inner_stmts: function to generate the IR for the body of the innermost loop
    c           	     óL   •‡ ‡— ‰ d   \  }}Š}t        ‰||ˆˆˆ fd„d|‰¬«       y)zžGenerate IR for a loop.

        Given a list of (index, expression, [conditions]) tuples, generate IR
        for the nested loops the list defines.
        r   c                 ó   •—  ‰‰ ‰dd  «      S ©Nr†   © )ÚcondsÚloop_contentsrÈ   s   €€€rt   rÜ   z;comprehension_helper.<locals>.handle_loop.<locals>.<lambda>¯  s   ø€ ‘M %¨°Q°R¨Ó9€ rv   N)r\   rl   )ru   )rÈ   rh   ri   r\   ræ   rg   rl   rç   s   `   @€€€rt   Úhandle_loopz)comprehension_helper.<locals>.handle_loop¤  s4   ú€ ð (3°1¡~Ñ$ˆˆt�U˜HÜØØØÝ9ØØØö	
rv   c                óÔ  •— | D ]Ÿ  }‰j                  ‰	«      5  ‰j                  |«      }ddd«       t        «       t        «       }}‰j                  ||«       ‰j	                  |«       ‰j
                  d   j                  ‰|j                  «       ‰j                  |«       Œ¡ |r ‰|«      S ‰j                  ‰	«      5   ‰«        ddd«       y# 1 sw Y   Œ©xY w# 1 sw Y   yxY w)aa  Generate the body of the loop.

        Args:
            conds: a list of conditions to be evaluated (in order, with short circuiting)
                to gate the body of the loop
            remaining_loop_params: the parameters for any further nested loops; if it's empty
                we'll instead evaluate the "gen_inner_stmts" function
        Néÿÿÿÿ)	r�   r‘   r   Úadd_bool_branchra   Únonlocal_controlÚgen_continuerl   r_   )
ræ   Úremaining_loop_paramsÚcondÚcond_valÚ
cont_blockÚ
rest_blockrg   r½   rè   rl   s
         €€€€rt   rç   z+comprehension_helper.<locals>.loop_contentsµ  sà   ø€ ð ò 	2ˆDØ×+Ñ+¨DÓ1ñ 0Ø"Ÿ>™>¨$Ó/�÷0ä%/£\´:³<˜
ˆJà×#Ñ# H¨j¸*ÔEØ×"Ñ" :Ô.Ø×$Ñ$ RÑ(×5Ñ5°g¸t¿y¹yÔIØ×%Ñ% jÕ1ð	2ñ !áÐ4Ó5Ð5ð ×+Ñ+¨DÓ1ñ "ÙÔ!÷"ð "÷0ð 0ú÷"ð "ús   ˜CÃCÃC	ÃC'N)rÈ   ú7list[tuple[Lvalue, Expression, list[Expression], bool]]r™   rš   )ræ   úlist[Expression]rî   ró   r™   rš   rå   )rg   rÈ   r½   rl   rè   rç   s   ` ``@@rt   rÆ   rÆ   “  s7   ü€ ÷"
ð""Øð"àVð"ð 
÷"ð "ñ@ �Õrv   c                óz   — | j                   dk(  xs+ t        | j                  t        «      xr | j                   dk(  S )Núbuiltins.rangezsix.moves.xrange)Úfullnamer{   rÌ   r   )ri   s    rt   Úis_range_refrø   Ø  s9   € à�‰Ð)Ñ)ò 	0Ü�d—i‘i¤Ó+ò 0Ø�M‰MÐ/Ñ/ðrv   ÚForGeneratorc                óÊ  — |rW| j                  |«      }t        | |||||«      }	| j                  |«      }
| j                  |
«      }|	j	                  ||«       |	S | j                  |«      }t        |«      st        |t        «      rH| j                  |«      }| j                  |«      }t        | |||||«      }|j	                  ||d¬«       |S t        |«      rF| j                  |«      }| j                  |«      }t        | |||||«      }|j	                  ||«       |S t        |t        «      �rìt        |j                  t         «      �rÑt#        |j                  «      �r|t%        |j&                  «      dk  s8t%        |j&                  «      dk(  �rK| j)                  |j&                  d   «      ��,t+        |j,                  «      t.        hk(  �rt%        |j&                  «      dk(  r*t1        d«      }| j                  |j&                  d   «      }n<| j                  |j&                  d   «      }| j                  |j&                  d   «      }t%        |j&                  «      dk(  rQ| j)                  |j&                  d   «      }|€J ‚|dk(  r,| j3                  d|j&                  d   j4                  «       nd}t7        | |||||«      }|j	                  |||«       |S |j                  j8                  d	k(  r¤t%        |j&                  «      dk(  rŒ|j,                  t.        gk(  rxt        |t:        «      rht%        |j<                  «      dk(  rP|j<                  d   }|j<                  d   }t?        | |||||«      }|j	                  |||j&                  d   «       |S |j                  j8                  d
k(  r¨t%        |j&                  «      dk\  r�t+        |j,                  «      t.        hk(  rst        |t:        «      rct%        |j<                  «      t%        |j&                  «      k(  r8tA        | |||||«      }|j	                  |j<                  |j&                  «       |S |j                  j8                  dk(  r¨t%        |j&                  «      dk(  r�|j,                  t.        gk(  r|t        | j                  |j&                  d   «      «      rU| j                  |j&                  d   «      }| j                  |«      }t        | |||||«      }|j	                  ||d¬«       |S t        |t        «      �rnt        |j                  tB        «      �rS|j&                  �sF| j                  |j                  jD                  «      }t        |«      �r|j                  jF                  dv rý| j                  |j                  jD                  «      }d}|j                  jF                  dk(  r,| j                  |j                  jD                  «      }t        }np|j                  jF                  dk(  r,| jI                  |j                  jD                  «      }tJ        }n+| jM                  |j                  jD                  «      }tN        } || |||||«      }|j	                  ||«       |S d}t        |tP        «      rddl)m*}  || |«      }|�|}|€| j                  |«      }|jV                  }t        |tX        «      r0|jZ                  j]                  t^        «      rta        | |||||«      }ntc        | |||||«      }| j                  |«      }
| j                  |
«      }|j	                  ||«       |S )z˜Return helper object for generating a for loop over an iterable.

    If "nested" is True, this is a nested iterator such as "e" in "enumerate(e)".
    F)rx   é   é   Nr†   r   zrange() step can't be zeroúbuiltins.enumerateúbuiltins.zipúbuiltins.reversedT)ÚkeysÚvaluesr¡   r   r  )Úprecompute_set_literal)2r‘   ÚForAsyncIterableÚ_analyze_iterable_item_typeÚtype_to_rtyper~   rŸ   r6   r{   r.   r|   r}   r2   Úget_dict_key_typeÚForDictionaryKeysr   Úcalleer   rø   r›   ÚargsÚextract_intÚsetÚ	arg_kindsr   r   rÐ   rl   ÚForRanger÷   r   r¡   ÚForEnumerateÚForZipr   ri   ÚnameÚget_dict_value_typeÚForDictionaryValuesÚget_dict_item_typeÚForDictionaryItemsr   Úmypyc.irbuild.expressionr  rz   r+   Úclass_irÚ
has_methodr   ÚForNativeGeneratorÚForIterable) rg   rh   ri   rm   Ú	loop_exitrl   r\   Únestedr‚   Ú	async_objÚ	item_typeÚ
item_rtypeÚrtyprƒ   Úfor_listÚfor_dictÚ	start_regÚend_regÚstepÚ	for_rangeÚlvalue1Úlvalue2Úfor_enumerateÚfor_zipr«   Úfor_dict_typeÚfor_dict_genÚiterable_expr_regr  Úset_literalÚitÚfor_objs                                    rt   r]   r]   à  s  € ñ  Ø—>‘> $Ó'ˆÜ$ W¨e°ZÀÈDÐRXÓYˆ	Ø×7Ñ7¸Ó=ˆ	Ø×*Ñ*¨9Ó5ˆ
Ø�‰�x Ô,ØÐà×Ñ˜TÓ"€DÜ˜dÔ#¤z°$¼Ô'=à—>‘> $Ó'ˆØ×/Ñ/°Ó5ˆä˜w¨¨z¸9ÀdÈFÓSˆØ�‰�h °UˆÔ;Øˆä˜$Ôà—>‘> $Ó'ˆØ×/Ñ/°Ó5ˆä$ W¨e°ZÀÈDÐRXÓYˆØ�‰�h Ô,Øˆä�$œÕ!¤j°·±¼gÕ&Fä˜Ÿ™Õ%ä�D—I‘I“ !Ò#Ü˜Ÿ	™	“N aÓ'¨G×,?Ñ,?ÀÇ	Á	È!ÁÓ,MÑ,Yä�D—N‘NÓ#¬ yÓ0ô �4—9‘9‹~ Ò"Ü#*¨1£:�	Ø!Ÿ.™.¨¯©°1©Ó6‘à#ŸN™N¨4¯9©9°Q©<Ó8�	Ø!Ÿ.™.¨¯©°1©Ó6�Ü�4—9‘9‹~ Ò"Ø×*Ñ*¨4¯9©9°Q©<Ó8�ØÐ'Ð'Ð'Ø˜1’9Ø—M‘MÐ">ÀÇ	Á	È!Á×@QÑ@QÕRà�ä  ¨%°¸YÈÈfÓUˆIØ�N‰N˜9 g¨tÔ4ØÐð �K‰K× Ñ Ð$8Ò8Ü�D—I‘I“ !Ò#Ø—‘¤7 )Ò+Ü˜5¤)Ô,Ü�E—K‘KÓ  AÒ%ð —k‘k !‘nˆGØ—k‘k !‘nˆGÜ(¨°%¸ÀYÐPTÐV\Ó]ˆMØ×Ñ˜w¨°·±¸1±Ô>Ø Ð ð �K‰K× Ñ  NÒ2Ü�D—I‘I“ !Ò#Ü�D—N‘NÓ#¬ yÒ0Ü˜5¤)Ô,Ü�E—K‘KÓ ¤C¨¯	©	£NÒ2ô ˜W e¨Z¸ÀDÈ&ÓQˆGØ�L‰L˜Ÿ™ d§i¡iÔ0ØˆNð �K‰K× Ñ Ð$7Ò7Ü�D—I‘I“ !Ò#Ø—‘¤7 )Ò+Ü& w×'8Ñ'8¸¿¹À1¹Ó'FÔGð —~‘~ d§i¡i°¡lÓ3ˆHØ!×3Ñ3°DÓ9ˆKä" 7¨E°:¸yÈ$ÐPVÓWˆHØ�M‰M˜( K¸ˆMÔ>ØˆOÜ�$œÕ!¤j°·±¼jÕ&IÐRV×R[ÓR[à×!Ñ! $§+¡+×"2Ñ"2Ó3ˆÜ˜eÕ$¨¯©×)9Ñ)9Ð=XÑ)XØ—~‘~ d§k¡k×&6Ñ&6Ó7ˆHØ7;ˆMØ�{‰{×Ñ 6Ò)Ø%×7Ñ7¸¿¹×8HÑ8HÓI�Ü 1‘Ø—‘×!Ñ! XÒ-Ø%×9Ñ9¸$¿+¹+×:JÑ:JÓK�Ü 3‘à%×8Ñ8¸¿¹×9IÑ9IÓJ�Ü 2�Ù(¨°%¸ÀYÐPTÐV\Ó]ˆLØ×Ñ˜h¨Ô4ØÐà&*ÐÜ�$œÔ åCá,¨W°dÓ;ˆØÐ"Ø +Ðð Ð Ø#ŸN™N¨4Ó0Ðà	×	Ñ	€Bä�"”iÔ  R§[¡[×%;Ñ%;Ô<QÔ%Rä$ W¨e°ZÀÈDÐRXÓY‰ô ˜g u¨j¸)ÀTÈ6ÓRˆØ×3Ñ3°DÓ9€IØ×&Ñ& yÓ1€JØ‡L�LÐ" JÔ/Ø€Nrv   c                  ól   — 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	„Zy
)rù   z-Abstract base class for generating for loops.c                óŽ   — || _         || _        || _        || _        | j	                  «       r|st        «       | _        y || _        y rˆ   )rg   rh   rm   rl   Úneed_cleanupr   r  )Úselfrg   rh   rm   r  rl   r  s          rt   Ú__init__zForGenerator.__init__‚  sB   € ð ˆŒØˆŒ
Ø$ˆŒØˆŒ	ð ×ÑÔ¡vä'›\ˆD�Nð 'ˆD�Nrv   c                 ó   — y)z0If this returns true, we need post-loop cleanup.Frå   ©r3  s    rt   r2  zForGenerator.need_cleanup›  s   € àrv   c                óÆ   — | j                  «       rQ| j                  j                  | j                  «       | j	                  «        | j                  j                  |«       yy)z!Add post-loop cleanup, if needed.N)r2  rg   ra   r  Úgen_cleanuprd   )r3  rp   s     rt   re   zForGenerator.add_cleanupŸ  sG   € à×ÑÔØ�L‰L×'Ñ'¨¯©Ô7Ø×ÑÔØ�L‰L×Ñ˜jÕ)ð rv   c                 ó   — y)z<Generate check for loop exit (e.g. exhaustion of iteration).Nrå   r6  s    rt   r`   zForGenerator.gen_condition¦  ó   � rv   c                 ó   — y)z6Generate ops at the beginning of the body (if needed).Nrå   r6  s    rt   rb   zForGenerator.begin_body©  r:  rv   c                 ó   — y)z/Generate stepping to the next item (if needed).Nrå   r6  s    rt   rc   zForGenerator.gen_step¬  r:  rv   c                 ó   — y)z'Generate post-loop cleanup (if needed).Nrå   r6  s    rt   r8  zForGenerator.gen_cleanup¯  r:  rv   c                ó®   — | j                   j                   j                  | j                   j                  || j                  «      | j                  d¬«      S )z>A helper to get collection length, used by several subclasses.Tr�   )rg   Úbuiltin_lenr€   rl   )r3  ri   s     rt   Úload_lenzForGenerator.load_len²  sD   € à�|‰|×#Ñ#×/Ñ/Ø�L‰L×Ñ˜d D§I¡IÓ.°·	±	Èð 0ó 
ð 	
rv   N)rg   r=   rh   r   rm   r   r  r   rl   r¿   r  Úboolr™   rš   ©r™   rA  )rp   r   r™   rš   rÀ   )ri   r*   r™   r*   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r4  r2  re   r`   rb   rc   r8  r@  rå   rv   rt   rù   rù     ss   „ Ù7ð'àð'ð ð'ð ð	'ð
 ð'ð ð'ð ð'ð 
ó'ó2ó*óKóEó>ó6ô
rv   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	y)r  zIGenerate IR for a for loop over an arbitrary iterable (the general case).c                 ó   — y©NTrå   r6  s    rt   r2  zForIterable.need_cleanup¼  ó   € àrv   c                ó|   — | j                   }|j                  t        |g| j                  «      }|| _        || _        y rˆ   )rg   r»   rP   rl   Úiter_targetrƒ   ©r3  r‚   rƒ   rg   Úiter_regs        rt   r~   zForIterable.initÀ  s7   € ð —,‘,ˆØ×'Ñ'¬°(°¸T¿Y¹YÓGˆØ#ˆÔØ&ˆÕrv   c                ó4  — | j                   }| j                  }|j                  t        |j	                  | j
                  |«      g|«      | _        |j                  t        | j                  | j                  | j                  t        j                  «      «       y rˆ   )rg   rl   r´   rQ   r€   rL  Únext_regr¦   r   r  rm   ÚIS_ERROR©r3  rg   rl   s      rt   r`   zForIterable.gen_conditionÈ  sg   € ð
 —,‘,ˆØ�y‰yˆØŸ™¤w°·±¸d×>NÑ>NÐPTÓ1UÐ0VÐX\Ó]ˆŒØ�‰”F˜4Ÿ=™=¨$¯.©.¸$¿/¹/Ì6Ï?É?Ó[Õ\rv   c                óÚ   — | j                   }| j                  }|j                  | j                  | j                  |«      }|j                  |j                  | j                  «      ||«       y rˆ   ©rg   rl   ÚcoercerP  rƒ   rÞ   Úget_assignment_targetrh   ©r3  rg   rl   rP  s       rt   rb   zForIterable.begin_bodyÒ  óS   € ð —,‘,ˆØ�y‰yˆð —>‘> $§-¡-°×1AÑ1AÀ4ÓHˆØ�‰�w×4Ñ4°T·Z±ZÓ@À(ÈDÕQrv   c                 ó   — y rˆ   rå   r6  s    rt   rc   zForIterable.gen_stepÜ  ó   € àrv   c                óZ   — | j                   j                  t        g | j                  «       y rˆ   ©rg   r´   rL   rl   r6  s    rt   r8  zForIterable.gen_cleanupà  s   € ð
 	�‰×ÑÔ.°°D·I±IÕ>rv   NrB  ©r‚   r*   rƒ   r-   r™   rš   rÀ   ©
rC  rD  rE  rF  r2  r~   r`   rb   rc   r8  rå   rv   rt   r  r  ¹  s%   „ ÙSóó'ó]óRóô?rv   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	y)r  z3Generate IR for a for loop over a native generator.c                 ó   — yrI  rå   r6  s    rt   r2  zForNativeGenerator.need_cleanupë  rJ  rv   c                ó    — || _         || _        y rˆ   )rL  rƒ   )r3  r‚   rƒ   s      rt   r~   zForNativeGenerator.initï  s   € ð $ˆÔØ&ˆÕrv   c           	     ó~  — | j                   }| j                  }t        t        «      | _        |j                  t        t        d¬«      «      }|j                  | j                  ||«       |j                  t        t        | j                  «      «      }|j                  «       }t        |j                  | j                  |«      t        |||||g|«      }t        |_        |j                  |«      | _        |j                  t%        | j"                  | j&                  | j(                  t$        j*                  «      «       y )NT)Ú	undefines)rg   rl   r'   r;   Úreturn_valuer¦   r"   rÞ   r!   r:   Únone_objectr%   r€   rL  r   r   Ú
error_kindrP  r   r  rm   rQ  )r3  rg   rl   ÚerrÚptrÚnnÚhelper_calls          rt   r`   z ForNativeGenerator.gen_conditionõ  sí   € Ø—,‘,ˆØ�y‰yˆÜ$Ô%6Ó7ˆÔØ�k‰kœ.Ô):ÀdÔKÓLˆØ�‰�t×(Ñ(¨#¨tÔ4ð �k‰kœ+Ô&?À×ARÑARÓSÓTˆØ× Ñ Ó"ˆÜ Ø�L‰L˜×)Ñ)¨4Ó0Ü!Ø��R˜˜SÐ!Øó	
ˆô "+ˆÔàŸ™ KÓ0ˆŒØ�‰”F˜4Ÿ=™=¨$¯.©.¸$¿/¹/Ì6Ï?É?Ó[Õ\rv   c                óÚ   — | j                   }| j                  }|j                  | j                  | j                  |«      }|j                  |j                  | j                  «      ||«       y rˆ   rT  rW  s       rt   rb   zForNativeGenerator.begin_body  rX  rv   c                 ó   — y rˆ   rå   r6  s    rt   rc   zForNativeGenerator.gen_step  rZ  rv   c                óp   — | j                   j                  t        | j                  g| j                  «       y rˆ   )rg   r»   rM   rd  rl   r6  s    rt   r8  zForNativeGenerator.gen_cleanup  s(   € ð 	�‰×!Ñ!Ô"7¸$×:KÑ:KÐ9LÈdÏiÉiÕXrv   NrB  r]  rÀ   r^  rå   rv   rt   r  r  è  s&   „ Ù=óó'ó]ó4RóôYrv   r  c                  ó0   — e Zd ZdZdd„Zdd„Zdd„Zdd„Zy)	r  z"Generate IR for an async for loop.c                ó¤   — | j                   }|j                  t        |g| j                  «      }|| _        || _        t        t        «      | _        y rˆ   )	rg   r´   rN   rl   rL  rƒ   r'   r/   Ústop_regrM  s        rt   r~   zForAsyncIterable.init&  sA   € ð —,‘,ˆØ—>‘>¤(¨X¨J¸¿	¹	ÓBˆØ#ˆÔØ&ˆÔÜ ¤Ó1ˆ�rv   c                ó2  ‡ ‡‡‡— ddl mŠm} ‰ j                  Š‰ j                  Šdˆˆfd„}dˆˆˆˆ fd„}dˆˆˆ fd„} |‰||‰fd |fgd ‰«       ‰j                  t        ‰ j                  ‰ j                  ‰ j                  t        j                  «      «       y )Nr   )Ú
emit_awaitÚtransform_try_exceptc                 ót   •— ‰ j                  t        t        j                  t        j                  ‰«      «      S rˆ   )r¦   r#   rV   rz   Úsrc)rg   rl   s   €€rt   Úexcept_matchz4ForAsyncIterable.gen_condition.<locals>.except_match?  s/   ø€ Ø—;‘;ÜÔ2×7Ñ7Ô9P×9TÑ9TÐVZÓ[óð rv   c                 óÞ   •— ‰j                  t        ‰j                  ‰j                  ‰«      g‰«      }  ‰‰| ‰«      ‰_        ‰j                  ‰j                  ‰j                  «       ‰«       y rˆ   )r´   rO   r€   rL  rP  rÞ   rp  Úfalse)Ú	awaitablerg   rr  rl   r3  s    €€€€rt   Útry_bodyz0ForAsyncIterable.gen_condition.<locals>.try_bodyD  sU   ø€ ØŸ™¤x°'·,±,¸t×?OÑ?OÐQUÓ2VÐ1WÐY]Ó^ˆIÙ& w°	¸4Ó@ˆDŒMØ�N‰N˜4Ÿ=™=¨'¯-©-«/¸4Õ@rv   c                 ó\   •— ‰ j                  ‰j                  ‰ j                  «       ‰«       y rˆ   )rÞ   rp  Útrue)rg   rl   r3  s   €€€rt   Úexcept_bodyz3ForAsyncIterable.gen_condition.<locals>.except_bodyI  s   ø€ Ø�N‰N˜4Ÿ=™=¨'¯,©,«.¸$Õ?rv   )r™   r*   rÀ   )Úmypyc.irbuild.statementrr  rs  rg   rl   r¦   r   rp  r  rm   ÚBOOL)r3  rs  rv  rz  r}  rg   rr  rl   s   `    @@@rt   r`   zForAsyncIterable.gen_condition/  s€   û€ ÷ 	Mà—,‘,ˆØ�y‰yˆö	÷
	Að 	A÷
	@ñ 	Ø�X ,°Ð!5°t¸[Ð IÐJÈDÐRVô	
ð 	�‰”F˜4Ÿ=™=¨$¯.©.¸$¿/¹/Ì6Ï;É;ÓWÕXrv   c                óÚ   — | j                   }| j                  }|j                  | j                  | j                  |«      }|j                  |j                  | j                  «      ||«       y rˆ   rT  rW  s       rt   rb   zForAsyncIterable.begin_bodyR  rX  rv   c                 ó   — y rˆ   rå   r6  s    rt   rc   zForAsyncIterable.gen_step\  rZ  rv   Nr]  rÀ   ©rC  rD  rE  rF  r~   r`   rb   rc   rå   rv   rt   r  r  #  s   „ Ù,ó2ó!YóFRôrv   r  c                óä  — t        |j                  «      r8t        s| j                  t        ||g|«      S | j                  t
        ||g|«      S t        |j                  «      r| j                  t        ||g|«      S t        |j                  «      r| j                  t        ||g|«      S t        |j                  t        «      rt        | j                  |||«      S | j                  |d|gd|«      S )z.Emit a potentially unsafe index into a target.Ú__getitem__N)r5   rz   r   r»   rT   rS   r9   r´   rZ   r8   rY   r{   r.   rC   rg   Úgen_method_call)rg   Útargetrh   rl   s       rt   Úunsafe_indexr‡  a  sÏ   € ô
 ˜&Ÿ+™+Ô&ÝØ×'Ñ'Ô(?À&È%ÀÐRVÓWÐWà×'Ñ'Ô(>ÀÈÀÐQUÓVÐVÜ	˜VŸ[™[Ô	)Ø�~‰~Ô6¸À¸ÈÓNÐNÜ	˜6Ÿ;™;Ô	'Ø�~‰~Ô4°v¸u°oÀtÓLÐLÜ	�F—K‘K¤Ô	&Ü" 7§?¡?°F¸EÀ4ÓHÐHà×&Ñ& v¨}¸u¸gÀtÈTÓRÐRrv   c                  óR   — e Zd ZU dZded<   	 d		 	 	 	 	 	 	 	 	 d
d„Zdd„Zdd„Zdd„Zy)r}   zoGenerate optimized IR for a for loop over a sequence.

    Supports iterating in both forward and reverse.
    úValue | NoneÚ
length_regNc                ó”  — t        |j                  «      s-t        |j                  t        «      sJ ||j                  f«       ‚| j                  }|| _        || _        || _        t        |j                  «      r/| j
                  xs | j                  | j                  «      | _
        nd | _
        |st        dt        «      }nj| j                  �'|j                  | j                  | j                  «      }n| j                  | j                  «      }|j                  j                  |d«      }|j!                  |«      | _        || _        y )Nr   r†   )r6   rz   r{   r.   rg   ry   rx   Úexpr_targetr4   r@  rŠ  r   r0   r€   rl   Úint_subÚensure_registerr�   rƒ   )r3  r‚   rƒ   rx   ry   rg   Ú	index_regÚlen_vals           rt   r~   zForSequence.init}  s	  € ô & h§m¡mÔ4¼
À8Ç=Á=ÔRVÔ8Wð 	
ØØ�M‰MðZ
ó 	
ÐWð —,‘,ˆàˆŒØˆŒð $ˆÔÜ" 8§=¡=Ô1à"Ÿk™kÒL¨T¯]©]¸4×;KÑ;KÓ-LˆD�Oð #ˆDŒOÙÜ& qÔ*@ÓA‰Ià�‰Ð*Ø!Ÿ,™, t§¡¸¿	¹	ÓB‘àŸ-™-¨×(8Ñ(8Ó9�ØŸ™×/Ñ/°¸Ó;ˆIØ#×3Ñ3°IÓ>ˆÔØ&ˆÕrv   c                ó\  — | j                   }| j                  }| j                  ro|j                  |j	                  | j
                  |«      t        d«      d|«      }t        «       }|j                  ||| j                  «       |j                  |«       | j                  €| j                  | j                  «      }n|j	                  | j                  |«      }|j                  |j	                  | j
                  |«      |d|«      }|j                  || j                  | j                  «       y )Nr   z>=ú<)rg   rl   rx   Ú	binary_opr€   r�   r   r   rë   r  ra   rŠ  r@  rŒ  rm   )r3  rg   rl   Ú
comparisonÚsecond_checkÚlen_regs         rt   r`   zForSequence.gen_condition�  sñ   € Ø—,‘,ˆØ�y‰yˆØ�<Š<ð
 !×*Ñ*Ø—‘˜T×.Ñ.°Ó5´w¸q³zÀ4ÈóˆJô &›<ˆLØ×#Ñ# J°¸d¿n¹nÔMØ×"Ñ" <Ô0Ø�?‰?Ð"ð —m‘m D×$4Ñ$4Ó5‰Gð —l‘l 4§?¡?°DÓ9ˆGØ×&Ñ& w§|¡|°D×4EÑ4EÀtÓ'LÈgÐWZÐ\`Óaˆ
Ø×Ñ 
¨D¯O©O¸T¿^¹^ÕLrv   c                óN  — | j                   }| j                  }t        ||j                  | j                  |«      |j                  | j
                  |«      |«      }|sJ ‚|j                  |j                  | j                  «      |j                  || j                  |«      |«       y rˆ   )rg   rl   r‡  r€   rŒ  r�   rÞ   rV  rh   rU  rƒ   )r3  rg   rl   Ú	value_boxs       rt   rb   zForSequence.begin_bodyµ  s�   € Ø—,‘,ˆØ�y‰yˆä ØØ�L‰L˜×)Ñ)¨4Ó0Ø�L‰L˜×*Ñ*¨DÓ1Øó	
ˆ	ñ Ðˆyð 	�‰Ø×)Ñ)¨$¯*©*Ó5Ø�N‰N˜9 d×&6Ñ&6¸Ó=Øõ	
rv   c                óú   — | j                   }| j                  }| j                  sdnd}|j                   j                  |j	                  | j
                  |«      |«      }|j                  | j
                  ||«       y )Nr†   rê   )rg   rl   rx   Úint_addr€   r�   rÞ   )r3  rg   rl   r$  r¦   s        rt   rc   zForSequence.gen_stepÉ  s^   € à—,‘,ˆØ�y‰yˆØŸš‰q¨"ˆØ�o‰o×%Ñ% g§l¡l°4×3DÑ3DÀdÓ&KÈTÓRˆØ�‰�t×(Ñ(¨#¨tÕ4rv   rˆ   )
r‚   r*   rƒ   r-   rx   rA  ry   r‰  r™   rš   rÀ   )	rC  rD  rE  rF  Ú__annotations__r~   r`   rb   rc   rå   rv   rt   r}   r}   u  sT   … ñð
 Óð Z^ð'Øð'Ø,1ð'Ø<@ð'ØJVð'à	ó'ó@Mó0
ô(5rv   r}   c                  óN   — e Zd ZU dZded<   ded<   dd„Zdd„Zdd„Zdd„Zdd	„Z	y
)ÚForDictionaryCommona§  Generate optimized IR for a for loop over dictionary keys/values.

    The logic is pretty straightforward, we use PyDict_Next() API wrapped in
    a tuple, so that we can modify only a single register. The layout of the tuple:
      * f0: are there more items (bool)
      * f1: current offset (int)
      * f2: next key (object)
      * f3: next value (object)
    For more info see https://docs.python.org/3/c-api/dict.html#c.PyDict_Next.

    Note that for subclasses we fall back to generic PyObject_GetIter() logic,
    since they may override some iteration methods in subtly incompatible manner.
    The fallback logic is implemented in CPy.h via dynamic type check.
    zClassVar[CFunctionDescription]Údict_next_opÚdict_iter_opc                 ó   — yrI  rå   r6  s    rt   r2  z ForDictionaryCommon.need_cleanupå  ó   € ð rv   c                ó  — | j                   }|| _        || _        t        d«      }|j	                  |«      | _        | j                  | j                  «      | _        |j                  | j                  |g| j                  «      }|| _        y ©Nr   )rg   rƒ   rŒ  r   rŽ  Úoffset_targetr@  Úsizer´   rŸ  rl   rL  )r3  r‚   rƒ   rg   ÚoffsetrN  s         rt   r~   zForDictionaryCommon.initê  sw   € Ø—,‘,ˆØ&ˆÔð $ˆÔÜ˜“ˆØ$×4Ñ4°VÓ<ˆÔØ—M‘M $×"2Ñ"2Ó3ˆŒ	ð —>‘> $×"3Ñ"3°h°ZÀÇÁÓKˆØ#ˆÕrv   c                óH  — | j                   }| j                  }| j                   j                  | j                  |j	                  | j
                  |«      |j	                  | j                  |«      g|«      | _        |j                  t        | j                  d|«      «      }|j                  | j                  ||«       |j                  t        | j                  d|«      «      }|j                  t        || j                  | j                  t        j                  «      «       y)zIGet next key/value pair, set new offset, and check if we should continue.r†   r   N)rg   rl   r´   rž  r€   rL  r¤  Ú
next_tupler¦   r(   rÞ   r   rm   r  r  )r3  rg   rl   Ú
new_offsetÚshould_continues        rt   r`   z!ForDictionaryCommon.gen_conditionø  sÒ   € à—,‘,ˆØ�y‰yˆØŸ,™,×-Ñ-Ø×ÑØ�\‰\˜$×*Ñ*¨DÓ1°7·<±<À×@RÑ@RÐTXÓ3YÐZØó
ˆŒð —[‘[¤¨$¯/©/¸1¸dÓ!CÓDˆ
Ø�‰�t×)Ñ)¨:°tÔ<à!Ÿ+™+¤h¨t¯©ÀÀ4Ó&HÓIˆØ�‰”F˜?¨D¯O©O¸T¿^¹^ÌVÏ[É[ÓYÕZrv   c                óÎ   — | j                   }| j                  }|j                  t        |j	                  | j
                  |«      |j	                  | j                  |«      g|«       y)z�Check that dictionary didn't change size during iteration.

        Raise RuntimeError if it is not the case to match CPython behavior.
        N)rg   rl   r´   rE   r€   rŒ  r¥  rR  s      rt   rc   zForDictionaryCommon.gen_step	  sP   € ð
 —,‘,ˆØ�y‰yˆà�‰ÜØ�\‰\˜$×*Ñ*¨DÓ1°7·<±<ÀÇ	Á	È4Ó3PÐQØõ	
rv   c                óZ   — | j                   j                  t        g | j                  «       y rˆ   r\  r6  s    rt   r8  zForDictionaryCommon.gen_cleanup  s   € à�‰×ÑÔ.°°D·I±IÕ>rv   NrB  r]  rÀ   )
rC  rD  rE  rF  r›  r2  r~   r`   rc   r8  rå   rv   rt   r�  r�  Ò  s/   … ñð 1Ó0Ø0Ó0óó
$ó[ó"
ô?rv   r�  c                  ó    — e Zd ZdZeZeZdd„Zy)r  z:Generate optimized IR for a for loop over dictionary keys.c                ó  — | j                   }| j                  }|j                  t        | j                  d|«      «      }|j                  |j                  | j                  «      |j                  || j                  |«      |«       y ©Nrû   ©
rg   rl   r¦   r(   r¨  rÞ   rV  rh   rU  rƒ   )r3  rg   rl   Úkeys       rt   rb   zForDictionaryKeys.begin_body"  sh   € Ø—,‘,ˆØ�y‰yˆð �k‰kœ( 4§?¡?°A°tÓ<Ó=ˆØ�‰Ø×)Ñ)¨$¯*©*Ó5Ø�N‰N˜3 × 0Ñ 0°$Ó7Øõ	
rv   NrÀ   )	rC  rD  rE  rF  rI   rž  rG   rŸ  rb   rå   rv   rt   r  r    s   „ ÙDà#€LØ#€Lô

rv   r  c                  ó    — e Zd ZdZeZeZdd„Zy)r  z<Generate optimized IR for a for loop over dictionary values.c                ó  — | j                   }| j                  }|j                  t        | j                  d|«      «      }|j                  |j                  | j                  «      |j                  || j                  |«      |«       y r¯  r°  )r3  rg   rl   r   s       rt   rb   zForDictionaryValues.begin_body5  sh   € Ø—,‘,ˆØ�y‰yˆð —‘œH T§_¡_°a¸Ó>Ó?ˆØ�‰Ø×)Ñ)¨$¯*©*Ó5Ø�N‰N˜5 $×"2Ñ"2°DÓ9Øõ	
rv   NrÀ   )	rC  rD  rE  rF  rJ   rž  rK   rŸ  rb   rå   rv   rt   r  r  /  s   „ ÙFà%€LØ%€Lô

rv   r  c                  ó    — e Zd ZdZeZeZdd„Zy)r  z;Generate optimized IR for a for loop over dictionary items.c                óV  — | j                   }| j                  }|j                  t        | j                  d|«      «      }|j                  t        | j                  d|«      «      }t        | j                  t        «      sJ | j                  «       ‚|j                  || j                  j                  d   |«      }|j                  || j                  j                  d   |«      }|j                  | j                  «      }t        |t        «      rkt        |j                  «      dk7  r|j                  d|«       |j!                  |j                  d   ||«       |j!                  |j                  d   ||«       y |j                  t#        ||g|«      «      }|j!                  |||«       y )Nrû   rü   r   r†   z'Expected a pair for dict item iteration)rg   rl   r¦   r(   r¨  r{   rƒ   r,   rU  r    rV  rh   r@   r›   r¡   rÐ   rÞ   r)   )r3  rg   rl   r±  r   r†  Úrvalues          rt   rb   zForDictionaryItems.begin_bodyH  sK  € Ø—,‘,ˆØ�y‰yˆà�k‰kœ( 4§?¡?°A°tÓ<Ó=ˆØ—‘œH T§_¡_°a¸Ó>Ó?ˆô ˜$×*Ñ*¬FÔ3ÐE°T×5EÑ5EÓEÐ3Ø�n‰n˜S $×"2Ñ"2×"8Ñ"8¸Ñ";¸TÓBˆØ—‘˜u d×&6Ñ&6×&<Ñ&<¸QÑ&?ÀÓFˆà×.Ñ.¨t¯z©zÓ:ˆÜ�fÔ3Ô4ä�6—<‘<Ó  AÒ%Ø—‘ÐGÈÔNØ�N‰N˜6Ÿ<™<¨™?¨C°Ô6Ø�N‰N˜6Ÿ<™<¨™?¨E°4Õ8à—[‘[¤¨3°¨,¸Ó!=Ó>ˆFØ�N‰N˜6 6¨4Õ0rv   NrÀ   )	rC  rD  rE  rF  rH   rž  rF   rŸ  rb   rå   rv   rt   r  r  B  s   „ ÙEà$€LØ$€Lô1rv   r  c                  ó0   — e Zd ZdZdd„Zdd„Zdd„Zdd„Zy)	r  z;Generate optimized IR for a for loop over an integer range.c                óR  — | j                   }|| _        || _        || _        || _        t        |j                  «      rt        |j                  «      rt        }n(t        |j                  «      r|j                  }nt        }t        || j                  ¬«      }|j                  ||| j                  «       || _        |j                  | j                  «      | _        |j                  | j                   |j#                  | j                  | j                  «      | j                  «       y )N)rl   )rg   r"  r#  r$  Ú
end_targetr7   rz   r<   r3   r1   r'   rl   rÞ   r�  rV  rh   r�   r€   )r3  r"  r#  r$  rg   Ú
index_typer�  s          rt   r~   zForRange.initc  sÓ   € Ø—,‘,ˆØ"ˆŒØˆŒØˆŒ	Ø!ˆŒÜ" 9§>¡>Ô2Ô7NÈwÏ|É|Ô7\Ü 4‰JÜ! '§,¡,Ô/Ø Ÿ™‰Jä'ˆJÜ˜Z¨d¯i©iÔ8ˆ	Ø�‰�y )¨T¯Y©YÔ7Ø"ˆŒà9@×9VÑ9VÐW[×WaÑWaÓ9bˆÔØ�‰�t×(Ñ(¨'¯,©,°t·~±~ÀtÇyÁyÓ*QÐSW×S\ÑS\Õ]rv   c                ó8  — | j                   }| j                  }| j                  dkD  rdnd}|j                  |j	                  | j
                  |«      |j	                  | j                  |«      ||«      }|j                  || j                  | j                  «       y )Nr   r’  ú>)
rg   rl   r$  r“  r€   r�  r¹  rë   rm   r  )r3  rg   rl   Úcmpr”  s        rt   r`   zForRange.gen_conditionv  sz   € Ø—,‘,ˆØ�y‰yˆà—Y‘Y ’]‰c¨ˆØ×&Ñ&Ø�L‰L˜Ÿ™¨Ó.°·±¸T¿_¹_ÈdÓ0SÐUXÐZ^ó
ˆ
ð 	×Ñ 
¨D¯O©O¸T¿^¹^ÕLrv   c                ó²   — | j                   }|j                  | j                  |j                  | j                  | j
                  «      | j
                  «       y rˆ   ©rg   rÞ   r�   r€   r�  rl   )r3  rg   s     rt   rb   zForRange.begin_body€  s=   € ð —,‘,ˆØ�‰�t×(Ñ(¨'¯,©,°t·~±~ÀtÇyÁyÓ*QÐSW×S\ÑS\Õ]rv   c                ó  — | j                   }| j                  }t        | j                  j                  «      rtt        | j
                  j                  «      rU|j                  t        |j                  | j                  |«      t        | j                  «      t        j                  |«      }nA|j                  |j                  | j                  |«      t        | j                  «      d|«      }|j                  | j                  ||«       y )Nú+)rg   rl   r7   r"  rz   r#  Úint_opr<   r€   r�  r   r$  r    ÚADDr“  rÞ   ©r3  rg   rl   Únew_vals       rt   rc   zForRange.gen_step‡  sÁ   € Ø—,‘,ˆØ�y‰yˆô # 4§>¡>×#6Ñ#6Ô7Ô<SØ�L‰L×Ñô=
ð —n‘nÜ$Ø—‘˜TŸ^™^¨TÓ2Ü˜Ÿ	™	Ó"Ü—	‘	Øó‰Gð ×'Ñ'Ø—‘˜TŸ^™^¨TÓ2´G¸D¿I¹IÓ4FÈÈTóˆGð 	�‰�t—~‘~ w°Õ5rv   N)r"  r*   r#  r*   r$  r¿   r™   rš   rÀ   r‚  rå   rv   rt   r  r  `  s   „ ÙEó^ó&Mó^ô6rv   r  c                  ó(   — e Zd ZdZdd„Zdd„Zdd„Zy)ÚForInfiniteCounterzAGenerate optimized IR for a for loop counting from 0 to infinity.c                óž   — | j                   }t        d«      }|j                  |«      | _        |j	                  | j
                  «      | _        y r£  )rg   r   rŽ  r�  rV  rh   r�   )r3  rg   Úzeros      rt   r~   zForInfiniteCounter.init¢  sB   € Ø—,‘,ˆô �q‹zˆØ ×0Ñ0°Ó6ˆŒØ9@×9VÑ9VÐW[×WaÑWaÓ9bˆÕrv   c                ó  — | j                   }| j                  }|j                  t        |j	                  | j
                  |«      t        d«      t        j                  |«      }|j                  | j
                  ||«       y rä   )
rg   rl   rÂ  r<   r€   r�  r   r    rÃ  rÞ   rÄ  s       rt   rc   zForInfiniteCounter.gen_stepª  s`   € Ø—,‘,ˆØ�y‰yˆð —.‘.Ü  '§,¡,¨t¯~©~¸tÓ"DÄgÈaÃjÔRW×R[ÑR[Ð]aó
ˆð 	�‰�t—~‘~ w°Õ5rv   c                óÂ   — | j                   j                  | j                  | j                   j                  | j                  | j
                  «      | j
                  «       y rˆ   r¿  r6  s    rt   rb   zForInfiniteCounter.begin_bodyµ  s>   € Ø�‰×ÑØ×Ñ˜tŸ|™|×0Ñ0°·±ÀÇÁÓKÈTÏYÉYõ	
rv   NrÀ   )rC  rD  rE  rF  r~   rc   rb   rå   rv   rt   rÇ  rÇ  Ÿ  s   „ ÙKócó	6ô
rv   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	y)r  zIGenerate optimized IR for a for loop of form "for i, x in enumerate(it)".c                 ó   — yrI  rå   r6  s    rt   r2  zForEnumerate.need_cleanup¾  r¡  rv   c           	     ó2  — t        | j                  || j                  | j                  | j                  d¬«      | _        | j
                  j                  «        t        | j                  ||| j                  | j                  | j                  d¬«      | _        y )NT©r  )	rÇ  rg   rm   r  rl   Ú	index_genr~   r]   Úmain_gen)r3  Úindex1Úindex2ri   s       rt   r~   zForEnumerate.initÃ  sj   € ä+Ø�L‰L˜& $§/¡/°4·>±>À4Ç9Á9ÐUYô
ˆŒð 	�‰×ÑÔä/Ø�L‰L˜& $¨¯©¸¿¹ÈÏÉÐ[_ô
ˆ�rv   c                ó8   — | j                   j                  «        y rˆ   )rÑ  r`   r6  s    rt   r`   zForEnumerate.gen_conditionÎ  s   € à�‰×#Ñ#Õ%rv   c                ól   — | j                   j                  «        | j                  j                  «        y rˆ   )rÐ  rb   rÑ  r6  s    rt   rb   zForEnumerate.begin_bodyÒ  s"   € Ø�‰×!Ñ!Ô#Ø�‰× Ñ Õ"rv   c                ól   — | j                   j                  «        | j                  j                  «        y rˆ   )rÐ  rc   rÑ  r6  s    rt   rc   zForEnumerate.gen_stepÖ  s"   € Ø�‰×ÑÔ!Ø�‰×ÑÕ rv   c                ól   — | j                   j                  «        | j                  j                  «        y rˆ   )rÐ  r8  rÑ  r6  s    rt   r8  zForEnumerate.gen_cleanupÚ  s"   € Ø�‰×"Ñ"Ô$Ø�‰×!Ñ!Õ#rv   NrB  )rÒ  r   rÓ  r   ri   r
   r™   rš   rÀ   r^  rå   rv   rt   r  r  »  s#   „ ÙSóó
	
ó&ó#ó!ô$rv   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	y)r  z?Generate IR for a for loop of form `for x, ... in zip(a, ...)`.c                 ó   — yrI  rå   r6  s    rt   r2  zForZip.need_cleanupâ  r¡  rv   c           
     ó¤  — t        |«      t        |«      k(  sJ ‚t        t        |«      dz
  «      D �cg c]  }t        «       ‘Œ c}| j                  gz   | _        g | _        t        ||| j                  «      D ]Q  \  }}}t        | j                  |||| j                  | j                  d¬«      }| j
                  j                  |«       ŒS y c c}w )Nr†   TrÏ  )r›   Úranger   rm   Úcond_blocksÚgensrÅ   r]   rg   r  rl   Úappend)r3  ÚindexesÚexprsÚ_rh   ri   Ú
next_blockr•   s           rt   r~   zForZip.initç  sµ   € Ü�7‹|œs 5›zÒ)Ð)Ð)ô 38¼¸G»ÀqÑ8HÓ2IÖJ¨QœJ�LÒJÈdÏoÉoÐM^Ñ^ˆÔØ(*ˆŒ	Ü'*¨7°E¸4×;KÑ;KÓ'Lò 	"Ñ#ˆE�4˜Ü)Ø—‘˜e T¨:°t·~±~ÀtÇyÁyÐY]ôˆCð �I‰I×Ñ˜SÕ!ñ		"ùò Ks   ³Cc                óæ   — t        | j                  «      D ]Y  \  }}|j                  «        |t        | j                  «      dz
  k  sŒ2| j                  j                  | j                  |   «       Œ[ y rä   )r£   rÝ  r`   r›   rg   ra   rÜ  )r3  r°   r•   s      rt   r`   zForZip.gen_conditionó  s^   € Ü §	¡	Ó*ò 	A‰FˆAˆsØ×ÑÔØ”3�t—y‘y“> AÑ%Ó%Ø—‘×+Ñ+¨D×,<Ñ,<¸QÑ,?Õ@ñ	Arv   c                óF   — | j                   D ]  }|j                  «        Œ y rˆ   )rÝ  rb   ©r3  r•   s     rt   rb   zForZip.begin_bodyù  s   € Ø—9‘9ò 	ˆCØ�N‰NÕñ	rv   c                óF   — | j                   D ]  }|j                  «        Œ y rˆ   )rÝ  rc   rå  s     rt   rc   zForZip.gen_stepý  s   € Ø—9‘9ò 	ˆCØ�L‰L�Nñ	rv   c                óF   — | j                   D ]  }|j                  «        Œ y rˆ   )rÝ  r8  rå  s     rt   r8  zForZip.gen_cleanup  s   € Ø—9‘9ò 	ˆCØ�O‰OÕñ	rv   NrB  )rß  zlist[Lvalue]rà  rô   r™   rš   rÀ   r^  rå   rv   rt   r  r  ß  s$   „ ÙIóó

"óAóóôrv   r  c                óŽ  — t        | |«      }t        |t        t        f«      rt	        |«      S t        |t
        t        f«      rc|j                  D �cg c]  }t        |t        «      sŒt        | |«      ‘Œ! }}d |v�rut        d„ |j                  D «       «      }|t        |«      z   S t        |t        «      rt        | |j                  «      S t        |t        «      r‰t        |j                  t        «      ro|j                  j                  rYt        |j                  j                   t        «      r5|j                  j"                  rt	        |j                  j                   «      S t        |t$        «      �r{t        |j&                  x}t(        «      �r^t+        d„ |j,                  D «       «      �rA|j.                  }|dv r1t	        |j0                  «      dk(  rt        | |j0                  d   «      S |dk(  r1t	        |j0                  «      dk(  rt        | |j0                  d   «      S |dk(  rL|j0                  r@|j0                  D �cg c]  }t        | |«      ‘Œ }	}t+        d	„ |	D «       «      r„t3        |	«      S |d
k(  rtt	        |j0                  «      dk  r\|j0                  D �cg c]  }t        | |«      ‘Œ }
}t+        d„ |
D «       «      r'	 t	        t5        t7        t8        t:           |
«      Ž «      S | j?                  |«      }t        |t@        «      rt	        |jB                  «      S y c c}w c c}w c c}w # t<        $ r Y ŒQw xY w)Nc              3  ó>   K  — | ]  }t        |t        «       –— Œ y ­wrˆ   )r{   r   )r‰   r°   s     rt   r‹   z"get_expr_length.<locals>.<genexpr>  s   è ø€ ÒH¸œJ q¬(Ó3Ô3ÑHùs   ‚c              3  ó.   K  — | ]  }|t         k(  –— Œ y ­wrˆ   )r   )r‰   Úkinds     rt   r‹   z"get_expr_length.<locals>.<genexpr>  s   è ø€ Ò; D�œ•Ñ;ùs   ‚)zbuiltins.listzbuiltins.tuplerý   zbuiltins.sortedrÿ   r†   r   zbuiltins.maprû   rþ   c              3  ó$   K  — | ]  }|d u–— Œ
 y ­wrˆ   rå   ©r‰   Úargs     rt   r‹   z"get_expr_length.<locals>.<genexpr>1  s   è ø€ Ò: s�3˜d”?Ñ:ùs   ‚rö   rü   c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrˆ   )r{   r¿   rí  s     rt   r‹   z"get_expr_length.<locals>.<genexpr>5  s   è ø€ Ò?¨C”:˜c¤3×'Ñ?ùrŒ   )"r>   r{   ÚstrÚbytesr›   r   r   r¡   r   Úget_expr_lengthÚsumri   r   rÌ   r   Úis_finalÚfinal_valueÚhas_explicit_valuer   r  r   r¢   r  r÷   r	  ÚminrÛ  r   r¤   r¿   Ú
ValueErrorrŸ   r,   r    )rg   ri   Úfoldedr°   ÚstarsÚotherr  r÷   rî  Úarg_lengthsÚfolded_argsr«   s               rt   rò  rò    s˜  € Ü ¨Ó.€FÜ�&œ3¤˜,Ô'Ü�6‹{ÐÜ	�Dœ8¤YÐ/Ô	0ð 7;·j±jÖ\°ÄJÈqÔRZÕD[” ¨!Õ,Ð\ˆÐ\Ø�uÒÜÑH¸T¿Z¹ZÔHÓHˆEØœ3˜u›:Ñ%Ð%Ü	�Dœ(Ô	#Ü˜w¨¯	©	Ó2Ð2ä�4œÔ!Ü�t—y‘y¤#Ô&Ø�I‰I×ÒÜ�t—y‘y×,Ñ,¬cÔ2Ø�I‰I×(Ò(ä�4—9‘9×(Ñ(Ó)Ð)ä�4œÕ"Ü §¡Ð,�v¬hÕ7ÜÑ;¨D¯N©NÔ;Õ;à—?‘?ˆàðñô �D—I‘I“ !Ò#ä" 7¨D¯I©I°a©LÓ9Ð9Ø˜Ò'¬C°·	±	«N¸aÒ,?Ü" 7¨D¯I©I°a©LÓ9Ð9Ø˜Ò'¨D¯IªIØDHÇIÁIÖN¸Sœ?¨7°CÕ8ÐNˆKÐNÜÑ:¨kÔ:Ô:Ü˜;Ó'Ð'ØÐ)Ò)¬c°$·)±)«nÀÒ.AØGKÇyÁyÖQÀÔ-¨g°sÕ;ÐQˆKÐQÜÑ?°;Ô?Ô?ðÜœu¤d¬4´©9°kÓ&BÐCÓDÐDð ×Ñ˜dÓ#€EÜ�%œÔ Ü�5—;‘;ÓÐØùòo ]ùòF Oùò Røô "ò Ùðús*   ÁL)Á(L)ÉL.Ê$L3Ë%L8 Ì8	MÍMc                ó  — | j                  |«      }t        |«      st        |t        t        f«      sJ |«       ‚t        | |«      }|€| j                  j                  |||¬«      S t        ||r
t        «      S t        «      S )Nr�   )rŸ   r6   r{   r,   r.   rò  rg   r?  r   r0   r<   )rg   ri   r‚   rl   rŽ   r«   ry   s          rt   r¨   r¨   G  sz   € ð ×Ñ˜dÓ#€EÜ! %Ô(¬J°u¼vÄt¸nÔ,MÐTÈuÓTÐMÜ˜W dÓ+€FØ€~à�‰×*Ñ*¨8°TÈÐ*ÓWÐWä�6±]Ô1Ó]Ð]ÔH\Ó]Ð]rv   )rg   r=   rh   r   ri   r
   rj   ÚGenFuncrk   zGenFunc | Noner\   rA  rl   r¿   r™   rš   )rg   r=   rh   r   ri   r
   r‚   r*   rj   zCallable[[Value], None]rl   r¿   ry   r*   r™   rš   )
rg   r=   r•   r   r©   zCallable[[Value, int], Value]r–   z*Callable[[Value, Value, Value, int], None]r™   r‰  )rg   r=   r•   r   r™   r*   )rg   r=   r•   z'GeneratorExpr | DictionaryComprehensionr™   rA  )
rg   r=   rÛ   r.   r•   r   r×   r‰  r™   r*   )
rg   r=   rÈ   ró   r½   zCallable[[], None]rl   r¿   r™   rš   )ri   r   r™   rA  )FF)rg   r=   rh   r   ri   r
   rm   r   r  r   rl   r¿   r\   rA  r  rA  r™   rù   )
rg   r=   r†  r*   rh   r*   rl   r¿   r™   r*   )rg   r=   ri   r
   r™   z
int | None)rg   r=   ri   r
   r‚   r*   rl   r¿   rŽ   rA  r™   r*   )‰rF  Ú
__future__r   Úcollections.abcr   Útypingr   r   Ú
mypy.nodesr   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   Ú
mypy.typesr   r   r   r   Úmypyc.commonr   r   Úmypyc.ir.opsr   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   Úmypyc.ir.rtypesr+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   Úmypyc.irbuild.builderr=   Úmypyc.irbuild.constant_foldr>   Úmypyc.irbuild.targetsr?   r@   Úmypyc.irbuild.vecrA   rB   rC   rD   Úmypyc.primitives.dict_opsrE   rF   rG   rH   rI   rJ   rK   Úmypyc.primitives.exc_opsrL   rM   Úmypyc.primitives.generic_opsrN   rO   rP   rQ   Úmypyc.primitives.list_opsrR   rS   rT   rU   Úmypyc.primitives.misc_opsrV   Úmypyc.primitives.registryrW   Úmypyc.primitives.set_opsrX   Úmypyc.primitives.str_opsrY   Úmypyc.primitives.tuple_opsrZ   rÿ  ru   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å   rv   rt   ú<module>r     sœ  ðñõ #å $ß !÷÷ ÷ ÷ ñ ÷" QÓ Pß @÷÷ ÷ ÷ ñ ÷"÷ ÷ ÷ ÷ õ( ,Ý :ß Iß _Ó _÷÷ ñ ÷ Oß MÓ M÷ó õ >Ý :Ý /Ý ;Ý ?à
�2�t�8Ñ
€ð;'Øð;'àð;'ð ð;'ð ð	;'ð
 ð;'ð ð;'ð ð;'ð 
ó;'ð|7'Øð7'àð7'ð ð7'ð ð	7'ð
 (ð7'ð ð7'ð ð7'ð 
ó7'ðtUØðUà	ðUð 6ðUð <ð	Uð
 óUóp,ð:ØðØDðà	óó(+ð  Y]ñØðØ"&ðØ-:ðØIUðà
óð@BØðBàHðBð (ðBð ð	Bð
 
óBóJð Øð\Øð\àð\ð ð\ð ð	\ð
 ð\ð ð\ð ð\ð ð\ð ó\÷~7
ñ 7
ôt,?�,ô ,?ô^8Y˜ô 8Yôv;�|ô ;ó|Sô(Z5�,ô Z5ôzG?˜,ô G?ôT
Ð+ô 
ô&
Ð-ô 
ô&1Ð,ô 1ô<<6ˆ|ô <6ô~
˜ô 
ô8!$�<ô !$ôH$ˆ\ô $óN>ðB
^Øð
^Ø(ð
^Ø49ð
^ØADð
^ØUYð
^à
ô
^rv   