Ë
    Ç[;jì ã            	       ó  — d dl Z  e j                  dwi de“de“de“de“de“de“de“d	e“d
e“de“de“de“de“de“de“de“Ž d dlZd dl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 ddlmZ ddlm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 ddlmZmZ ddlmZ dd lmZ dd!lmZmZmZm Z   G d"„ d#«      Z! G d$„ d%e«      Z" G d&„ d'e«      Z#d(Z$d)Z%d*Z& G d+„ d,e«      Z' G d-„ d.e«      Z( G d/„ d0e«      Z)d1„ Z*d2„ Z+d3„ Z,e jZ                  d4e.d5e.fd6„«       Z/e jZ                  d7e.d8e.d9e.d:e.fd;„«       Z0 G d<„ d=ee!«      Z1 G d>„ d?ee!«      Z2 G d@„ dAe«      Z3 G dB„ dCee!«      Z4 G dD„ dEee!«      Z5 G dF„ dGee!«      Z6 G dH„ dIee!«      Z7 G dJ„ dKee!«      Z8 G dL„ dMee!«      Z9 G dN„ dOe«      Z: G dP„ dQe«      Z;dR„ Z< G dS„ dTe«      Z= G dU„ dVe«      Z> G dW„ dXe«      Z? G dY„ dZe«      Z@ G d[„ d\ee!«      ZA G d]„ d^e«      ZB G d_„ d`e«      ZC G da„ dbe«      ZD G dc„ dde«      ZE G de„ dfe«      ZF G dg„ dhe«      ZG G di„ djee!«      ZH G dk„ dle«      ZI G dm„ dnee!«      ZJ G do„ dpe«      ZK G dq„ dre«      ZL G ds„ dte«      ZM G du„ dve«      ZNy)xé    NÚ
PyrexTypesÚNamingÚ	ExprNodesÚNodesÚOptionsÚ	UtilNodesÚLetNodeÚ
LetRefNodeÚTreeFragmentÚEncodedStringÚerrorÚwarningÚcopyÚhashlibÚsysÚ
itemgetter)r   é   )ÚCode)r   )r   )r   )r   )r   )ÚBuiltin)ÚErrors)ÚVisitorTransformÚTreeVisitor)ÚCythonTransformÚEnvTransformÚScopeTrackingTransform)r	   r
   )r   )r   )r   r   ÚCompileErrorÚInternalErrorc                   ó:   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
y	)
ÚSkipDeclarationsa)  
    Variable and function declarations can often have a deep tree structure,
    and yet most transformations don't need to descend to this depth.

    Declaration nodes are removed after AnalyseDeclarationsTransform, so there
    is no need to use this for transformations after that point.
    c                 ó   — |S ©N© ©ÚselfÚnodes     úlG:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\Cython/Compiler/ParseTreeTransforms.pyÚvisit_CTypeDefNodez#SkipDeclarations.visit_CTypeDefNode&   ó   € Øˆó    c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CVarDefNodez"SkipDeclarations.visit_CVarDefNode)   r(   r)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CDeclaratorNodez&SkipDeclarations.visit_CDeclaratorNode,   r(   r)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CBaseTypeNodez$SkipDeclarations.visit_CBaseTypeNode/   r(   r)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CEnumDefNodez#SkipDeclarations.visit_CEnumDefNode2   r(   r)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CStructOrUnionDefNodez,SkipDeclarations.visit_CStructOrUnionDefNode5   r(   r)   c                 óF   — |j                   dk7  r| j                  |«       |S ©NÚextern)Ú
visibilityÚvisitchildrenr#   s     r&   Úvisit_CppClassNodez#SkipDeclarations.visit_CppClassNode8   s!   € Ø�?‰?˜hÒ&à×Ñ˜tÔ$Øˆr)   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r'   r+   r-   r/   r1   r3   r9   r"   r)   r&   r   r      s*   „ ñòòòòòòór)   r   c                   óZ   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zdd„Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zˆ xZS )ÚNormalizeTreea\  
    This transform fixes up a few things after parsing
    in order to make the parse tree more suitable for
    transforms.

    a) After parsing, blocks with only one statement will
    be represented by that statement, not by a StatListNode.
    When doing transforms this is annoying and inconsistent,
    as one cannot in general remove a statement in a consistent
    way and so on. This transform wraps any single statements
    in a StatListNode containing a single statement.

    b) The PassStatNode is a noop and serves no purpose beyond
    plugging such one-statement blocks; i.e., once parsed a
`    "pass" can just as well be represented using an empty
    StatListNode. This means less special cases to worry about
    in subsequent transforms (one always checks to see if a
    StatListNode has no children to see if the block is empty).
    c                 ó@   •— t         ‰| �  |«       d| _        d| _        y ©NF)ÚsuperÚ__init__Úis_in_statlistÚ
is_in_expr©r$   ÚcontextÚ	__class__s     €r&   rC   zNormalizeTree.__init__T   s   ø€ Ü‰Ñ˜Ô!Ø#ˆÔØˆ�r)   c                 óÒ   — | j                  |«       t        |j                  t        j                  «      s1t        j                  |j
                  |j                  g¬«      |_        |S ©N©ÚposÚstats)r8   Ú
isinstanceÚbodyr   ÚStatListNoderL   r#   s     r&   Úvisit_ModuleNodezNormalizeTree.visit_ModuleNodeY   sG   € Ø×Ñ˜4Ô Ü˜$Ÿ)™)¤U×%7Ñ%7Ô8ä×*Ñ*¨t¯x©xÀÇ	Á	¸{ÔKˆDŒIØˆr)   c                 ó\   — | j                   }d| _         | j                  |«       || _         |S ©NT)rE   r8   )r$   r%   Ústacktmps      r&   Úvisit_ExprNodezNormalizeTree.visit_ExprNode`   s,   € Ø—?‘?ˆØˆŒØ×Ñ˜4Ô Ø"ˆŒØˆr)   c                 óÐ   — | j                   }|| _         | j                  |«       || _         | j                   s.| j                  s"t        j                  |j
                  |g¬«      S |S rJ   )rD   r8   rE   r   rP   rL   )r$   r%   Úis_listcontainerrT   s       r&   Úvisit_StatNodezNormalizeTree.visit_StatNodeg   sX   € Ø×&Ñ&ˆØ.ˆÔØ×Ñ˜4Ô Ø&ˆÔØ×"Ò"¨4¯?ª?Ü×%Ñ%¨$¯(©(¸4¸&ÔAÐAàˆKr)   c                 óD   — d| _         | j                  |«       d| _         |S ©NTF)rD   r8   r#   s     r&   Úvisit_StatListNodez NormalizeTree.visit_StatListNodeq   s%   € Ø"ˆÔØ×Ñ˜4Ô Ø#ˆÔØˆr)   c                 ó&   — | j                  |d«      S rS   ©rX   r#   s     r&   Úvisit_ParallelAssignmentNodez*NormalizeTree.visit_ParallelAssignmentNodew   ó   € Ø×"Ñ" 4¨Ó.Ð.r)   c                 ó&   — | j                  |d«      S rS   r]   r#   s     r&   r1   z NormalizeTree.visit_CEnumDefNodez   r_   r)   c                 ó&   — | j                  |d«      S rS   r]   r#   s     r&   r3   z)NormalizeTree.visit_CStructOrUnionDefNode}   r_   r)   c                 ó¢   — |j                   j                  r)t        j                  |j                   j                  «      S | j                  |«      S )z!Eliminate useless string literals)ÚexprÚis_string_literalr   ÚPassStatNoderL   rX   r#   s     r&   Úvisit_ExprStatNodez NormalizeTree.visit_ExprStatNode€   s9   € à�9‰9×&Ò&Ü×%Ñ% d§i¡i§m¡mÓ4Ð4à×&Ñ& tÓ,Ð,r)   c                 ó   — |S r!   r"   r#   s     r&   r-   z#NormalizeTree.visit_CDeclaratorNode‡   r(   r)   ©F)r:   r;   r<   r=   rC   rQ   rU   rX   r[   r^   r1   r3   rf   r-   Ú__classcell__©rH   s   @r&   r?   r?   ?   s:   ø„ ñô( ò
òóòò/ò/ò/ò-ör)   r?   c                   ó   — e Zd Zy)ÚPostParseErrorN)r:   r;   r<   r"   r)   r&   rl   rl   ‹   s   … r)   rl   zHCannot assign default value to fields in cdef classes, structs or unionsz0Invalid buffer defaults specification (see docs)z0Special attributes must not have a type declaredc                   óŽ   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zˆ xZS )Ú	PostParsea©  
    Basic interpretation of the parse tree, as well as validity
    checking that can be done on a very basic level on the parse
    tree (while still not being a problem with the basic syntax,
    as such).

    Specifically:
    - Default values to cdef assignments are turned into single
    assignments following the declaration (everywhere but in class
    bodies, where they raise a compile error)

    - Interpret some node structures into Python runtime values.
    Some nodes take compile-time arguments (currently:
    TemplatedTypeNode[args] and __cythonbufferdefaults__ = {args}),
    which should be interpreted. This happens in a general way
    and other steps should be taken to ensure validity.

    Type arguments cannot be interpreted in this way.

    - For __cythonbufferdefaults__ the arguments are checked for
    validity.

    TemplatedTypeNode has its directives interpreted:
    Any first positional argument goes into the "dtype" attribute,
    any "ndim" keyword argument goes into the "ndim" attribute and
    so on. Also it is checked that the directive combination is valid.
    - __cythonbufferdefaults__ attributes are parsed and put into the
    type information.

    Note: Currently Parsing.py does a lot of interpretation and
    reorganization that can be refactored into this transform
    if a more pure Abstract Syntax Tree is wanted.

    - Some invalid uses of := assignment expressions are detected
    c                 óX   •— t         ‰| �  |«       d| j                  i| _        d| _        y )NÚ__cythonbufferdefaults__F)rB   rC   Úhandle_bufferdefaultsÚspecialattribute_handlersÚin_pattern_noderF   s     €r&   rC   zPostParse.__init__µ   s/   ø€ Ü‰Ñ˜Ô!à&¨×)CÑ)Cð*
ˆÔ&ð  %ˆÕr)   c           	      óf  — t        «       }|j                  |j                  «       |j                  s0|j                  s$t        |j                  t        j                  «      r6t        j                  |j                  j                  |j                  ¬«      }n5t        j                  |j                  j                  |j                  ¬«      }t        j                  |j                  |j                  |j                  |j                  |j                   |d ¬«      |_        | j                  |«       |S )N©rc   ©Úvalue)ÚnameÚargsÚstar_argÚstarstar_argrO   Údoc)ÚYieldNodeCollectorr8   Úresult_exprÚ	has_yieldÚ	has_awaitrN   r   ÚYieldExprNoder   ÚExprStatNoderL   ÚReturnStatNodeÚDefNoderx   ry   rz   r{   Údef_node)r$   r%   Ú	collectorrO   s       r&   Úvisit_LambdaNodezPostParse.visit_LambdaNode¼   sâ   € ä&Ó(ˆ	Ø×Ñ × 0Ñ 0Ô1Ø×Ò )×"5Ò"5¼ÀD×DTÑDTÔV_×VmÑVmÔ9nÜ×%Ñ%Ø× Ñ ×$Ñ$¨4×+;Ñ+;ô=‰Dô ×'Ñ'Ø× Ñ ×$Ñ$¨D×,<Ñ,<ô>ˆDäŸ™Ø�H‰H˜4Ÿ9™9Ø—‘ T§]¡]Ø×*Ñ*Ø˜4ô	!ˆŒð
 	×Ñ˜4Ô Øˆr)   c                 ój  — t        «       }|j                  |j                  d dg¬«       t        j                  |j
                  |j                  d g d d |j                  |j                  d¬«	      |_        t        j                  |j                  | j                  dv ¬«       | j                  |«       |S )NÚiterator©ÚattrsÚexcludeT)rx   r|   ry   rz   r{   rO   Úis_async_defÚis_generator_expression©ÚpyclassÚcclass©Úscope_is_class)r}   r8   Úloopr   r„   rL   rx   r€   r…   Ú_AssignmentExpressionCheckerÚ	do_checksÚ
scope_type©r$   r%   r†   s      r&   Úvisit_GeneratorExpressionNodez'PostParse.visit_GeneratorExpressionNodeÎ   s“   € ä&Ó(ˆ	Ø×Ñ §	¡	°À
¸|ÐÔLÜŸ™Ø�H‰H˜4Ÿ9™9¨$Ø˜d°Ø—‘¨×)<Ñ)<Ø$(ô	*ˆŒô
 	%×.Ñ.¨t¯y©yÈÏÉÐ\qÐIqÐ.ÔrØ×Ñ˜4Ô Øˆr)   c                 ó
  — |j                   s8t        «       }|j                  |j                  «       |j                  rd|_         t
        j                  |j                  | j                  dv ¬«       | j                  |«       |S )NTr�   r’   )Úhas_local_scoper}   r8   r”   r€   r•   r–   r—   r˜   s      r&   Úvisit_ComprehensionNodez!PostParse.visit_ComprehensionNodeÛ   sj   € à×#Ò#Ü*Ó,ˆIØ×#Ñ# D§I¡IÔ.Ø×"Ò"Ø'+�Ô$Ü$×.Ñ.¨t¯y©yÈÏÉÐ\qÐIqÐ.ÔrØ×Ñ˜4Ô Øˆr)   c                 óì   — t        |j                  t        j                  «      st	        |j
                  t        «      ‚|j                  | j                  _        |j
                  | j                  _	        y r!   )
rN   Údefaultr   ÚDictNoderl   rL   ÚERR_BUF_DEFAULTSÚ
scope_nodeÚbuffer_defaults_nodeÚbuffer_defaults_pos)r$   Údecls     r&   rq   zPostParse.handle_bufferdefaultsç   sH   € Ü˜$Ÿ,™,¬	×(:Ñ(:Ô;Ü  §¡Ô+;Ó<Ð<Ø/3¯|©|ˆ�‰Ô,Ø.2¯h©hˆ�‰Õ+r)   c           
      óD  — 	 | j                  |«       |g}g }|j                  D �]À  }|}t        |t        j                  t        j
                  f«      r7|j                  }t        |t        j                  t        j
                  f«      rŒ7t        |t        j                  «      �r.|j                  ��!| j                  dv r�t        | j                  t        j                  «      rO| j                  j                  |j                  «      }|r(||urt        |j                   t"        «      ‚ ||«       �Œt        |j                   t$        «      ‚| j                  dk7  }|j'                  t        j(                  |j                   t+        j,                  |j                   |j                  ¬«      |j                  ||j.                  ¬«      «       d |_        |j'                  |«       �ŒÃ ||_        |S # t        $ r%}| j0                  j3                  |«       Y d }~y d }~ww xY w)N)r‘   r�   ÚstructÚmodule©rx   )ÚlhsÚrhsÚfirstÚfrom_pxd_cvardef)r8   ÚdeclaratorsrN   r   ÚCPtrDeclaratorNodeÚCConstDeclaratorNodeÚbaseÚCNameDeclaratorNoderž   r—   r¡   ÚCClassDefNoderr   Úgetrx   rl   rL   ÚERR_INVALID_SPECIALATTR_TYPEÚERR_CDEF_INCLASSÚappendÚSingleAssignmentNoder   ÚNameNodeÚin_pxdrG   Únonfatal_error)	r$   r%   rM   Únewdeclsr¤   ÚdeclbaseÚhandlerÚfirst_assignmentÚes	            r&   r+   zPostParse.visit_CVarDefNodeí   s¬  € ð
 	Ø×Ñ˜tÔ$Ø�FˆEØˆHØ×(Õ(�Ø�Ü  ¬E×,DÑ,DÄe×F`ÑF`Ð+aÔbØ'Ÿ}™}�Hô ! ¬E×,DÑ,DÄe×F`ÑF`Ð+aÕbä˜h¬×(AÑ(AÕBØ×'Ñ'Ñ3ØŸ?™?Ð.MÑMÜ)¨$¯/©/¼5×;NÑ;NÔOØ*.×*HÑ*H×*LÑ*LÈTÏYÉYÓ*W Ù#*Ø'+°8Ñ';Ü.<¸T¿X¹XÔGcÓ.dÐ(dÙ$+¨D¤MÙ$,Ü"0°·±Ô;KÓ"LÐLØ+/¯?©?¸hÑ+FÐ(ØŸ™¤U×%?Ñ%?ÀÇÁÜ )× 2Ñ 2°4·8±8À(Ç-Á-Ô PØ (× 0Ñ 0Ð8HØ-1¯[©[ô&:ô ;ð ,0˜Ô(Ø—‘ Ö%ð+ )ð,  (ˆDÔØˆLøÜò 	ð �L‰L×'Ñ'¨Ô*Üûð		ús   ‚BG1 ÂE%G1 Ç1	HÇ:HÈHc                 ót   — | j                  |«       | j                  ||j                  |j                  g«      S r!   )r8   Ú_visit_assignment_noder©   rª   r#   s     r&   Úvisit_SingleAssignmentNodez$PostParse.visit_SingleAssignmentNode  s0   € Ø×Ñ˜4Ô Ø×*Ñ*¨4°$·(±(¸D¿H¹HÐ1EÓFÐFr)   c                 óx   — | j                  |«       | j                  ||j                  |j                  gz   «      S r!   )r8   rÁ   Úlhs_listrª   r#   s     r&   Úvisit_CascadedAssignmentNodez&PostParse.visit_CascadedAssignmentNode  s2   € Ø×Ñ˜4Ô Ø×*Ñ*¨4°·±À$Ç(Á(ÀÑ1KÓLÐLr)   c                 óª  — t        |D �cg c]  }|j                  s|j                  rd‘Œ c}«      dk  r|S g }t        ||«       g }t	        ||«       g }|D ]s  }|dd }|d   }t        |«      dk(  r&t        j                  |j                  |d   |¬«      }n"t        j                  |j                  ||¬«      }|j                  |«       Œu t        |«      dk(  r|d   }	n$t        j                  |d   j                  |¬«      }	|rB|D �
cg c]  }
|
j                  |
f‘Œ }}
t        |«       |ddd…   D ]  \  }}t        ||	«      }	Œ |	S c c}w c c}
w )	zgFlatten parallel assignments into separate single
        assignments or cascaded assignments.
        r   é   Néÿÿÿÿr   ©r©   rª   )rÄ   rª   ©rM   )ÚsumÚis_sequence_constructorrd   Úflatten_parallel_assignmentsÚeliminate_rhs_duplicatesÚlenr   r·   rL   ÚCascadedAssignmentNoder¶   ÚParallelAssignmentNodeÚ
expressionÚsort_common_subsequencesr	   )r$   r%   Ú	expr_listrc   Úexpr_list_listÚ	temp_refsÚnodesrÄ   rª   Úassign_nodeÚtempÚduplicates_and_tempsÚ_Útemp_refs                 r&   rÁ   z PostParse._visit_assignment_node#  sy  € ô ™yó M™y�tØ×0Ò0°D×4JÒ4Jò ˜yñ Mó NØPQòRð ˆKàˆÜ$ Y°Ô?Øˆ	Ü  °Ô;àˆÛ'ˆIØ   "�~ˆHØ˜B‘-ˆCÜ�8‹} Ò!Ü×1Ñ1°#·'±'Ø" 1™+¨Sô2‘ô ×3Ñ3°C·G±GØ'¨sô4�à�L‰L˜Õð (ô ˆu‹:˜Š?Ø ™(‰Kä×6Ñ6°u¸Q±x·|±|ÈUÔSˆKáá1:ó$=Ù1:¨ð '+§o¡o°tÒ%<Ø1:ð !ð $=ä$Ð%9Ô:Ø3±D°b°DÔ9‘��8Ü% h°Ó<‘ð  :ð ÐùòEMùò8$=s   Š!EÄEc                 óˆ   — |j                   D ]2  }|j                  r| j                  ||«       Œ"|j                  |«       Œ4 |S r!   )ry   rÌ   Ú_flatten_sequencer¶   )r$   ÚseqÚresultÚargs       r&   rÞ   zPostParse._flatten_sequenceK  s<   € Ø—8”8ˆCØ×*Ò*Ø×&Ñ& s¨FÕ3à—‘˜cÕ"ð	 ð
 ˆr)   c                 óV   — | j                  |«       | j                  |g «      |_        |S r!   )r8   rÞ   ry   r#   s     r&   Úvisit_DelStatNodezPostParse.visit_DelStatNodeS  s)   € Ø×Ñ˜4Ô Ø×*Ñ*¨4°Ó4ˆŒ	Øˆr)   c                 óâ  — |j                   rÑt        j                  |j                  t	        j
                  |j                  j                  |j                  j                  ¬«      gd¬«      }t        j                  |j                  t        j                  |j                  |j                  t        j                  |j                  |g¬«      ¬«      g¬«      |_
        | j                  |«       |S )Nr¨   T)ry   Úignore_nonexistingrÊ   )rO   Úfinally_clause)Úis_except_asr   ÚDelStatNoderL   r   r¸   Útargetrx   rP   ÚTryFinallyStatNoderO   r8   )r$   r%   Ú
del_targets      r&   Úvisit_ExceptClauseNodez PostParse.visit_ExceptClauseNodeX  sº   € Ø×Òä×*Ñ*Ø—‘Ü×(Ñ(Ø—K‘K—O‘O¨$¯+©+×*:Ñ*:ô<ð =à#'ô	)ˆJô
 ×*Ñ*Ø—‘Ü×/Ñ/Ø—H‘HØŸ™Ü#(×#5Ñ#5ØŸ™Ø)˜lô$,ô-ð .ô/ˆDŒIð 	×Ñ˜4Ô Øˆr)   c           	      ó  — |j                   €dt        j                  |j                  t	        j
                  |j                  t        d«      ¬«      |j                  dddd¬«      |_         d|_        | j                  |«       |S )zUExtract the exception raising into a RaiseStatNode to simplify GIL handling.
        NÚAssertionErrorr¨   T)Úexc_typeÚ	exc_valueÚexc_tbÚcauseÚbuiltin_exc_nameÚwrap_tuple_value)	Ú	exceptionr   ÚRaiseStatNoderL   r   r¸   r   rw   r8   r#   s     r&   Úvisit_AssertStatNodezPostParse.visit_AssertStatNodek  sp   € ð �>‰>Ð!Ü"×0Ñ0Ø—‘Ü"×+Ñ+¨D¯H©H¼=ÐIYÓ;ZÔ[ØŸ*™*ØØØ!1Ø!%ôˆDŒNð ˆDŒJØ×Ñ˜4Ô Øˆr)   c                 óD   — t        |j                  |j                  «       y r!   )r   rL   Úwhatr#   s     r&   Úvisit_ErrorNodezPostParse.visit_ErrorNode|  s   € Üˆd�h‰h˜Ÿ	™	Ô"Ør)   c                 óH   — |j                  «        | j                  |«       |S r!   )Úvalidate_targetsr8   r#   s     r&   Úvisit_MatchCaseNodezPostParse.visit_MatchCaseNode€  s!   € Ø×ÑÔØ×Ñ˜4Ô Øˆr)   c                 óH   — |j                  «        | j                  |«       |S r!   )Úvalidate_irrefutabler8   r#   s     r&   Úvisit_MatchNodezPostParse.visit_MatchNode…  s!   € Ø×!Ñ!Ô#Ø×Ñ˜4Ô Øˆr)   c                 ó^   — | j                   dc}| _         | j                  |«       || _         |S rS   )rs   r8   )r$   r%   rs   s      r&   Úvisit_PatternNodezPostParse.visit_PatternNodeŠ  s2   € Ø04×0DÑ0DÀdÐ-ˆ˜Ô-Ø×Ñ˜4Ô Ø.ˆÔØˆr)   c                 ól   — | j                   rt        |j                  d«       | j                  |«       |S )Nz/f-strings are not accepted for pattern matching)rs   r   rL   r8   r#   s     r&   Úvisit_JoinedStrNodezPostParse.visit_JoinedStrNode�  s-   € Ø×ÒÜ�$—(‘(ÐMÔNØ×Ñ˜4Ô Øˆr)   c                 óª   — | j                   dk(  r4|j                  dv r&t        |j                  d|j                  › d�d«       y | j	                  |«      S )Nr‘   )Ú__getreadbuffer__Ú__getwritebuffer__Ú__getsegcount__Ú__getcharbuffer__Ú'zD' relates to the old Python 2 buffer protocol and is no longer used.rÇ   )r—   rx   r   rL   Úvisit_FuncDefNoder#   s     r&   Úvisit_DefNodezPostParse.visit_DefNode–  sT   € Ø�O‰O˜xÒ'Ø—	‘	ÐpÑpÜ�D—H‘H  $§)¡) ð --ð -Ø./ô1àØ×%Ñ% dÓ+Ð+r)   )r:   r;   r<   r=   rC   r‡   r™   rœ   rq   r+   rÂ   rÅ   rÁ   rÞ   rã   rì   r÷   rú   rý   r   r  r  r  ri   rj   s   @r&   rn   rn   ‘   sl   ø„ ñ"ôF%òò$ò	ò7ò%ò\GòMò&òPòò
ò&ò"òò
ò
òö,r)   rn   c                   ó<   ‡ — e Zd Zˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Zˆ xZ	S )Ú%_AssignmentExpressionTargetNameFinderc                 ó0   •— t         ‰| �  «        i | _        y r!   )rB   rC   Útarget_names©r$   rH   s    €r&   rC   z._AssignmentExpressionTargetNameFinder.__init__   s   ø€ Ü‰ÑÔØˆÕr)   c                 óº   — |j                   r|j                  gS |j                  r5g }|j                  D ]"  }|j	                  | j                  |«      «       Œ$ |S g S r!   )Úis_namerx   rÌ   ry   ÚextendÚfind_target_names)r$   ré   Únamesrá   s       r&   r  z7_AssignmentExpressionTargetNameFinder.find_target_names¤  sR   € Ø�>Š>Ø—K‘K�=Ð Ø×+Ò+ØˆEØ—{”{�Ø—‘˜T×3Ñ3°CÓ8Õ9ð #àˆLàˆ	r)   c                 óˆ   — t        | j                  |j                  «      «      | j                  |<   | j	                  |«       y r!   )Útupler  ré   r  r8   r#   s     r&   Úvisit_ForInStatNodez9_AssignmentExpressionTargetNameFinder.visit_ForInStatNode¯  s4   € Ü"'¨×(>Ñ(>¸t¿{¹{Ó(KÓ"Lˆ×Ñ˜$ÑØ×Ñ˜4Õ r)   c                  ó   — y r!   r"   r#   s     r&   rœ   z=_AssignmentExpressionTargetNameFinder.visit_ComprehensionNode³  ó   € Ør)   c                  ó   — y r!   r"   r#   s     r&   r‡   z6_AssignmentExpressionTargetNameFinder.visit_LambdaNode¶  r  r)   c                 ó&   — | j                  |«       y r!   ©r8   r#   s     r&   Ú
visit_Nodez0_AssignmentExpressionTargetNameFinder.visit_Node¹  ó   € Ø×Ñ˜4Õ r)   )
r:   r;   r<   rC   r  r  rœ   r‡   r  ri   rj   s   @r&   r  r  Ÿ  s!   ø„ ôò	ò!òòö!r)   r  c                   ób   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zed„ «       Zd„ Z	d„ Z
d„ Zd	„ Zd
„ Zd„ Zˆ xZS )r•   za
    Enforces rules on AssignmentExpressions within generator expressions and comprehensions
    c                 óD  •— t         ‰| �  «        t        «       }|j                  |«       |j                  | _        d| _        d| _        || _        d| _	        t        «       | _        | j
                  j                  «       D ]  }| j                  j                  |«       Œ y ©NFr"   )rB   rC   r  Úvisitr  Útarget_names_dictÚin_iteratorÚin_nested_generatorr“   Úcurrent_target_namesÚsetÚall_target_namesÚvaluesÚupdate)r$   Ú	loop_noder“   Útarget_name_finderr  rH   s        €r&   rC   z%_AssignmentExpressionChecker.__init__Á  sŠ   ø€ Ü‰ÑÔäBÓDÐØ× Ñ  Ô+Ø!3×!@Ñ!@ˆÔØ ˆÔØ#(ˆÔ Ø,ˆÔØ$&ˆÔ!Ü #£ˆÔØ×+Ñ+×2Ñ2Ö4ˆEØ×!Ñ!×(Ñ(¨Õ/ñ 5r)   c                 óÀ   — | j                   | j                  | j                  | j                  | j                  f}d| _        d| _        d| _        t        «       | _        |S r#  )r&  r'  r“   r*  r(  r)  ©r$   Ú	old_states     r&   Ú_reset_statez)_AssignmentExpressionChecker._reset_stateÏ  se   € Ø×%Ñ% t×'?Ñ'?À×ATÑATÐVZ×VkÑVkÐmq÷  nGñ  nGð  Hˆ	à#(ˆÔ Ø#ˆÔØ$&ˆÔ!Ü #£ˆÔØÐr)   c                 óF   — |\  | _         | _        | _        | _        | _        y r!   )r&  r'  r“   r*  r(  r0  s     r&   Ú
_set_statez'_AssignmentExpressionChecker._set_stateØ  s&   € ð }FÑyˆÔ˜$Ô2°DÔ4GÈÔI^Ð`dÕ`yr)   c                 ó8   —  | ||«      }|j                  |«       y r!   )r$  )Úclsr-  r“   Úcheckers       r&   r–   z&_AssignmentExpressionChecker.do_checksÛ  s   € á�i Ó0ˆØ�‰�iÕ r)   c                 óD  — | j                   r| j                  |«       y | j                  }| j                  j	                  |d «      }|r| xj                  |z  c_        d| _        | j                  |j                  «       d| _        | j                  |d¬«       || _        y )NTF)r‰   ©rŒ   )r'  r8   r(  r%  r³   r&  r$  r‰   )r$   r%   r(  Útarget_names       r&   r  z0_AssignmentExpressionChecker.visit_ForInStatNodeà  s�   € Ø×#Ò#Ø×Ñ˜tÔ$Øà#×8Ñ8ÐØ×,Ñ,×0Ñ0°°tÓ<ˆÙØ×%Ò%¨Ñ4Õ%àˆÔØ�
‰
�4—=‘=Ô!Ø ˆÔØ×Ñ˜4¨ÐÔ7à$8ˆÕ!r)   c                 ó|  — | j                   rt        |j                  d«       | j                  rt        |j                  d«       |j                  | j
                  v r$t        |j                  d|j                  z  «       y |j                  | j                  v r$t        |j                  d|j                  z  «       y y )NzKassignment expression cannot be used in a comprehension iterable expressionzKassignment expression within a comprehension cannot be used in a class bodyzIassignment expression cannot rebind comprehension iteration variable '%s'zHcomprehension inner loop cannot rebind assignment expression target '%s')r&  r   rL   r“   r:  r(  r*  r#   s     r&   Úvisit_AssignmentExpressionNodez;_AssignmentExpressionChecker.visit_AssignmentExpressionNodeñ  s�   € Ø×ÒÜ�$—(‘(ÐiÔjØ×ÒÜ�$—(‘(ÐiÔjØ×Ñ˜t×8Ñ8Ñ8Ü�$—(‘(ÐgØ×"Ñ"ñ#õ $à×Ñ ×!6Ñ!6Ñ6Ü�$—(‘(ÐfØ×"Ñ"ñ#õ $ð 7r)   c                 ó|   — | j                  «       }| j                  |j                  «       | j                  |«       y r!   )r2  r$  r~   r4  )r$   r%   r1  s      r&   r‡   z-_AssignmentExpressionChecker.visit_LambdaNodeý  s0   € ð ×%Ñ%Ó'ˆ	à�
‰
�4×#Ñ#Ô$Ø�‰˜	Õ"r)   c                 óZ   — | j                   }d| _         | j                  |«       || _         y rS   )r'  r8   ©r$   r%   r'  s      r&   rœ   z4_AssignmentExpressionChecker.visit_ComprehensionNode  s,   € Ø"×6Ñ6ÐØ#'ˆÔ Ø×Ñ˜4Ô Ø#6ˆÕ r)   c                 ón   — | j                   }d| _         | j                  |j                  «       || _         y rS   )r'  r$  r”   r?  s      r&   r™   z:_AssignmentExpressionChecker.visit_GeneratorExpressionNode  s.   € Ø"×6Ñ6ÐØ#'ˆÔ à�
‰
�4—9‘9ÔØ#6ˆÕ r)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   r  z'_AssignmentExpressionChecker.visit_Node  r   r)   )r:   r;   r<   r=   rC   r2  r4  Úclassmethodr–   r  r<  r‡   rœ   r™   r  ri   rj   s   @r&   r•   r•   ½  sJ   ø„ ñô0òòFð ñ!ó ð!ò9ò"
$ò#ò7ò7ö!r)   r•   c                 ó
  ‡‡‡‡‡— t        «       Ši Šˆˆˆˆfd„Š| D ]  }|d   } ‰|«       Œ ‰syˆˆfd„Š‰D ]3  }|j                  sŒt        t        ‰|j                  «      «      |_        Œ5 | D ]  } ‰|d   «      |d<   Œ y)zÞReplace rhs items by LetRefNodes if they appear more than once.
    Creates a sequence of LetRefNodes that set up the required temps
    and appends them to ref_node_sequence.  The input list is modified
    in-place.
    c                 óü   •— | j                   s| j                  ry | ‰v r'| ‰vr"t        | «      }|‰| <   ‰j                  |«       y y ‰j	                  | «       | j
                  r| j                  D ]
  } ‰|«       Œ y y r!   )Ú
is_literalr  r
   r¶   ÚaddrÌ   ry   )r%   Úref_nodeÚitemÚfind_duplicatesÚref_node_sequenceÚ	ref_nodesÚ
seen_nodess      €€€€r&   rI  z1eliminate_rhs_duplicates.<locals>.find_duplicates  s}   ø€ Ø�?Š?˜dŸlšlð Ø�:ÑØ˜9Ñ$Ü% dÓ+�Ø"*�	˜$‘Ø!×(Ñ(¨Õ2ð %ð
 �N‰N˜4Ô Ø×+Ò+Ø ŸIœI�DÙ# DÕ)ñ &ð ,r)   rÈ   Nc                 óz   •— | ‰v r‰|    S | j                   r$t        t        ‰| j                  «      «      | _        | S r!   )rÌ   ÚlistÚmapry   )r%   rK  Úsubstitute_nodess    €€r&   rP  z2eliminate_rhs_duplicates.<locals>.substitute_nodes4  s;   ø€ Ø�9ÑØ˜T‘?Ð"Ø×)Ò)ÜœSÐ!1°4·9±9Ó=Ó>ˆDŒIØˆr)   )r)  rÌ   rN  rO  ry   )	rÕ   rJ  rÔ   rª   r%   rI  rK  rL  rP  s	    `   @@@@r&   rÎ   rÎ     s‹   ü€ ô “€JØ€I÷*ó  $ˆ	Ø˜‰mˆÙ˜Õð $ñ Øõó ˆØ×'Ó'ÜœSÐ!1°4·9±9Ó=Ó>ˆD�Ið ó
 $ˆ	Ù(¨°2©Ó7ˆ	�"Šñ $r)   c                 óì   ‡— ˆfd„Šˆfd„}t        | «      D ][  \  }}|d   }|}t        |dz
  dd«      D ]  } ||| |   d   «      sŒ|}Œ ||k7  sŒ:t        ||d«      D ]  }| |dz
     | |<   Œ || |<   Œ] y)a  Sort items/subsequences so that all items and subsequences that
    an item contains appear before the item itself.  This is needed
    because each rhs item must only be evaluated once, so its value
    must be evaluated first and then reused when packing sequences
    that contain it.

    This implies a partial order, and the sort must be stable to
    preserve the original order as much as possible, so we use a
    simple insertion sort (which is very fast for short sequences, the
    normal case in practice).
    c                 ód   •— | D ]*  }||u r y|j                   sŒ ‰|j                  |«      sŒ* y yrZ   ©rÌ   ry   )rß   ÚxrH  Úcontainss      €r&   rU  z*sort_common_subsequences.<locals>.containsP  s5   ø€ ÛˆDØ�q‰yÙØ×-Ó-±(¸4¿9¹9ÀaÕ2HÙð	 ð
 r)   c                 óF   •— |j                   xr  ‰|j                  | «      S r!   rS  )ÚaÚbrU  s     €r&   Ú
lower_thanz,sort_common_subsequences.<locals>.lower_thanW  s   ø€ Ø×(Ñ(Ò@©X°a·f±f¸aÓ-@Ð@r)   r   rÈ   r   N)Ú	enumerateÚrange)ÚitemsrY  rL   rH  ÚkeyÚnew_posÚirU  s          @r&   rÓ   rÓ   D  s•   ø€ ôôAô ˜uÖ%‰	ˆˆTØ�1‰gˆØˆÜ�s˜1‘u˜b "Ö%ˆAÙ˜#˜u Q™x¨™{Õ+Ø‘ð &ð �c‹>Ü˜3 ¨Ö,�Ø   1¡™:��a’ð -à!ˆE�'ŠNñ &r)   c                 óº   — g }| j                   }| j                  }| j                  }|j                  }|D ]#  } ||«      }|j                   |||¬«      «       Œ% |S )Nrv   )rL   rH   rw   r¶   )ÚliteralÚcharsrL   ÚstypeÚsvalÚ	sval_typeÚcharÚcvals           r&   Ú#unpack_string_to_character_literalsrh  f  sZ   € Ø€EØ
�+‰+€CØ×Ñ€EØ�=‰=€DØ—‘€IÛˆÙ˜‹ˆØ�‰‘U˜3 dÔ+Õ,ð ð €Lr)   ÚinputÚoutputc                 óž  — | d   }|j                   st        |t        j                  «      r&t	        | d d D �cg c]  }|j                   ‘Œ c}«      s|j                  | «       y g }|j                   r|j                  }n|j                  rt        |«      }t        «      }t        |«      D �cg c]  }g ‘Œ }}g }	| d d D �]t  }|j                   s4|j                  rt        |j                  d«       |j                  |«       ŒDt        |j                  «      }
d}|j                  D ]  }|t        |j                  «      z  }Œ |dkD  r*t        |j                  d«       |j                  ||g«       Œ³|
|z
  |kD  r:t        |j                  d||dk7  xr dxs dfz  «       |j                  ||g«       Œõ|rt        ||	|j                  |«       �Œ|
|k  r0t        |j                  d	|
|fz  «       |j                  ||g«       �ŒFt!        ||j                  «      D ]  \  }}|j                  |«       Œ �Œw |r"|j                  |«       |j                  |«       t!        ||«      D ]%  \  }}|sŒ	|j                  |«       t#        ||«       Œ' |	D ]/  }|d   j                   rt#        ||«       Œ|j                  |«       Œ1 y c c}w c c}w )
NrÈ   z4starred assignment target must be in a list or tupler   r   z,more than 1 starred expression in assignmentz#need more than %d value%s to unpackÚsÚ z/too many values to unpack (expected %d, got %d))rÌ   rN   r   ÚUnicodeNoderË   r¶   ry   rd   rh  rÏ   r[  Ú
is_starredr   rL   ÚboolÚmap_starred_assignmentÚziprÍ   )ri  rj  rª   r©   Úcomplete_assignmentsÚrhs_argsÚrhs_sizerÛ   Úlhs_targetsÚstarred_assignmentsÚlhs_sizeÚstarred_targetsrc   ÚtargetsÚcascades                  r&   rÍ   rÍ   r  s–  € ð �‰)€CØ×(Ò(¬J°s¼I×<QÑ<QÔ,RÜ¸uÀSÀb¹zÓJ¹z¸˜×3Ó3¸zÑJÔKØ�‰�eÔØàÐà
×"Ò"Ø—8‘8‰Ø	×	Ò	Ü6°sÓ;ˆô #& h£-€HÜ$ XœÓ/™˜!’2˜€KÐ/ØÐà�S�bŒzˆØ×*Ò*Ø�~Š~Ü�c—g‘gÐUÔVØ ×'Ñ'¨Ô,ØÜ�s—x‘x“=ˆØˆØ—H”HˆDØœt D§O¡OÓ4Ñ4‰Oð à˜QÒÜ�#—'‘'ÐIÔJØ�M‰M˜3˜s˜)Ô$ØØ˜Ñ'¨(Ò2Ü�#—'‘'Ð@Ø ¨A¡Ò6°3Ò<¸"Ð=ñ>ô ?à�M‰M˜3˜s˜)Ô$ØÙÜ" ;Ð0CØ#&§8¡8¨Xö7à˜Ò Ü�#—'‘'ÐLØ˜xÐ(ñ)ô *à�M‰M˜3˜s˜)Ô$Ùä!$ [°#·(±(Ö!;‘�˜Ø—‘˜tÕ$ò "<ð9 ñ> Ø×#Ñ# CÔ(Ø�‰Ð*Ô+ô ˜K¨Ö2‰ˆ�ÚØ�N‰N˜3ÔÜ(¨°&Õ9ð 3ó 'ˆØ�1‰:×-Ò-Ü(¨°&Õ9à�M‰M˜'Õ"ñ	 'ùòw Kùò 0s   ¸KÂ.	K
rv  rw  Úlhs_argsrt  c                 óø  — t        t        | |«      «      D ]:  \  }\  }}|j                  r|}t        |«      |z
  dz
  } n|j	                  |«       Œ< t        d«      ‚t        t        | | d  ||dz   d  «      «      D ]  \  }\  }}|j	                  |«       Œ ||   j                  }	||d  }
|r|
d |  }
|
r|
d   j                  }n|	j                  }|j	                  |	t        j                  ||
¬«      g«       y )Nr   z6no starred arg found when splitting starred assignmentr   )rL   ry   )
rZ  rr  ro  rÏ   r¶   r   ré   rL   r   ÚListNode)rv  rw  r|  rt  r_  rz  rc   ÚstarredÚlhs_remainingré   Ústarred_rhsrL   s               r&   rq  rq  ¾  s  € ô (¬¨K¸Ó(BÖCÑˆ‰?ˆG�TØ�?Š?ØˆGÜ ›M¨AÑ-°Ñ1ˆMÙØ�‰�tÕð Dô ÐTÓUÐUô (¬¨K¸¸¸Ð,HØ,4°W¸q±[°\Ð,Bó)Dö EÑˆ‰?ˆG�Tà�‰�tÕðEð
 �gÑ×%Ñ%€FØ˜7˜8Ð$€KÙØ! / M >Ð2ˆÙØ˜!‰n× Ñ ‰à�j‰jˆØ×ÑØ”	×"Ñ" s°Ô=ð ?õ @r)   c                   ó6   ‡ — e Zd ZdZdZdZˆ fd„Zd„ Zd„ Zˆ xZ	S )ÚPxdPostParseaˆ  
    Basic interpretation/validity checking that should only be
    done on pxd trees.

    A lot of this checking currently happens in the parser; but
    what is listed below happens here.

    - "def" functions are let through only if they fill the
    getbuffer/releasebuffer slots

    - cdef functions are let through only if they are on the
    top level and are declared "inline"
    z>function definition in pxd file must be declared 'cdef inline'z5inline function definition in pxd file cannot be '%s'c                 ó0   •— d| _         t        ‰| �	  |«      S )NÚpxd)r—   rB   Ú__call__©r$   r%   rH   s     €r&   r†  zPxdPostParse.__call__÷  s   ø€ ØˆŒÜ‰wÑ Ó%Ð%r)   c                 ó\   — | j                   }d| _         | j                  |«       || _         |S ©Nr‘   )r—   r8   )r$   r%   Úolds      r&   Úvisit_CClassDefNodez PxdPostParse.visit_CClassDefNodeû  s,   € Ø�o‰oˆØ"ˆŒØ×Ñ˜4Ô ØˆŒØˆr)   c                 ó  — | j                   }t        |t        j                  «      r| j                  dk(  r|j
                  dv rd }t        |t        j                  «      rwd|j                  v r]| j                  dv rOd|_        |j                  dk7  r| j                  |j                  z  }n+|j                  r| j                  dz  }nd }n| j                   }|r0| j                  j                  t        |j                  |«      «       y |S )Nr‘   )Ú__getbuffer__Ú__releasebuffer__Úinline)r…  r‘   TÚprivateÚapi)ÚERR_INLINE_ONLYrN   r   r„   r—   rx   ÚCFuncDefNodeÚ	modifiersÚinline_in_pxdr7   ÚERR_NOGO_WITH_INLINEr‘  rG   rº   rl   rL   )r$   r%   Úerrs      r&   r  zPxdPostParse.visit_FuncDefNode  sÚ   € ð ×"Ñ"ˆä�tœUŸ]™]Ô+°·±À8Ò0KØ—I‘IÐ!GÑGØˆCä�dœE×.Ñ.Ô/Ø˜DŸN™NÑ*Ø—O‘OÐ'8Ñ8Ø%)�Ô"Ø—?‘? iÒ/Ø×3Ñ3°d·o±oÑE‘CØ—X’XØ×3Ñ3°eÑ;‘Cà‘Cà×*Ñ*�áØ�L‰L×'Ñ'¬°t·x±xÀÓ(EÔFØàˆKr)   )
r:   r;   r<   r=   r’  r–  r†  r‹  r  ri   rj   s   @r&   rƒ  rƒ  æ  s%   ø„ ñð W€OØRÐô&òör)   rƒ  c                   óB   ‡ — e Zd Zˆ fd„Zd„ Zd„ Zej                  Zˆ xZ	S )ÚTrackNumpyAttributesc                 ó@   •— t         ‰| �  «        t        «       | _        y r!   )rB   rC   r)  Únumpy_module_namesr  s    €r&   rC   zTrackNumpyAttributes.__init__!  s   ø€ Ü‰ÑÔÜ"%£%ˆÕr)   c                 óv   — |j                   dk(  r)| j                  j                  |j                  xs d«       |S )NÚnumpy)Úmodule_namer›  rF  Úas_namer#   s     r&   Úvisit_CImportStatNodez*TrackNumpyAttributes.visit_CImportStatNode%  s2   € Ø×Ñ˜wÒ&Ø×#Ñ#×'Ñ'¨¯©Ò(?¸Ô@Øˆr)   c                 ó®   — | j                  |«       |j                  }|j                  r|j                  | j                  v s|j
                  rd|_        |S rS   )r8   Úobjr  rx   r›  Úis_numpy_attribute)r$   r%   r¢  s      r&   Úvisit_AttributeNodez(TrackNumpyAttributes.visit_AttributeNode*  sF   € Ø×Ñ˜4Ô Ø�h‰hˆØ�KŠK˜CŸH™H¨×(?Ñ(?Ñ?ÀC×DZÒDZØ&*ˆDÔ#Øˆr)   )
r:   r;   r<   rC   r   r¤  r   Úrecurse_to_childrenr  ri   rj   s   @r&   r™  r™    s   ø„ ô(òò
ð "×5Ñ5„Jr)   r™  c            
       ó*  ‡ — e Zd ZdZej
                  ej                  ej                   ej                  dd«       ej                  dd«       ej                  dd«       ej                  dd«      ej                  ej                  dœ	Z
d ej                  d«      iZh d	£Zej                  e
«       h d
£Zh d£Zˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z!d„ Z"d„ Z#d„ Z$d „ Z%d!„ Z&d"„ Z'd#„ Z(d$„ Z)d%„ Z*d&„ Z+d'„ Z,ˆ xZ-S )(ÚInterpretCompilerDirectivesa+  
    After parsing, directives can be stored in a number of places:
    - #cython-comments at the top of the file (stored in ModuleNode)
    - Command-line arguments overriding these
    - @cython.directivename decorators
    - with cython.directivename: statements
    - replaces "cython.compiled" with BoolNode(value=True)
      allowing unreachable blocks to be removed at a fairly early stage
      before cython typing rules are forced on applied

    This transform is responsible for interpreting these various sources
    and store the directive in two ways:
    - Set the directives attribute of the ModuleNode for global directives.
    - Use a CompilerDirectivesNode to override directives for a subtree.

    (The first one is primarily to not have to modify with the tree
    structure, so that ModuleNode stay on top.)

    The directives are stored in dictionaries from name to value in effect.
    Each such dictionary is always filled in for all possible directives,
    using default values where no value is given by the user.

    The available directives are controlled in Options.py.

    Note that we have to run this prior to analysis, and so some minor
    duplication of functionality has to occur: We manually track cimports
    and which names the "cython" module may have been imported to.
    Tz++z--F)	Útypeofzoperator.addresszoperator.dereferencezoperator.preincrementzoperator.predecrementzoperator.postincrementzoperator.postdecrementzoperator.typeidÚaddresszoperator.commaÚ,>   ÚNULLÚcastÚunionÚsizeofr¦   ÚdeclareÚpointerÚtypedefÚcompiledÚparallelÚ
fused_type>   ÚviewÚcimportsÚoperatorr³  Údataclasses>   Úpranger³  Úthreadidc                 ó0  •— t         ‰| �  |«       t        «       | _        ddi| _        i | _        t        j                  t        j                  «       «      }|j                  «       D ]&  \  }}t        j                  |«      |t        |«      <   Œ( || _        y )NÚstaticmethod)rB   rC   r)  Úcython_module_namesÚdirective_namesÚparallel_directivesr   Údeepcopyr   Úget_directive_defaultsr\  ÚstrÚ
directives)r$   rG   Úcompilation_directive_defaultsrÃ  r]  rw   rH   s         €r&   rC   z$InterpretCompilerDirectives.__init__z  s|   ø€ Ü‰Ñ˜Ô!Ü#&£5ˆÔ Ø .°Ð?ˆÔØ#%ˆÔ Ü—]‘]¤7×#AÑ#AÓ#CÓDˆ
Ø8×>Ñ>Ö@‰JˆC�Ü#'§=¡=°Ó#7ˆJ”s˜3“xÒ ð Aà$ˆ�r)   c           
      óî   — t         j                  j                  |d «      }|r1||vr-| j                  j	                  t        |d|›d|›d�«      «       y|t         j                  vrt        |d|›d�«       y)NzThe z& compiler directive is not allowed in z scopeFzInvalid directive: 'z'.T)r   Údirective_scopesr³   rG   rº   rl   Údirective_typesr   )r$   rL   Ú	directiveÚscopeÚlegal_scopess        r&   Úcheck_directive_scopez1InterpretCompilerDirectives.check_directive_scope„  sn   € Ü×/Ñ/×3Ñ3°I¸tÓDˆÙ˜E¨Ñ5Ø�L‰L×'Ñ'¬±sÚHQÒSXð=Zó )[ô \àà¤× 7Ñ 7Ñ7Ü‘cºÐDÔEØr)   c                 óÔ  — |j                  d«      sy |j                  dd«      d   }|| j                  v ry d}dj                  «       d d D �cg c]  }|j                  «       ‘Œ }}|D ]   \  }}|j                  d|z   «      sŒd|z  } n |s>|t        j
                  v }	|	s#|j                  d	«      sdd
lm}
 t        |
|«      }	|	rd|z  }t        |d|›d|rdnd›|›�«       y c c}w )Núcython.Ú.rÇ   r   rm  zõ                imp                  cimports
                cimp                 cimports
                para                 parallel
                parra                parallel
                dataclass            dataclasses
            rÈ   zDid you mean 'cython.%s' ?rÛ   )ÚShadowz2Instead, use 'import cython' and then 'cython.%s'.r
  z ' is not a valid cython.* modulez. )
Ú
startswithÚsplitÚvalid_cython_submodulesÚ
splitlinesr   rÇ  rm  rÏ  Úhasattrr   )r$   rL   rž  Ú	submoduleÚextraÚlineÚhintsÚwrongÚcorrectÚis_simple_cython_namerÏ  s              r&   Ú_check_valid_cython_modulez6InterpretCompilerDirectives._check_valid_cython_module�  s  € Ø×%Ñ% iÔ0ØØ×%Ñ% c¨1Ó-¨aÑ0ˆ	Ø˜×4Ñ4Ñ4Øàˆð&÷ ‘
“˜S˜bñ&"ó
ñ&"˜TˆD�J‰J�Lð &"ð 	ð 
ó $‰NˆE�7Ø×%Ñ% i°%Ñ&7Õ8Ø4°wÑ>�Ùð $ñ Ø$-´×1HÑ1HÐ$HÐ!Ù(°×1EÑ1EÀcÔ1Jõ &Ü(/°¸	Ó(BÐ%Ù$ØLÈyÑX�ä‰cÚÙ‰D˜rÐ!Ùð
õ 	ùò/
s   ÁC%c                 ó¾  — t        |j                  «      D ]J  }| j                  |j                  |d«      rŒ!| j	                  |j                  |d«       |j                  |= ŒL |j
                  | _        | j                  j                  |j                  «       | j                  |_        | j                  |_	        | j                  |«       | j                  |_        |S )Nr§   )ÚsortedÚdirective_commentsrË  rL   Úwrong_scope_errorrÉ  Úmodule_scoperÃ  r,  r¿  r8   r½  )r$   r%   r]  s      r&   rQ   z,InterpretCompilerDirectives.visit_ModuleNode¶  s±   € Ü˜$×1Ñ1Ö2ˆCØ×-Ñ-¨d¯h©h¸¸XÕFØ×&Ñ& t§x¡x°°hÔ?Ø×+Ñ+¨CÑ0ð 3ð
 !ŸJ™JˆÔà�‰×Ñ˜t×6Ñ6Ô7ØŸ/™/ˆŒØ#'×#;Ñ#;ˆÔ Ø×Ñ˜4Ô Ø#'×#;Ñ#;ˆÔ Øˆr)   c                 ór   — | j                   |j                   c}| _         | j                  |«       || _         |S r!   ©rÃ  r8   ©r$   r%   Úold_directivess      r&   Úvisit_CompilerDirectivesNodez8InterpretCompilerDirectives.visit_CompilerDirectivesNodeÅ  s2   € Ø*.¯/©/¸4¿?¹?Ð'ˆ˜œØ×Ñ˜4Ô Ø(ˆŒØˆr)   c                 ót   — |t         j                  v xs% || j                  v xs t        j                  |«      S r!   )r   rÇ  Úspecial_methodsr   Úparse_basic_type)r$   rx   s     r&   Úis_cython_directivez/InterpretCompilerDirectives.is_cython_directiveÍ  s;   € Øœ×/Ñ/Ð/ò 2Ø˜×,Ñ,Ð,ò2ä×+Ñ+¨DÓ1ð	3r)   c                 ó0  — |dz   j                  d«      }|r|j                  d«      }|dk(  rd| j                  d<   |S |dk(  r%| j                  D ]  }d|z  | j                  |<   Œ |S t	        |«      dk7  s|d   | j                  vrt        |d	|z  «       |S )
z¸
        Checks to see if fullname (e.g. cython.parallel.prange) is a valid
        parallel directive. If it is a star import it also updates the
        parallel_directives.
        rÎ  úcython.parallel.úcython.parallelr³  zcython.parallel.*zcython.parallel.%sé   rÈ   zNo such directive: %s)rÐ  rÑ  r¿  Úvalid_parallel_directivesrÏ   r   )r$   Ú	full_namerL   rà   rÈ  rx   s         r&   Úis_parallel_directivez1InterpretCompilerDirectives.is_parallel_directiveÒ  s¶   € ð ˜c‘/×-Ñ-Ð.@ÓAˆáØ!Ÿ™¨Ó,ˆIØÐ-Ò-Ø7H�×(Ñ(¨Ñ4ð ˆð Ð1Ò1Ø ×:Ô:�DØ5IÈDÑ5P�D×,Ñ,¨TÒ2ð ;ð ˆô	 �i“. AÒ%Ø˜B‘- t×'EÑ'EÑEÜ�cÐ2°YÑ>Ô?àˆr)   c                 óz  — |j                   }|dk(  rt        |j                  d«       |j                  d«      rF|j                  r$|j                  dk7  r|t        d«      d  |_         |S t        |j                  d«       |dk(  r+| j                  j                  |j                  xs d«       |S |j                  d«      rû|j                  d«      r$t        |j                  |j                   dz   «       n| j                  |j                  |«       |d	k(  r`|j                  r)|j                  dk7  r|| j                  |j                  <   y | j                  j                  d«       || j                  d	<   y |j                  r|d
d  | j                  |j                  <   y | j                  j                  d«       y |S )Núcython.cimportszGCannot cimport the 'cython.cimports' package directly, only submodules.úcython.cimports.ÚcythonzkPython cimports must use 'from cython.cimports... import ...' or 'import ... as ...', not just 'import ...'rÍ  rì  z is not a modulerí  é   )rž  r   rL   rÐ  rŸ  rÏ   r½  rF  rÜ  r¿  r¾  ©r$   r%   rž  s      r&   r   z1InterpretCompilerDirectives.visit_CImportStatNodeç  sž  € Ø×&Ñ&ˆØÐ+Ò+Ü�$—(‘(ÐeÔfØ×!Ñ!Ð"4Ô5Ø�|Š| §¡°Ò 8Ø#.¬sÐ3EÓ/FÐ/GÐ#H�Ô Ø�Ü�$—(‘(ðCôDð ˜(Ò"Ø×$Ñ$×(Ñ(¨¯©Ò)A¸ÔBð* ˆð) ×#Ñ# IÔ.Ø×%Ñ%Ð&8Ô9Ü�d—h‘h × 0Ñ 0Ð3EÑ EÕFà×/Ñ/°·±¸+ÔFàÐ/Ò/Ø—<’< D§L¡L°HÒ$<Ø=H�D×,Ñ,¨T¯\©\Ñ:ð ð ×,Ñ,×0Ñ0°Ô:à9Dð ×,Ñ,Ø$5ñ7ð ð —’Ø5@ÀÀ°_�×$Ñ$ T§\¡\Ñ2ð
 ð ×(Ñ(×,Ñ,¨XÔ6ð Øˆr)   c                 óº  — |j                   }|dk(  s|j                  d«      r2| j                  |j                  ||j                  |j
                  «      S |j                  sú|dk(  s|j                  d«      rä| j                  |j                  |«       |dz   dd  }g }|j
                  D ]¥  \  }}}||z   }d|z   }	| j                  |	|j                  «      r|	| j                  |xs |<   ŒA| j                  |«      r|| j                  |xs |<   Œf|dv r(|| j                  |xs |<   |j                  |||f«       Œ’|j                  |||f«       Œ§ |sy ||_        |S )Nró  rô  rõ  rÍ  rÎ  rö  )r¸  Útyping)rž  rÐ  Ú_create_cimport_from_importrL   Úrelative_levelÚimported_namesrÜ  rñ  r¿  rê  r¾  r¶   )
r$   r%   rž  rÕ  ÚnewimprL   rx   rŸ  rð  Úqualified_names
             r&   Úvisit_FromCImportStatNodez5InterpretCompilerDirectives.visit_FromCImportStatNode  sk  € Ø×&Ñ&ˆØÐ+Ò+¨{×/EÑ/EÐFXÔ/Yà×3Ñ3Ø—‘˜+ t×':Ñ':¸D×<OÑ<OóQð Qà×$Ò$Ø˜xÒ'¨;×+AÑ+AÀ)Ô+LØ×+Ñ+¨D¯H©H°kÔBØ$ sÑ*¨A¨BÐ/ˆIØˆFØ&*×&9Ô&9Ñ"��T˜7Ø%¨Ñ,�	Ø!*¨YÑ!6�Ø×-Ñ-¨n¸d¿h¹hÔGð AO�D×,Ñ,¨Wª_¸Ò=Ø×-Ñ-¨iÔ8Ø<E�D×(Ñ(¨ª°DÒ9ØÐ";Ñ;Ø<E�D×(Ñ(¨ª°DÑ9à—M‘M 3¨¨gÐ"6Õ7à—M‘M 3¨¨gÐ"6Õ7ð ':ñ  Øà"(ˆDÔØˆr)   c                 ó(  — |j                   }|j                  j                  }|dk(  s|j                  d«      rwg }|j                  D ]>  \  }}|j                  |j                  |||j                  k(  rd n|j                  f«       Œ@ | j                  |j                  ||j                  |«      S |dk(  s|j                  d«      rÌ| j                  |j                  j                  |«       |dz   dd  }g }|j                  D ]ƒ  \  }}||z   }	d|	z   }
| j                  |
|j                  «      r|
| j                  |j                  <   ŒF| j                  |	«      r|	| j                  |j                  <   Œq|j                  ||f«       Œ… |sy ||_        |S )Nró  rô  rõ  rÍ  rÎ  rö  )r§   rž  rw   rÐ  r\  r¶   rL   rx   rú  ÚlevelrÜ  rñ  r¿  rê  r¾  )r$   r%   Úimport_noderž  rü  rx   Ú	name_noderÕ  rý  rð  rþ  s              r&   Úvisit_FromImportStatNodez4InterpretCompilerDirectives.visit_FromImportStatNode,  s~  € Ø—k‘kˆØ!×-Ñ-×3Ñ3ˆØÐ+Ò+¨{×/EÑ/EÐFXÔ/YØˆNØ#'§:¤:‘��iØ×%Ñ%Ø—]‘] D°$¸)¿.¹.Ò2H©$ÈiÏnÉnÐ]õ_ð $.ð ×3Ñ3Ø—‘˜+ {×'8Ñ'8¸.óJð Jà˜HÒ$¨×(>Ñ(>¸yÔ(IØ×+Ñ+¨K×,CÑ,C×,GÑ,GÈÔUØ$ sÑ*¨A¨BÐ/ˆIØˆFØ#'§:¤:‘��iØ%¨Ñ,�	Ø!*¨YÑ!6�Ø×-Ñ-¨n¸d¿h¹hÔGØ?M�D×,Ñ,¨Y¯^©^Ò<Ø×-Ñ-¨iÔ8Ø;D�D×(Ñ(¨¯©Ò8à—M‘M 4¨Ð"3Õ4ð $.ñ ØØˆDŒJØˆr)   c                 ó  — |dk(  s|j                  d«      rt        |t        d«      d  «      }|rt        j                  ||||¬«      S |D ���cg c]"  \  }}}t        j
                  ||||dk(  ¬«      ‘Œ$ c}}}S c c}}}w )Nró  rô  )rž  rû  rü  r   )rž  rŸ  Úis_absolute)rÐ  r   rÏ   r   ÚFromCImportStatNodeÚCImportStatNode)r$   Únode_posrž  r  rü  rL   Údotted_namerŸ  s           r&   rú  z7InterpretCompilerDirectives._create_cimport_from_importH  s¢   € ØÐ+Ò+¨{×/EÑ/EÐFXÔ/YÜ'¨´CÐ8JÓ4KÐ4LÐ(MÓNˆKáä×,Ñ,Ø kØ$Ø-ô/ð /ñ 2@õñ 2@Ñ-�C˜ gô ×%Ñ%ØØ +Ø#Ø %¨¡
ö	,ð
 2@óð ùô s   Á'A;c                 ór  — t        |j                  t        j                  «      r�|j                  j                  j
                  }|dk7  r|j                  d«      s|S t        j                  |j                  ||j                  j                  ¬«      }| j                  |«      }|S | j                  |«       |S )Nrõ  rÍ  )rž  rŸ  )rN   rª   r   Ú
ImportNoderž  rw   rÐ  r   r  rL   r©   rx   r   r8   r÷  s      r&   rÂ   z6InterpretCompilerDirectives.visit_SingleAssignmentNode]  s–   € Ü�d—h‘h¤	× 4Ñ 4Ô5ØŸ(™(×.Ñ.×4Ñ4ˆKØ˜hÒ&¨{×/EÑ/EÀiÔ/PØ�ä×(Ñ(¨¯©¸{ÐTX×T\ÑT\×TaÑTaÔbˆDØ×-Ñ-¨dÓ3ˆDð ˆð ×Ñ˜tÔ$àˆr)   c                 óF  — |j                   r| j                  |d«       |j                  | j                  v rd|_        n.| j
                  j                  |j                  «      }|�||_        |j                  «       dk(  r!t        j                  |j                  d¬«      S |S )NÚ
annotationTr²  rv   )r  Ú
visitchildrx   r½  Úis_cython_moduler¾  r³   Úcython_attributeÚas_cython_attributer   ÚBoolNoderL   )r$   r%   rÈ  s      r&   Úvisit_NameNodez*InterpretCompilerDirectives.visit_NameNodej  s†   € Ø�?Š?Ø�O‰O˜D ,Ô/Ø�9‰9˜×0Ñ0Ñ0Ø$(ˆDÕ!à×,Ñ,×0Ñ0°·±Ó;ˆIØÐ$Ø(1�Ô%Ø×#Ñ#Ó%¨Ò3Ü×%Ñ% d§h¡h°dÔ;Ð;àˆr)   c                 ó�   — | j                  |«       |j                  «       dk(  r!t        j                  |j                  d¬«      S |S )Nr²  Trv   )r8   r  r   r  rL   r#   s     r&   r¤  z/InterpretCompilerDirectives.visit_AttributeNodex  s=   € Ø×Ñ˜4Ô Ø×#Ñ#Ó%¨Ò3Ü×%Ñ% d§h¡h°dÔ;Ð;àˆr)   c                 óT   — |j                   r| j                  |j                   «       |S r!   )rc   r$  r#   s     r&   Úvisit_AnnotationNodez0InterpretCompilerDirectives.visit_AnnotationNode  s    € ð �9Š9Ø�J‰J�t—y‘yÔ!Øˆr)   c                 óL   — | j                  |d«       | j                  |«       |S ©NÚcppclass)r  r8   r#   s     r&   Úvisit_NewExprNodez-InterpretCompilerDirectives.visit_NewExprNode†  s#   € Ø�‰˜˜jÔ)Ø×Ñ˜4Ô Øˆr)   c           	      ó’  — t        |t        j                  «      �rE| j                  |d«       |j                  j                  «       }|�rt        j                  j                  |«      }|rô|j                  «       \  }}g }g }|�¢|t        urš|j                  D ]w  }|\  }	}
|›d|	j                  ›�}t        j                  j                  |«      r/|j                  | j                  ||
gd |j                  «      «       Œg|j                  |«       Œy |sd }n||_        |r|s|s|S |j                  | j                  ||||j                  j                  «      «       |S y t        |t        j                   t        j"                  f«      r½| j%                  |«       |j                  «       }|ršt        j                  j                  |«      }|t&        u rAt        j(                  |j                  d¬«      }| j                  ||gd |j                  «      gS |�|t        j*                  u r|d fgS t-        |j                  d|z  «      ‚y )NÚfunctionrÎ  Trv   z5The '%s' directive should be used as a function call.)rN   r   ÚCallNoder  r  r  r   rÇ  r³   Úexplicit_args_kwdsÚdictÚkey_value_pairsrw   r¶   Útry_to_parse_directiverL   ÚAttributeNoder¸   r$  rp  r  ÚDEFER_ANALYSIS_OF_ARGUMENTSrl   )r$   r%   ÚoptnameÚdirectivetypery   ÚkwdsrÃ  r!  Úkeyvaluer]  rw   Úsub_optnamerá   s                r&   Útry_to_parse_directivesz3InterpretCompilerDirectives.try_to_parse_directives‹  s  € ô �dœI×.Ñ.Õ/Ø�O‰O˜D *Ô-Ø—m‘m×7Ñ7Ó9ˆGÚÜ '× 7Ñ 7× ;Ñ ;¸GÓ D�Ù Ø!%×!8Ñ!8Ó!:‘J�D˜$Ø!#�JØ&(�OØÐ'¨MÄÑ,EØ(,×(<Ô(<˜HØ)1™J˜C Ú5<¸c¿iºiÐ*H˜KÜ&×6Ñ6×:Ñ:¸;ÔGØ *× 1Ñ 1°$×2MÑ2MÈkÐ\aÐ[bÐdhÐjr×jvÑjvÓ2wÕ xà /× 6Ñ 6°xÕ @ð )=ñ  /Ø#'™Dà3B˜DÔ0Ù%©d¹4Ø#-Ð-Ø×%Ñ% d×&AÑ&AÀ'È4ÐQUÐW[×WdÑWd×WhÑWhÓ&iÔjØ%Ð%ð ô ˜œy×6Ñ6¼	×8JÑ8JÐKÔLØ�J‰J�tÔØ×.Ñ.Ó0ˆGÙÜ '× 7Ñ 7× ;Ñ ;¸GÓ D�Ø ¤DÑ(Ü#×,Ñ,¨T¯X©X¸TÔB�CØ ×7Ñ7¸À#ÀÈÈdÏhÉhÓWÐXÐXØ"Ð*¨m¼w×?bÑ?bÑ.bØ$ d˜OÐ,Ð,ä(ØŸ™Ð"YÐ\cÑ"cóeð eàr)   c                 ó’  — |dk(  r%| j                   j                  st        |d|z  «      ‚|dk(  rÏt        |«      dkD  }d}|rŸ|j                  r“|j                  d   }t        |j                  «      dk(  rj|j
                  j                  rT|j
                  j                  dk(  r;t        |j                  t        j                  «      r|j                  j                  }nd}|rt        |d«      ‚d|r|d   |ffS d |ffS t        j                  j                  |«      }t        |«      dk(  r6t        |d   t        j                  «      r|t        j                  «       |   fS |t         u rM|€+t        |«      dk7  st        |d   t        j                  «      st        |d	|z  «      ‚||d   j                  fS |t"        u rV|€+t        |«      dk7  st        |d   t        j$                  «      st        |d
|z  «      ‚|t#        |d   j                  «      fS |t&        u rV|€+t        |«      dk7  st        |d   t        j(                  «      st        |d|z  «      ‚|t'        |d   j                  «      fS |t*        u r&|€t        |«      dk7  rt        |d|z  «      ‚||d   fS |t,        u r/t        |«      dk7  rt        |d|z  «      ‚||j/                  «       fS |t0        u rN|r't        |j                  «      dk7  rt        |d|z  «      ‚||D �	cg c]  }	t'        |	j                  «      ‘Œ c}	fS t3        |«      r]|€+t        |«      dk7  st        |d   t        j(                  «      st        |d|z  «      ‚| ||t'        |d   j                  «      «      fS |t        j4                  u r|||r|j/                  «       ffS i ffS J ‚c c}	w )NÚ
np_pythranz.The %s directive can only be used in C++ mode.Ú	exceptvalr   Tr   ÚcheckzYThe exceptval directive takes 0 or 1 positional arguments and the boolean keyword "check"ú8The %s directive takes one compile-time boolean argumentz8The %s directive takes one compile-time integer argumentz7The %s directive takes one compile-time string argumentz(The %s directive takes one type argumentz1The %s directive takes no prepositional argumentsz+The %s directive takes no keyword arguments)rG   Úcpprl   rÏ   r!  r]  rd   rw   rN   r   r  r   rÇ  r³   ÚNoneNoderÁ  rp  ÚintÚIntNoderÂ  rn  Útyper   Úas_python_dictrN  Úcallabler$  )
r$   r%  ry   r'  rL   Ú	arg_errorr.  Úkwr&  rá   s
             r&   r"  z2InterpretCompilerDirectives.try_to_parse_directive·  sÈ  € Ø�lÒ"¨4¯<©<×+;Ò+;Ü  Ð&VÐY`Ñ&`ÓaÐaØ˜Ò#ä˜D›	 A™ˆIØˆEÙ˜×,Ò,Ø×)Ñ)¨!Ñ,�Ü˜×,Ñ,Ó-°Ò2ØŸ™×0Ò0°R·V±V·\±\ÀWÒ5LÜ" 2§8¡8¬Y×-?Ñ-?Ô@ØŸH™HŸN™N‘Eà $�IÙÜ$ØÐtóvð và©T $ q¡'¸UÐ!CÐDÐD°t¸UÐ!CÐDÐDä×/Ñ/×3Ñ3°GÓ<ˆÜˆt‹9˜Š>œj¨¨a©´)×2DÑ2DÔEØœG×:Ñ:Ó<¸WÑEÐEÐEØœdÑ"ØÐ¤3 t£9°¢>¼ÀDÈÁGÌY×M_ÑM_Ô9`Ü$ SØNÐQXÑXóZð Zà˜T !™WŸ]™]Ð+Ð+ØœcÑ!ØÐ¤3 t£9°¢>¼ÀDÈÁGÌY×M^ÑM^Ô9_Ü$ SØNÐQXÑXóZð ZàœS  a¡§¡Ó/Ð0Ð0ØœcÑ!ØÐ¤3 t£9°¢>¼ÀDÈÁGÌY×MbÑMbÔ9cÜ$ SØMÐPWÑWóYð YàœS  a¡§¡Ó/Ð0Ð0ØœdÑ"ØÐ¤3 t£9°¢>Ü$ SØ>ÀÑHóJð Jà˜T !™WÐ%Ð%ØœdÑ"Ü�4‹y˜AŠ~Ü$ SØGÈ'ÑQóSð Sà˜D×/Ñ/Ó1Ð1Ð1ØœdÑ"Ùœ˜D×0Ñ0Ó1°QÒ6Ü$ SØAÀGÑKóMð Mà¹Ó>¹°œc #§)¡)�n¸Ñ>Ð>Ð>Ü�mÔ$ØÐ¤3 t£9°¢>¼ÀDÈÁGÌY×MbÑMbÔ9cÜ$ SØMÐPWÑWóYð Yà™]¨7´C¸¸Q¹¿¹Ó4FÓGÐHÐHØœg×AÑAÑAà˜d¹T D×$7Ñ$7Ó$9ÐJÐKÐKÀrÐJÐKÐKà�5ùò ?s   ÌOc                 ó@  — |s|rJ ‚| j                  |«      S | j                  }t        j                  |fi |¤Ž}|�t        j                  |fi |¤Ž}n|}||k(  r| j                  |«      S || _        |�j||k7  ret	        j
                  |j                  j                  t	        j                  |j                  j                  ||j                  ¬«      g¬«      |_        | j                  |«      }|| _        t        |t        j                  «      r'|j                  |j                  «       |j                  }t        |t        j
                  «      s"t	        j
                  |j                  |g¬«      }t	        j                  |j                  |||j                  ¬«      S )N)rÃ  rO   rÊ   )rO   rÃ  Úis_terminator)r  rÃ  r   Úcopy_inherited_directivesr   rP   rO   rL   ÚCompilerDirectivesNoderN   r,  r:  )r$   r%   rÃ  Úcontents_directivesrå  Únew_directivesÚnew_contents_directivesÚretbodys           r&   Úvisit_with_directivesz1InterpretCompilerDirectives.visit_with_directives÷  sk  € áÙ*Ð*Ð*Ø—?‘? 4Ó(Ð(àŸ™ˆÜ ×:Ñ:¸>ÑXÈZÑXˆØÐ*Ü&-×&GÑ&GØñ'7Ø"5ñ'7Ñ#ð '5Ð#à˜^Ò+Ø—?‘? 4Ó(Ð(à(ˆŒØÐ+Ø'¨>Ò9ä×*Ñ*Ø—	‘	—‘ä×0Ñ0ØŸ	™	Ÿ™Ø#:Ø!ŸY™Yô(ðôˆDŒIð —/‘/ $Ó'ˆØ(ˆŒä�gœu×;Ñ;Ô<Ø×!Ñ! '×"4Ñ"4Ô5Ø—l‘lˆGÜ˜'¤5×#5Ñ#5Ô6Ü×(Ñ(¨¯©¸'¸ÔCˆGÜ×+Ñ+Ø�K‰K˜g°.ÐPW×PeÑPeôgð 	gr)   c                 óR   — | j                  |d«      \  }}| j                  |||«      S )Nr  ©Ú_extract_directivesrA  ©r$   r%   rÃ  r=  s       r&   r  z-InterpretCompilerDirectives.visit_FuncDefNode!  ó0   € Ø*.×*BÑ*BÀ4ÈÓ*TÑ'ˆ
Ð'Ø×)Ñ)¨$°
Ð<OÓPÐPr)   c                 ó  — | j                  |d«      \  }}|j                  «       D ]I  \  }}|dk(  r||_        Œ|dvsŒ| j                  j	                  t        |j                  d|z  «      «       ŒK | j                  ||d ¬«      S )Nr  Úlocals)Úfinalr¼  zXCdef functions can only take cython.locals(), staticmethod, or final decorators, got %s.©r=  )rD  r\  Údirective_localsrG   rº   rl   rL   rA  )r$   r%   rÃ  rÛ   rx   rw   s         r&   r+   z-InterpretCompilerDirectives.visit_CVarDefNode%  s”   € Ø×0Ñ0°°zÓB‰ˆ
�AØ%×+Ñ+Ö-‰KˆD�%Ø�xÒØ(-�Õ%ØÐ6Ò6Ø—‘×+Ñ+¬NØ—H‘HðAØCGñHó-Iõ Jð	 .ð ×)Ñ)¨$°
ÐPTÐ)ÓUÐUr)   c                 óR   — | j                  |d«      \  }}| j                  |||«      S r‰  rC  rE  s       r&   r‹  z/InterpretCompilerDirectives.visit_CClassDefNode1  s0   € Ø*.×*BÑ*BÀ4ÈÓ*RÑ'ˆ
Ð'Ø×)Ñ)¨$°
Ð<OÓPÐPr)   c                 óR   — | j                  |d«      \  }}| j                  |||«      S r  rC  rE  s       r&   r9   z.InterpretCompilerDirectives.visit_CppClassNode5  rF  r)   c                 óR   — | j                  |d«      \  }}| j                  |||«      S )NÚclassrC  rE  s       r&   Úvisit_PyClassDefNodez0InterpretCompilerDirectives.visit_PyClassDefNode9  s0   € Ø*.×*BÑ*BÀ4ÈÓ*QÑ'ˆ
Ð'Ø×)Ñ)¨$°
Ð<OÓPÐPr)   c           	      óÔ  — |j                   si i fS g }g }g }t        | j                  «      }t        «       }|j                   ddd…   D �]c  }| j	                  |j
                  «      }	|	��1|	D �])  }
| j                  |j                  |
d   |«      ró|
\  }}|dv rc|€d}nZ|\  }}|s+t        |«      dk7  st        |d   t        j                  «      st        |j                  d|z  «      ‚|d   j                  }||f}
|j                  ||«      |k7  r6|dk(  rd	|v rt        |j                  d
«       |j!                  |
«       |||<   n#t#        |j                  d|›|�d|z  nd›d�«       |
d   dk(  r|j!                  |«       |
d   dk(  s�Œ!|dk(  s�Œ(d}�Œ, �ŒS|j!                  |«       �Œf |ddd…   |ddd…   z   |_         i }i }|D ]˜  \  }}||v rr||   }t        |t        «      r|j%                  |«       nPt        |t&        «      r|j)                  |«       n.|dk(  r|||   k7  rt        |j                  d«       |||<   n|||<   |t*        j,                  vsŒ”|||<   Œš ||fS )zß
        Returns two dicts - directives applied to this function/class
        and directives applied to its contents. They aren't always the
        same (since e.g. cfunc should not be applied to inner functions)
        NrÈ   r   )ÚnogilÚwith_gilTr   r/  ÚcfuncÚufuncz=Cannot apply @cfunc to @ufunc, please reverse the decorators.z*Directive does not change previous value (z=%rrm  Ú)r¼  r‘   rO  Úcollection_typez4Multiple values of collection_type are not supported)Ú
decoratorsr   rÃ  Úobjectr*  Ú	decoratorrË  rL   rÏ   rN   r   r  rl   rw   r³   r   r¶   r   r,  rN  r  r   Úimmediate_decorator_directives)r$   r%   Ú
scope_namerÃ  ÚrealdecsÚbothÚcurrent_opt_dictÚmissingÚdecr>  rÈ  rx   rw   ry   r'  ÚoptdictÚcontents_optdictÚ	old_values                     r&   rD  z/InterpretCompilerDirectives._extract_directives=  s˜  € ð �ŠØ�r�6ˆMàˆ
ØˆØˆÜ §¡Ó0ÐÜ“(ˆà—?‘?¡4 R 4Õ(ˆCØ!×9Ñ9¸#¿-¹-ÓHˆNØÑ)Ü!/�IØ×1Ñ1°$·(±(¸IÀa¹LÈ*ÔUØ&/™˜˜eØÐ#8Ñ8Ø$˜}Ø(,¡à-2¡
  dÙ#'¬3¨t«9¸ª>ÄÈDÐQRÉGÔU^×UgÑUgÔAhÜ*8¸¿¹ÐB|ð  @Dñ  CDó  +Eð  %EØ(,¨Q©¯© Ø)-¨u¨˜IØ+×/Ñ/°°gÓ>À%ÒGØ# wš°7Ð>NÑ3NÜ % c§g¡gÐ/nÔ oØ&×-Ñ-¨iÔ8Ø5:Ð,¨TÒ2ä# C§G¢GÙ $°uÐ7H e¨e¢mÈbÑ&Pð.Rô Sà$ Q™<¨>Ò9Ø ŸK™K¨Ô,à  ‘| xÔ/°JÀ'Ô4IØ%-š
ò1 "0ð4 —‘ Ö$ð; )ð< #¡4 R 4™.¨4±°"°©:Ñ5ˆŒàˆØÐÛ%‰KˆD�%Ø�w‰Ø# D™M�	ô ˜i¬Ô.Ø×$Ñ$ UÕ+Ü 	¬4Ô0Ø×$Ñ$ UÕ+àÐ0Ò0°U¸gÀd¹mÒ5KÜ˜dŸh™hÐ(^Ô_Ø$)�G˜D’Mà %�˜‘Øœ7×AÑAÒAØ).Ð  Ò&ð! &ð" Ð(Ð(Ð(r)   c                 óì  — i }| j                  |j                  «      xs g D ]   }|€Œ|j                  �0| j                  j	                  t        |j                  d«      «       ŒB|\  }}|dv r| j                  ||«      c S |dk(  r|\  }}| j                  |||«      c S | j                  |j                  |d«      sŒœ|||<   Œ¢ |r| j                  |j                  |d ¬«      S | j                  |«      S )Nz6Compiler directive with statements cannot contain 'as')rR  ÚgilÚcritical_sectionzwith statementrJ  )r*  Úmanagerré   rG   rº   rl   rL   Ú_transform_with_gilÚ_transform_critical_sectionrË  rA  rO   r  )r$   r%   Údirective_dictrÈ  rx   rw   ry   r'  s           r&   Úvisit_WithStatNodez.InterpretCompilerDirectives.visit_WithStatNode‚  sÿ   € ØˆØ×5Ñ5°d·l±lÓCÒIÀrÒIˆIØÐ ØØ�{‰{Ð&Ø—‘×+Ñ+Ü" 4§8¡8Ð-eÓfôhàØ#‰KˆD�%ØÐ'Ñ'à×/Ñ/°°dÓ;Ò;ØÐ+Ò+Ø"‘
��dØ×7Ñ7¸¸dÀDÓIÒIØ×+Ñ+¨D¯H©H°dÐ<LÕMØ',�˜tÒ$ð Jñ  Ø×-Ñ-¨d¯i©i¸Ð]aÐ-ÓbÐbØ�‰˜tÓ$Ð$r)   c                 ó>  — |dv sJ ‚|j                   }d }t        |t        j                  «      rf|j                  rZt        |j                  «      dkD  r2| j                  j                  t        |j                  d|z  «      «       |j                  d   }nLt        |t        j                  «      r2| j                  j                  t        |j                  d|z  «      «       t        j                  |j                  ||j                  |¬«      }| j                  |«      S )N)rf  rR  r   z6Compiler directive %s accepts one positional argument.r   )ÚstaterO   Ú	condition)rh  rN   r   ÚSimpleCallNodery   rÏ   rG   rº   rl   rL   ÚGeneralCallNoder   ÚGILStatNoderO   r  )r$   r%   rn  rh  ro  s        r&   ri  z/InterpretCompilerDirectives._transform_with_gil˜  sá   € ØÐ(Ñ(Ð(Ð(Ø—,‘,ˆØˆ	Ü�gœy×7Ñ7Ô8¸W¿\º\Ü�7—<‘<Ó  1Ò$Ø—‘×+Ñ+Ü" 4§8¡8Ð-eÐhmÑ-mÓnôpàŸ™ Q™‰IÜ˜¤×!:Ñ!:Ô;Ø�L‰L×'Ñ'Ü˜tŸx™xÐ)aÐdiÑ)iÓjôlä× Ñ  §¡°¸T¿Y¹YÐR[Ô\ˆØ�‰˜tÓ$Ð$r)   c                 ó  — t        |«      dk  st        |«      dkD  s|r/| j                  j                  t        |j                  d«      «       t        j                  |j                  ||j                  ¬«      }| j                  |«      S )Nr   rÇ   zBcritical_section directive accepts one or two positional arguments©ry   rO   )	rÏ   rG   rº   rl   rL   r   ÚCriticalSectionStatNoderO   r  )r$   r%   ry   r'  s       r&   rj  z7InterpretCompilerDirectives._transform_critical_section§  sl   € Üˆt‹9�qŠ=œC ›I¨šM©TØ�L‰L×'Ñ'Ü˜tŸx™xÐ)mÓnôô ×,Ñ,Ø�H‰H˜4 d§i¡iô
ˆð �‰˜tÓ$Ð$r)   ).r:   r;   r<   r=   r   Ú
TypeofNodeÚAmpersandNodeÚDereferenceNodeÚinc_dec_constructorÚ
TypeidNodeÚunop_method_nodesÚc_binop_constructorÚbinop_method_nodesrè  r,  rÒ  rï  rC   rË  rÜ  rQ   ræ  rê  rñ  r   rÿ  r  rú  rÂ   r  r¤  r  r  r*  r"  rA  r  r+   r‹  r9   rP  rD  rl  ri  rj  ri   rj   s   @r&   r§  r§  4  sh  ø„ ñð: ×&Ñ&à%×3Ñ3Ø )× 9Ñ 9Ø"? )×"?Ñ"?ÀÀdÓ"KØ"? )×"?Ñ"?ÀÀdÓ"KØ"? )×"?Ñ"?ÀÀtÓ"LØ"? )×"?Ñ"?ÀÀtÓ"LØ"+×"6Ñ"6ð ×*Ñ*ñÐð  	Ð"? )×"?Ñ"?ÀÓ"DðÐò€Oð
 ×ÑÐ,Ô-òÐò!Ðô%ò	ò$òNòò3ò
ò*"òHòBò8ò*òòòòò
*òX>ò@'gòTQò
VòQòQòQòB)òJ%ò,%ö%r)   r§  c                   óª   ‡ — e Zd ZdZdZdZdZdZej                  e
j                  ej                  dœZd„ Zd„ Zd„ Zd„ Zd	„ Zd
„ Zd„ Zd„ Zˆ fd„Zˆ xZS )ÚParallelRangeTransformaÈ  
    Transform cython.parallel stuff. The parallel_directives come from the
    module node, set there by InterpretCompilerDirectives.

        x = cython.parallel.threadavailable()   -> ParallelThreadAvailableNode
        with nogil, cython.parallel.parallel(): -> ParallelWithBlockNode
            print cython.parallel.threadid()    -> ParallelThreadIdNode
            for i in cython.parallel.prange(...):  -> ParallelRangeNode
                ...
    NF)zcython.parallel.parallelzcython.parallel.threadidzcython.parallel.prangec                 óN   — |j                   | j                  v xs |j                  S r!   )rx   r¿  r  r#   s     r&   Únode_is_parallel_directivez1ParallelRangeTransform.node_is_parallel_directiveÓ  s"   € Ø�y‰y˜D×4Ñ4Ð4ÒM¸×8MÑ8MÐMr)   c                 óº  — | j                   rdj                  | j                  «      }nP| j                  | j                  d      }|›ddj                  | j                  dd «      ›�}|j	                  d«      }| j
                  j                  |«      }|€7| j                   r| j                  d   dk7  st        |j                  d|z  «       d| _         d| _        |S )zº
        Figure out which parallel directive was used and return the associated
        Node class.

        E.g. for a cython.parallel.prange() call we return ParallelRangeNode
        rÎ  r   r   Nr³  zInvalid directive: %sF)	Únamenode_is_cython_moduleÚjoinÚparallel_directiver¿  ÚrstripÚdirective_to_noder³   r   rL   )r$   r%   rÈ  r6  s       r&   Úget_directive_class_nodez/ParallelRangeTransform.get_directive_class_nodeÖ  sÏ   € ð ×)Ò)ØŸ™ ×!8Ñ!8Ó9‰Ià×0Ñ0°×1HÑ1HÈÑ1KÑLˆIÚ#,Ø#&§8¡8¨D×,CÑ,CÀAÀBÐ,GÔ#HðJˆIà!×(Ñ(¨Ó-ˆIà×$Ñ$×(Ñ(¨Ó3ˆØˆ; × >Ò >Ø $× 7Ñ 7¸Ñ :¸jÒ HÜ�$—(‘(Ð3°iÑ?Ô@à).ˆÔ&Ø"&ˆÔàˆ
r)   c                 ób   — |j                   r"|j                   | _         | j                  |«      S |S )zd
        If any parallel directives were imported, copy them over and visit
        the AST
        )r¿  r  r#   s     r&   rQ   z'ParallelRangeTransform.visit_ModuleNodeï  s1   € ð
 ×#Ò#Ø'+×'?Ñ'?ˆDÔ$Ø—?‘? 4Ó(Ð(ð ˆr)   c                 ón   — | j                  |«      r#|j                  g| _        |j                  | _        |S r!   )r�  rx   r…  r  rƒ  r#   s     r&   r  z%ParallelRangeTransform.visit_NameNodeû  s1   € Ø×*Ñ*¨4Ô0Ø'+§y¡y kˆDÔ#Ø-1×-BÑ-BˆDÔ*Øˆr)   c                 óŠ   — | j                  |«       | j                  r%| j                  j                  |j                  «       |S r!   )r8   r…  r¶   Ú	attributer#   s     r&   r¤  z*ParallelRangeTransform.visit_AttributeNode  s6   € Ø×Ñ˜4Ô Ø×"Ò"Ø×#Ñ#×*Ñ*¨4¯>©>Ô:Øˆr)   c                 óR  — | j                  |d«       | j                  s| j                  |d¬«       |S t        |t        j
                  «      r#|j                  j                  }|j                  }n|j                  }i }| j                  |«      }|r ||j                  ||¬«      }|S )Nr  )r  r9  )ry   Úkwargs)r  r…  r8   rN   r   rq  Úpositional_argsry   Úkeyword_argsrˆ  rL   )r$   r%   ry   rŽ  Úparallel_directive_classs        r&   Úvisit_CallNodez%ParallelRangeTransform.visit_CallNode  sš   € Ø�‰˜˜jÔ)Ø×&Ò&Ø×Ñ˜t¨]ÐÔ;ØˆKô
 �dœI×5Ñ5Ô6Ø×'Ñ'×,Ñ,ˆDØ×&Ñ&‰Fà—9‘9ˆDØˆFà#'×#@Ñ#@ÀÓ#FÐ Ù#ñ ,¨D¯H©H¸4ÈÔOˆDàˆr)   c                 óÖ  — | j                  |j                  «      }t        |t        j                  «      rX| j
                  dk(  r t        |j                  j                  d«       d| _        | j                  |d«      }d| _        ||_	        |S | j                  r=| j                  |«      }|sy|t        j                  u rt        |j                  d«       y| j                  |d«       |S )z.Rewrite with cython.parallel.parallel() blockszparallel withz*Nested parallel with blocks are disallowedrO   Nz%The parallel directive must be called)r$  rh  rN   r   ÚParallelWithBlockNodern  r   rL   r  rO   r…  rˆ  )r$   r%   ÚnewnoderO   r‘  s        r&   rl  z)ParallelRangeTransform.visit_WithStatNode  sÇ   € à—*‘*˜TŸ\™\Ó*ˆä�gœu×:Ñ:Ô;Ø�z‰z˜_Ò,Ü�d—l‘l×&Ñ&ØBôDð )ˆDŒJØ—?‘? 4¨Ó0ˆDØˆDŒJàˆGŒLØˆNØ×$Ò$Ø'+×'DÑ'DÀTÓ'JÐ$á+àà'¬5×+FÑ+FÑFÜ�d—h‘hÐ GÔHØà�‰˜˜fÔ%Øˆr)   c                 óH  — | j                  |d«       | j                  |d«       t        |j                  j                  t        j
                  «      }| j                  }|r–|j                  j                  }|j                  |_        |j                  |_        |j                  |_	        |}t        |j                  t        j                  «      s t        |j                  j                  d«       d| _        | j                  |d«       || _        | j                  |d«       |S )z/Rewrite 'for i in cython.parallel.prange(...):'r‰   ré   z+Can only iterate over an iteration variabler¹  rO   Úelse_clause)r  rN   r‰   Úsequencer   ÚParallelRangeNodern  ré   rO   r—  r   r¸   r   rL   )r$   r%   Ú	in_prangeÚprevious_stateÚparallel_range_nodes        r&   r  z*ParallelRangeTransform.visit_ForInStatNode<  sä   € à�‰˜˜jÔ)Ø�‰˜˜hÔ'ä˜tŸ}™}×5Ñ5Ü$×6Ñ6ó8ˆ	àŸ™ˆáð #'§-¡-×"8Ñ"8Ðà)-¯©ÐÔ&Ø'+§y¡yÐÔ$Ø.2×.>Ñ.>ÐÔ+à&ˆDä˜dŸk™k¬9×+=Ñ+=Ô>Ü�d—k‘k—o‘oØCôEð "ˆDŒJà�‰˜˜fÔ%Ø#ˆŒ
Ø�‰˜˜mÔ,Øˆr)   c                 ó(   •— |�t         ‰| �  |«      S y)zVisit a node that may be NoneN)rB   r$  r‡  s     €r&   r$  zParallelRangeTransform.visit[  s   ø€ àÐÜ‘7‘= Ó&Ð&ð r)   )r:   r;   r<   r=   r…  rƒ  Úin_context_manager_sectionrn  r   r”  r   ÚParallelThreadIdNoder™  r‡  r�  rˆ  rQ   r  r¤  r’  rl  r  r$  ri   rj   s   @r&   r  r  ²  s   ø„ ñ	ð Ðð !&Ðð "'Ðð €Eð %*×$?Ñ$?à$-×$BÑ$BØ"'×"9Ñ"9ñ	ÐòNòò2
òòòò0ò:÷>'ð 'r)   r  c                   ó0   — e Zd Zd„ Zd„ Zej                  Zy)ÚWithTransformc                 ó†  — | j                  |dg«       |j                  }|j                  }|j                  |j                  |j
                  }}}t        j                  |«      x}|_        t        j                  |t        j                  |t        j                  |«      t        |rdnd«      d¬«      g d¬«      |_        |r&t        j                  ||j                  ¬«      |_        |�/t        j                  |t        j                   |||¬«      |g¬	«      }t        j"                  |dt%        d
«      D �cg c]  }t        j&                  |«      ‘Œ c}¬«      }t        j(                  |t        j*                  |t        j,                  |t        j.                  |t        j0                  ||d||rt        j                  |d ¬«      nd ¬«      ¬«      t        j2                  |«      ¬«      gd ¬«      d d |¬«      }	t        j4                  |t        j6                  |||	gd ¬«      t        j8                  |t        j0                  ||dt        j"                  |t%        d
«      D �cg c]  }t        j:                  |«      ‘Œ c}¬«      |rt        j                  |d ¬«      nd ¬«      ¬«      d¬«      |_        |S c c}w c c}w )NrO   Ú
__aenter__Ú	__enter__T)r¢  rŒ  Úis_special_lookup)r  ry   Úis_temp)rá   )r©   Ú	with_noderÊ   rî  )Úslowry   F)Ú	with_statÚtest_if_runry   Ú
await_expr©Úoperand)ro  rO   )Ú
if_clausesr—  )rO   Úpatternré   Úexcinfo_target)rO   Úexcept_clausesr—  ©ry   ru   )rO   ræ   Úhandle_error_case)r8   rL   Úis_asyncrO   ré   rh  r   Ú	ProxyNoderp  r#  Ú	CloneNoder   Ú
enter_callÚAwaitExprNoder   rP   ÚWithTargetAssignmentStatNodeÚ	TupleNoder[  ÚExcValueNodeÚExceptClauseNodeÚ
IfStatNodeÚIfClauseNodeÚNotNodeÚWithExitCallNodeÚReraiseStatNoderê   ÚTryExceptStatNoder‚   r1  )
r$   r%   rL   r´  rO   ré   rh  rÛ   r°  Úexcept_clauses
             r&   rl  z WithTransform.visit_WithStatNodeb  s„  € Ø×Ñ˜4 & Ô*Ø�h‰hˆØ—=‘=ˆØ $§	¡	¨4¯;©;¸¿¹�gˆfˆÜ!*×!4Ñ!4°WÓ!=Ð=ˆ�$”,Ü#×2Ñ2Øœ)×1Ñ1Øœ×,Ñ,¨WÓ5Ü'¹©ÀkÓRØ"&ô(ð ØôˆŒñ Ü'×5Ñ5°c¸t¿¹ÔOˆDŒOàÐÜ×%Ñ%ØÜ×6Ñ6Ø °4ô9àðôˆDô #×,Ñ,¨S°tÜ16°q´óC;Ù19¨AŒI×"Ñ" 3Õ'°ñC;ô <ˆä×.Ñ.Ø”e×&Ñ&ØÜ×&Ñ&Ø¤y×'8Ñ'8Ø¬×)CÑ)CØ #¨tØ,1Ø%3ÙU]¬9×+BÑ+BÀ3ÈDÕ+QÐcgô	*iô(jô #×2Ñ2°3Ó7ôð
!ð !ô"ð ØØ)ô!
ˆô& ×,Ñ,Ø”e×-Ñ-Ø˜$Ø -˜Ø ôô
 !×-Ñ-Øœ)×4Ñ4Ø 4Ø $Ü"×,Ñ,ØÄEÈ!ÄHÓ"MÁH¸q¤9×#5Ñ#5°cÕ#:ÀHÑ"MôOáIQœy×6Ñ6°sÀÕEÐW[ô]ô^ð $ô
ˆŒ	ð ˆùòIC;ùò@ #Ns   Ä8J9É$J>"c                 ó   — |S r!   r"   r#   s     r&   rU   zWithTransform.visit_ExprNode   ó   € àˆr)   N)r:   r;   r<   rl  rU   r   r¥  r  r"   r)   r&   r¡  r¡  a  s   „ ò<ò|ð "×5Ñ5�Jr)   r¡  c                   ó0   ‡ — e Zd Zˆ fd„Zd„ Zd„ Zd„ Zˆ xZS )Ú#_GeneratorExpressionArgumentsMarkerc                 ó0   •— t         ‰| �  «        || _        y r!   )rB   rC   Úgen_expr)r$   rÉ  rH   s     €r&   rC   z,_GeneratorExpressionArgumentsMarker.__init__©  s   ø€ Ü‰ÑÔØ ˆ�r)   c                 ó|   — |j                   s|j                  rJ ‚| j                  |_        | j                  |«       y r!   )rE  Úgenerator_arg_tagrÉ  r8   r#   s     r&   rU   z2_GeneratorExpressionArgumentsMarker.visit_ExprNode­  s2   € Ø�Šà×.Ò.Ð/Ð.Ø%)§]¡]ˆDÔ"Ø×Ñ˜4Õ r)   c                  ó   — y r!   r"   r#   s     r&   r  z._GeneratorExpressionArgumentsMarker.visit_Node´  s   € ð 	r)   c                 ó&   — | j                   |_        y r!   )rÉ  rË  r#   s     r&   r™   zA_GeneratorExpressionArgumentsMarker.visit_GeneratorExpressionNode¹  s   € Ø!%§¡ˆÕr)   )r:   r;   r<   rC   rU   r  r™   ri   rj   s   @r&   rÇ  rÇ  §  s   ø„ ô!ò!òö
/r)   rÇ  c                   ó<   — e Zd Zd„ Zd„ Zd„ Zd„ Zej                  Z	y)Ú_HandleGeneratorArgumentsc                 óÔ  — ddl m} t        |t        j                  «      sJ ‚|| _        t        |j                  j                  «      | _        t        |j                  «      | _	        d| _
        i | _        | j                  |«       | j                  j                  «       D ]  \  }}|j                  |||«       Œ | j                  |j                  _        | j                  |_	        |S )Nr   )ÚVisitorr   )rm  rÑ  rN   r   ÚGeneratorExpressionNodeÚgen_noderN  r…   ry   Úcall_parametersÚ	tag_countÚsubstitutionsr8   r\  Úrecursively_replace_node)r$   r%   rÑ  ÚkÚvs        r&   r†  z"_HandleGeneratorArguments.__call__Ã  s¾   € ÝÜ˜$¤	× AÑ AÔBÐBÐBØˆŒä˜Ÿ™×+Ñ+Ó,ˆŒ	Ü# D×$8Ñ$8Ó9ˆÔØˆŒØˆÔà×Ñ˜4Ô à×&Ñ&×,Ñ,Ö.‰DˆAˆqð ×,Ñ,¨T°1°aÕ8ð	 /ð "ŸY™Yˆ�‰ÔØ#×3Ñ3ˆÔØˆr)   c                 ó,   — | j                  |d¬«      }|S )NF)Údo_visit_children©Ú_handle_ExprNode)r$   r%   Únew_nodes      r&   r™   z7_HandleGeneratorArguments.visit_GeneratorExpressionNodeÙ  s   € à×(Ñ(¨ÀÐ(ÓGˆð ˆr)   c                 óT  — |j                   ��‡| j                  ��z| j                  |j                   k(  �r`|j                  }| j                  }| xj                  dz  c_        t	        dj                  |«      «      }| j                  j                  }|j                  j                  |«      �s-ddl	m
} t	        t        j                  |j                  t        |«      «      z   «      }t        j                   ||¬«      }	|j"                  }
t%        j&                  |
d¬«      }
|
|	_        t        j(                  ||	d d d ¬«      }|	j*                  |_        |
|_        | j,                  j/                  |«       d |_         | j0                  j/                  |«       |j3                  |j                  |«      |_        ||j4                  _        d|j4                  _        |r,| j                  d c}| _        | j;                  |«       || _        t=        j>                  ||d¬	«      }| j                  j                  j@                  j                  jC                  |j*                  «      |_        |j4                  j"                  |_        || jD                  |<   |S |r| j;                  |«       |S )
Nr   z.{})ÚSymtab©rL   rx   F)Úremove_fakeref)rL   Ú
declaratorÚ	base_typerž   r  T)rx   Úinitialized_check)#rË  rÓ  rL   rÕ  r   Úformatr…   Úlocal_scopeÚlookup_hererm  rà  r   Úgenexpr_arg_prefixÚpunycodify_namerÂ  r   r±   r4  r   Úremove_cv_refÚCArgDeclNoderx   ry   r¶   rÔ  Údeclare_argumentÚentryÚcnameÚ
in_closurer8   r   r¸   ÚgbodyÚlookuprÖ  )r$   r%   rÛ  rL   Úname_sourcerx   r…   rà  rï  Ú	name_declr4  Únew_argrÓ  r  s                 r&   rÝ  z*_HandleGeneratorArguments._handle_ExprNodeà  s  € Ø×"Ñ"Ñ.°4·=±=Ñ3LØ—‘ ×!7Ñ!7Ó7Ø—(‘(ˆCð Ÿ.™.ˆKØ�NŠN˜aÑ�NÜ  §¡¨kÓ!:Ó;ˆDØ—}‘}×-Ñ-ˆHØ×'Ñ'×3Ñ3°DÕ9Ý$Ü%¤f×&?Ñ&?À&×BXÑBXÔY\Ð]hÓYiÓBjÑ&jÓk�Ü!×5Ñ5¸#ÀDÔI�	Ø—y‘y�ô "×/Ñ/°ÀUÔK�à!%�	”Ü×,Ñ,°ÀØ:>ÈÐY]ô_�à(Ÿ~™~�”Ø#�”à—	‘	× Ñ  Ô)Ø)-�Ô&Ø×$Ñ$×+Ñ+¨DÔ1Ø (× 9Ñ 9¸(×:NÑ:NÐPWÓ X�”Ø&+�—‘Ô#Ø+/�—‘Ô(á ð +/¯-©-¸Ð'�˜$œ-Ø×"Ñ" 4Ô(Ø (�”ô
 "×*Ñ*¨3°TÈUÔSˆIØ"Ÿm™m×4Ñ4×:Ñ:×FÑF×MÑMÈiÏnÉnÓ]ˆIŒOØ&Ÿ_™_×1Ñ1ˆIŒNØ'0ˆD×Ñ˜tÑ$ØÐÙØ×Ñ˜tÔ$Øˆr)   c                 ó&   — | j                  |d«      S rS   rÜ  r#   s     r&   rU   z(_HandleGeneratorArguments.visit_ExprNode  s   € Ø×$Ñ$ T¨4Ó0Ð0r)   N)
r:   r;   r<   r†  r™   rÝ  rU   r   r¥  r  r"   r)   r&   rÏ  rÏ  À  s$   „ òò,ò;òz1ð "×5Ñ5�Jr)   rÏ  c                   ó®   ‡ — e Zd ZdZdZ ed«       ed«       ed«      dœj                  Zˆ fd„Zd„ Z	d	„ Z
d
„ Zd„ Zed„ «       Zd„ Zd„ Zed„ «       Zˆ xZS )ÚDecoratorTransforma  
    Transforms method decorators in cdef classes into nested calls or properties.

    Python-style decorator properties are transformed into a PropertyNode
    with up to the three getter, setter and deleter DefNodes.
    The functional style isn't supported yet.
    NÚ__get__Ú__set__Ú__del__)ÚgetterÚsetterÚdeleterc                 ó¶   •— | j                   €g | _         | j                   j                  i «       t        ‰| �  |«      }| j                   j	                  «        |S r!   )Ú_propertiesr¶   rB   r‹  Úpopr‡  s     €r&   r‹  z&DecoratorTransform.visit_CClassDefNode3  sQ   ø€ Ø×ÑÐ#Ø!ˆDÔØ×Ñ×Ñ Ô#Ü‰wÑ*¨4Ó0ˆØ×Ñ×ÑÔØˆr)   c                 ó�   — t        |j                  d   t        «      rdnd}t        |j                  d|j                  z  |«       |S )Nr   rÇ   z4'property %s:' syntax is deprecated, use '@property')rN   rL   rÂ  r   rx   )r$   r%   r  s      r&   Úvisit_PropertyNodez%DecoratorTransform.visit_PropertyNode;  s=   € ä §¡¨¡¬SÔ1‘°qˆÜ�—‘ÐPÐSW×S\ÑS\Ñ\Ð^cÔdØˆr)   c                 óÄ  — | j                  |«      }|j                  s|S | j                  dk7  s| j                  j                  dk7  r†t        |j                  «      dk(  rI|j                  d   j                  j                  r&|j                  d   j                  j                  dk(  s#t        |j                  d   j                  d«       |S |}| j                  |«      }|rR|j                  j                  r&|j                  «       }|r*| j                  |||«      }nt        |j                  d«       |j                  r| j                  ||j                  d   «      S |S )Nr‘   r6   r   r   r¼  z0Cdef functions cannot take arbitrary decorators.z*C property decorator can only be @property)r  rX  r—   r¡   r7   rÏ   rZ  r  rx   r   rL   Ú_find_property_decoratorÚdeclared_nameÚ_add_propertyÚ_reject_decorated_property)r$   r%   Úret_nodeÚdecorator_noderx   s        r&   Úvisit_CFuncDefNodez%DecoratorTransform.visit_CFuncDefNodeA  s&  € Ø×%Ñ% dÓ+ˆØ�ŠØˆKØ�_‰_ Ò(¨D¯O©O×,FÑ,FÈ(Ò,Rô ˜Ÿ™Ó(¨AÒ-°$·/±/À!Ñ2D×2NÑ2N×2VÒ2VØ—O‘O AÑ&×0Ñ0×5Ñ5¸ÒGÜ�d—o‘o aÑ(×,Ñ,Ð.`ÔaØˆKàˆØ×6Ñ6°tÓ<ˆÙØ×'Ñ'×/Ò/Ø×)Ñ)Ó+�ÙØ#×1Ñ1°$¸¸nÓM‘Hä�n×(Ñ(Ð*VÔWà�?Š?Ø×2Ñ2°4¸¿¹ÈÑ9KÓLÐLØˆr)   c                 ó   — | j                   }| j                  |«      }|dk7  s|j                  s|S | j                  |«      }|�î|j                  }|j
                  r| j                  ||j                  |«      S | j                  |j                  «      }|rœ|j                  j                  |j                  k7  r<t        |j                  d|j                  j                  ›d|j                  ›d�«       n=t        |j                  «      dkD  r| j                  ||«      S | j                  |||«      S |j                  D ]_  }|j                  }|j
                  sŒ|xj                   |j                  dk(  z  c_        |xj"                  |j                  dk(  z  c_        Œa |j                  }d |_        | j%                  |||j                  «      S )Nr‘   z&Mismatching property names, expected 'z', got 'r
  r   rB  r¼  )r—   r  rX  r  rZ  r  r  rx   Ú_map_property_attributerŒ  r¢  r   rL   rÏ   r  Ú_add_to_propertyÚis_classmethodÚis_staticmethodÚchain_decorators)r$   r%   r—   r
  rZ  Úhandler_nameÚfuncÚdecss           r&   r  z DecoratorTransform.visit_DefNode[  sˆ  € Ø—_‘_ˆ
Ø×%Ñ% dÓ+ˆØ˜Ò!¨¯ªØˆKð ×6Ñ6°tÓ<ˆØÐ%Ø&×0Ñ0ˆIØ× Ò Ø×)Ñ)¨$°·	±	¸>ÓJÐJà#×;Ñ;¸I×<OÑ<OÓP�ÙØ —}‘}×)Ñ)¨T¯Y©YÒ6ä˜n×0Ò0à"+§-¡-×"4Ó"4°d·i³iðAõBô ˜TŸ_™_Ó-°Ò1Ø#×>Ñ>¸tÀ^ÓTÐTà#×4Ñ4°T¸<ÈÓXÐXð ŸœˆIØ×&Ñ&ˆDØ�|‹|Ø×#Ò# t§y¡y°MÑ'AÑAÕ#Ø×$Ò$¨¯	©	°^Ñ(CÑCÖ$ð	 )ð �‰ˆØˆŒØ×$Ñ$ T¨4°·±Ó;Ð;r)   c                 óø   — | j                   d   }|j                  d d d…   D ]V  }|j                  }|j                  r|j                  dk(  r|c S |j
                  sŒ;|j                  j                  |v sŒT|c S  y )NrÈ   Úproperty)r   rX  rZ  r  rx   Úis_attributer¢  )r$   r%   Ú
propertiesr
  rZ  s        r&   r  z+DecoratorTransform._find_property_decorator�  ss   € Ø×%Ñ% bÑ)ˆ
Ø"Ÿo™o©d°¨dÔ3ˆNØ&×0Ñ0ˆIØ× Ò  Y§^¡^°zÒ%Aà%Ò%Ø×'Ó'¨I¯M©M×,>Ñ,>À*Ò,Là%Ò%ð 4ð r)   c                 ó`   — | j                   D ]  }||k7  sŒ	t        |j                  d«       Œ  | S )Nz=Property methods with additional decorators are not supported)rX  r   rL   )r%   r
  Údecos      r&   r  z-DecoratorTransform._reject_decorated_property�  s0   € ð —O”OˆDØ�~Ó%Ü�d—h‘hÐ _Õ`ð $ð ˆr)   c                 óh  — t        |j                  «      dkD  r| j                  ||«      S |j                  j                  |«       | j                  d   }t        |t        j                  «      }t        j                  |j                  |g¬«      }|rl||v rt        |j                  d«       d|j                  vrt        |j                  d«       t        j                  |j                  |j                  ||¬«      }n®||v rm||   }|j                  rt        |j                  d«       y t        d«      |_        |j                  |_	        |j                  |_        |g|j"                  _        y t        d«      |_        t        j&                  |j                  ||j                  |¬	«      }|||<   |S )
Nr   rÈ   rÊ   úC property redeclaredr�  z+C property method must be declared 'inline')r|   rx   rO   rù  )rx   r|   rO   )rÏ   rX  r  Úremover   rN   r   r“  rP   rL   r   r”  ÚCPropertyNoder|   Úis_cpropertyr   rx   rO   rM   ÚPropertyNode)r$   r%   rx   r
  r  r  rO   Úprops           r&   r  z DecoratorTransform._add_property•  sd  € Üˆt�‰Ó !Ò#Ø×2Ñ2°4¸ÓHÐHØ�‰×Ñ˜~Ô.Ø×%Ñ% bÑ)ˆ
Ü! $¬×(:Ñ(:Ó;ˆÜ×!Ñ! $§(¡(°4°&Ô9ˆÙØ�zÑ!Ü�d—h‘hÐ 7Ô8Ø˜tŸ~™~Ñ-Ü�d—h‘hÐ MÔNÜ×&Ñ& t§x¡x°T·X±XÀDÈtÔT‰DØ�ZÑØ˜dÑ#ˆDØ× Ò Ü�d—h‘hÐ 7Ô8ð ô	 *¨)Ó4�”	ØŸ8™8�”ØŸ8™8�”Ø#' &�—	‘	”Øä% iÓ0ˆDŒIÜ×%Ñ%Ø—‘˜t¨¯©¸ô>ˆDàˆ
�4ÑØˆr)   c                 ój  — | j                   d   }||j                     }|j                  rt        |j                  d«       y ||_        |j
                  j                  |«       |j                  j                  }t        |«      D ]  \  }}|j                  |k(  sŒ|||<    y  |j                  |«       y )NrÈ   r  )r   rx   r  r   rL   rX  r  rO   rM   rZ  r¶   )	r$   r%   rx   rZ  r  r!  rM   r_  Ústats	            r&   r  z#DecoratorTransform._add_to_property³  s¢   € Ø×%Ñ% bÑ)ˆ
Ø˜$Ÿ)™)Ñ$ˆØ×ÒÜ�$—(‘(Ð3Ô4ØØˆŒ	Ø�‰×Ñ˜yÔ)Ø—	‘	—‘ˆÜ  Ö'‰GˆAˆtØ�y‰y˜DÓ Ø��a‘Øð ð (ð
 �L‰L˜ÔØr)   c                 ó€  — t        j                  | j                  |¬«      }|ddd…   D ]/  }t        j                  |j                  |j                  |g¬«      }Œ1 t        j                  | j                  |¬«      }t        j                  | j                  ||¬«      }t        j                  |g«      }|| _        | |gS )af  
        Decorators are applied directly in DefNode and PyClassDefNode to avoid
        reassignments to the function/class name - except for cdef class methods.
        For those, the reassignment is required as methods are originally
        defined in the PyMethodDef struct.

        The IndirectionNode allows DefNode to override the decorator.
        r¨   NrÈ   ©r  ry   rÉ   )	r   r¸   rL   rp  rZ  r   r·   ÚIndirectionNodeÚdecorator_indirection)r%   rX  rx   Údecorator_resultrZ  r  Úreassignments          r&   r  z#DecoratorTransform.chain_decoratorsÄ  s±   € ô %×-Ñ-¨d¯h©h¸TÔBÐØ#¡D b DÔ)ˆIÜ(×7Ñ7Ø—‘Ø"×,Ñ,Ø&Ð'ô )Ñð *ô ×&Ñ& t§x¡x°dÔ;ˆ	Ü×1Ñ1Ø�H‰HØØ ô"ˆô
 ×,Ñ,¨l¨^Ó<ˆØ%1ˆÔ"Ø�lÐ#Ð#r)   )r:   r;   r<   r=   r   r   r³   r  r‹  r  r  r  r  r¼  r  r  r  r  ri   rj   s   @r&   rø  rø  #  s†   ø„ ñð €Kñ   	Ó*Ù 	Ó*Ù  Ó+ñ÷ 
�cð	 ôòòò4$<òL
ð ñó ðòò<ð" ñ$ó ô$r)   rø  c                   ó*   — e Zd ZdZd„ ZeZeZeZeZeZ	y)ÚCnameDirectivesTransformzí
    Only part of the CythonUtilityCode pipeline. Must be run before
    DecoratorTransform in case this is a decorator for a cdef class.
    It filters out @cname('my_cname') decorators and rewrites them to
    CnameDecoratorNodes.
    c                 ó¸  — t        |dd «      s| j                  |«      S t        |j                  «      D �]  \  }}|j                  }t        |t        j                  «      sŒ.|j                  j                  sŒE|j                  j                  dk(  sŒ_|j                  «       \  }}|rt        d«      ‚t        |«      dk7  rt        d«      ‚|d   j                  r|d   j                  t         j"                  u st        d«      ‚|d   j%                  d «      }|j                  |= t'        j(                  |j*                  ||¬«      } n | j                  |«      S )	NrX  rï  z/cname decorator does not take keyword argumentsr   z*cname decorator takes exactly one argumentr   z4argument to cname decorator must be a string literal)rL   r%   rï  )Úgetattrr  rZ  rX  rZ  rN   r   r  r  r  rx   r  rî   rÏ   rE  r4  r   Úunicode_typeÚcompile_time_valuer   ÚCnameDecoratorNoderL   )r$   r%   r_  rZ  ry   rŽ  rï  s          r&   Úhandle_functionz(CnameDirectivesTransform.handle_functionè  s?  € Ü�t˜\¨4Ô0Ø—?‘? 4Ó(Ð(ä% d§o¡o×6‰LˆAˆyØ!×+Ñ+ˆIä˜9¤i×&8Ñ&8Õ9Ø×&Ñ&×.Ó.Ø×&Ñ&×+Ñ+¨wÓ6Ø(×;Ñ;Ó=‘��fáÜ(ØMóOð Oô �t“9 ’>Ü(ØHóJð Jð ˜Q™×*Ò*¨t°A©w¯|©|¼w×?SÑ?SÑ/SÜ(ØRóTð Tð ˜Q™×2Ñ2°4Ó8�Ø—O‘O AÐ&Ü×/Ñ/°D·H±HÀ4Ø6;ô=�áð1 7ð4 �‰˜tÓ$Ð$r)   N)
r:   r;   r<   r=   r1  r  r‹  r1   r3   r+   r"   r)   r&   r+  r+  à  s-   „ ñò%ð@ (ÐØ)ÐØ(ÐØ"1ÐØ'Ñr)   r+  c                   ó@   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zy
)ÚForwardDeclareTypesz�
    Declare all global cdef names that we allow referencing in other places,
    before declaring everything (else) in source code order.
    c                 óˆ   — | j                   }|j                  }|j                  |_        | j                  |«       ||_        |S r!   )rá  rÃ  r8   )r$   r%   ÚenvrŠ  s       r&   ræ  z0ForwardDeclareTypes.visit_CompilerDirectivesNode  s;   € Ø×ÑˆØ�n‰nˆØŸ™ˆŒØ×Ñ˜4Ô ØˆŒØˆr)   c                 ó€   — |j                   | _        |j                  | j                  _        | j                  |«       |S r!   )rÉ  rá  rÃ  r8   r#   s     r&   rQ   z$ForwardDeclareTypes.visit_ModuleNode  s3   € Ø ŸJ™JˆÔØ'+§¡ˆ×ÑÔ$Ø×Ñ˜4Ô Øˆr)   c                 ó˜   — | j                   j                  }d| j                   _        | j                  |«       || j                   _        |S ©Nr   )rá  Úin_cincluder8   )r$   r%   Úold_cinclude_flags      r&   Úvisit_CDefExternNodez(ForwardDeclareTypes.visit_CDefExternNode#  sC   € Ø ×-Ñ-×9Ñ9ÐØ()ˆ×ÑÔ%Ø×Ñ˜4Ô Ø(9ˆ×ÑÔ%Øˆr)   c                 ó<   — |j                  | j                  «       |S r!   )r¯  rá  r#   s     r&   r1   z&ForwardDeclareTypes.visit_CEnumDefNode*  s   € Ø�‰�T×&Ñ&Ô'Øˆr)   c                 ó€   — |j                   | j                  j                  vr|j                  | j                  «       |S r!   )rx   rá  Úentriesr¯  r#   s     r&   r3   z/ForwardDeclareTypes.visit_CStructOrUnionDefNode.  s1   € Ø�9‰9˜D×-Ñ-×5Ñ5Ñ5Ø�L‰L˜×*Ñ*Ô+Øˆr)   c                 óÜ  — |j                   | j                  j                  vr|j                  | j                  «       | j                  j                  |j                      j                  }|�|j
                  rs|j                  sg|j                  r[|j                  }|j                  D ]@  }|j                  sŒ|j                  j                  sŒ'|j                  j                  «        ŒB |S r!   )Ú
class_namerá  r>  r¯  r4  Úis_extension_typeÚis_builtin_typerÉ  Úcfunc_entriesÚis_fusedÚ"get_all_specialized_function_types)r$   r%   r4  rÉ  rî  s        r&   r‹  z'ForwardDeclareTypes.visit_CClassDefNode3  s®   € Ø�?‰? $×"3Ñ"3×";Ñ";Ñ;Ø�L‰L˜×*Ñ*Ô+à× Ñ ×(Ñ(¨¯©Ñ9×>Ñ>ˆØÐ × 6Ò 6¸t×?SÒ?SÐX\×XbÒXbØ—J‘JˆEØ×,Ô,�Ø—:“: %§*¡*×"5Ó"5Ø—J‘J×AÑAÕCð -ð ˆr)   c                 ó   — |S r!   r"   r#   s     r&   r  z%ForwardDeclareTypes.visit_FuncDefNode?  rÅ  r)   c                 ó   — |S r!   r"   r#   s     r&   rP  z(ForwardDeclareTypes.visit_PyClassDefNodeC  rÅ  r)   N)r:   r;   r<   r=   ræ  rQ   r;  r1   r3   r‹  r  rP  r"   r)   r&   r3  r3    s/   „ ñò
òòòòò

òór)   r3  c                   óŽ  ‡ — e Zd Z edd ed«      g¬«      Z edd ed«      g¬«      Z edd ed«      g¬«      Z ed ed«      g¬«      Z ed	 ed«      g¬«      Z	dZ
d
Zˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zˆ fd„Zd„ Zd„ Zd„ Z d „ Z!d!„ Z"d"„ Z#d#„ Z$d$„ Z%d%„ Z&d&„ Z'd'„ Z(d(„ Z)d)„ Z*ˆ xZ+S )*ÚAnalyseDeclarationsTransformzr
property NAME:
    def __get__(self):
        return ATTR
    def __set__(self, value):
        ATTR = value
    Úc_classN©r  Úpipelinez�
property NAME:
    def __get__(self):
        return ATTR
    def __set__(self, value):
        ATTR = value
    def __del__(self):
        ATTR = None
    z?
property NAME:
    def __get__(self):
        return ATTR
    a„  
cdef class NAME:
    cdef TYPE value
    def __init__(self, MEMBER=None):
        cdef int count
        count = 0
        INIT_ASSIGNMENTS
        if IS_UNION and count > 1:
            raise ValueError, "At most one union member should be specified."
    def __str__(self):
        return STR_FORMAT % MEMBER_TUPLE
    def __repr__(self):
        return REPR_FORMAT % MEMBER_TUPLE
    )rL  z;
if VALUE is not None:
    ATTR = VALUE
    count += 1
    r   c                 óˆ   •— g | _         t        «       | _        t        «       }|j                  | _        |j                  |«      S r!   )Úseen_vars_stackr)  Úfused_error_funcsrB   r  Ú_super_visit_FuncDefNoder†  )r$   ÚrootÚsuper_classrH   s      €r&   r†  z%AnalyseDeclarationsTransform.__call__x  s;   ø€ à!ˆÔÜ!$£ˆÔÜ“gˆØ(3×(EÑ(EˆÔ%Ø×#Ñ# DÓ)Ð)r)   c                 óV   — | j                   d   j                  |j                  «       |S ©NrÈ   )rN  rF  rx   r#   s     r&   r  z+AnalyseDeclarationsTransform.visit_NameNode€  s$   € Ø×Ñ˜RÑ ×$Ñ$ T§Y¡YÔ/Øˆr)   c                 óL  — g | _         | j                  j                  t        «       «       |j	                  | j                  «       «       | j                  |«       | j                  j                  «        |j                  j                  j                  | j                   «       |S r!   )Úextra_module_declarationsrN  r¶   r)  Úanalyse_declarationsÚcurrent_envr8   r  rO   rM   r  r#   s     r&   rQ   z-AnalyseDeclarationsTransform.visit_ModuleNode„  sx   € à)+ˆÔ&Ø×Ñ×#Ñ#¤C£EÔ*Ø×!Ñ! $×"2Ñ"2Ó"4Ô5Ø×Ñ˜4Ô Ø×Ñ× Ñ Ô"Ø�	‰	�‰×Ñ˜t×=Ñ=Ô>Øˆr)   c                 óº   — | xj                   dz  c_         |j                  | j                  «       «       | j                  |«       | xj                   dz  c_         |S r8  )Ú	in_lambdarW  rX  r8   r#   s     r&   r‡   z-AnalyseDeclarationsTransform.visit_LambdaNodeŽ  sH   € Ø�Š˜!Ñ�Ø×!Ñ! $×"2Ñ"2Ó"4Ô5Ø×Ñ˜4Ô Ø�Š˜!Ñ�Øˆr)   c                 óú  — | j                  |«      }|j                  r?d|j                  j                  v r'ddlm}  |||j                  j                  d   | «       |j                  �r|j                  j
                  rû|j                  rïg }|j                  j                  D ]]  }|j                  sŒ| j                  |«      }|j                  |j                  «       | j                  |«       |j                  |«       Œ_ |r|j                  xj                  |z  c_        |j                  dk7  rG|j                  j                  d«      s,|j                  j                  d«      s| j!                  |«       |S )Núdataclasses.dataclassr   )Úhandle_cclass_dataclassr6   Ú
__reduce__Ú__reduce_ex__)Úvisit_ClassDefNoderÉ  rÃ  Ú	Dataclassr]  ÚimplementedrO   Úvar_entriesÚneeds_propertyÚcreate_PropertyrW  r$  r¶   rM   r7   rò  Ú_inject_pickle_methods)r$   r%   r]  rM   rî  r  s         r&   r‹  z0AnalyseDeclarationsTransform.visit_CClassDefNode•  s  € Ø×&Ñ& tÓ,ˆØ�:Š:Ð1°T·Z±Z×5JÑ5JÑJÝ:Ù# D¨$¯*©*×*?Ñ*?Ð@WÑ*XÐZ^Ô_Ø�:‹:˜$Ÿ*™*×0Ò0°T·Y²YØˆEØŸ™×/Ô/�Ø×'Ó'Ø#×3Ñ3°EÓ:�HØ×1Ñ1°$·*±*Ô=Ø—J‘J˜xÔ(Ø—L‘L Õ*ð 0ñ Ø—	‘	—’ 5Ñ(•Ø—‘ 8Ò+Ø ŸJ™J×-Ñ-¨lÔ;Ø ŸJ™J×-Ñ-¨oÔ>Ø×+Ñ+¨DÔ1Øˆr)   c                 óÌ  — | j                  «       }|j                  j                  d   du ry |j                  j                  d   du }g }|j                  j                  }d }d }|�–|j                  d„ |j                  j                  D «       «       |xs |j                  j                  d«      }|xs8 |j                  j                  d«      xs |j                  j                  d«      }|j                  }|�Œ–|j                  d„ ¬	«       |ry |D �cg c]P  }|j                  j                  s8|j                  j                  |«      r|j                  j                  |«      s|‘ŒR }	}|D �cg c]  }|j                  j                  sŒ|‘Œ }
}|s|	s|
rÖ|sÔ|rd
}n9|	rddj                  d„ |	D «       «      z  }nddj                  d„ |
D «       «      z  }|rt        |j                   |«       t#        dd|iz  dt%        d «      g¬«      j'                  i «      }|j)                  |j                  «       | j+                  |«       |j,                  j.                  j1                  |«       y |D ]O  }|j                  j                  rŒ|j                  j3                  |«       |j                  j5                  |«       ŒQ |D �cg c]  }|j6                  ‘Œ }}dj                  t9        |«      D ��cg c]  \  }}d|›d|›d�‘Œ c}}«      }t;        |«      }t=        |«      dk7  r||d   dz  gz   d d }d|j>                  › �}t=        |«      }|jA                  tB        jD                  jG                  dd«      «       d|› dd j                  |«      › d d j                  |«      jI                  d!«      ›d"|jJ                  › d#|› d$|jJ                  › d%|› d&|jJ                  › d'|› d(|d)›d*�}|jA                  tB        jD                  jG                  d+d«      «       t#        |d,t%        d «      g¬«      j'                  i «      }|j)                  |j                  j                  «       | j+                  |«       | jL                  j1                  |«       d j                  d-„ |D «       «      t=        |«      d.k(  rdnd/z   }d0j                  |D �cg c])  }|j                  j                  sŒd1|j6                  › d2�‘Œ+ c}xs d3g«      }d4|› d5|› d6|› d7|d8   › d9|› d7|d8   › d:|› d;�}t#        |dt%        d «      g¬«      j'                  i «      }|j)                  |j                  «       | jO                  ||j                  «       | j+                  |«       | jQ                  «        |j,                  j.                  j1                  |«       y c c}w c c}w c c}w c c}}w c c}w )<NÚauto_pickleFTc              3   ó>   K  — | ]  }|j                   d vsŒ|–— Œ y­w))Ú__weakref__Ú__dict__Nr¨   ©Ú.0r¿   s     r&   Ú	<genexpr>zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>¶  s   è ø€ ÐmÑ*? QÀ1Ç6Á6ÐQlÒClœqÑ*?ùs   ‚–Ú	__cinit__r^  r_  c                 ó   — | j                   S r!   r¨   )r¿   s    r&   Ú<lambda>zEAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<lambda>º  s   €  q§v¢vr)   )r]  z2no default __reduce__ due to non-trivial __cinit__z6%s cannot be converted to a Python object for picklingrª  c              3   ó:   K  — | ]  }d |j                   z  –— Œ y­w©zself.%sNr¨   rl  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>Ï  s!   è ø€ ÐY}Ñv|ÐqrÐZcÐfg×flÑflÕZlÑv|ùó   ‚zZPickling of struct members such as %s must be explicitly requested with @auto_pickle(True)c              3   ó:   K  — | ]  }d |j                   z  –— Œ y­wrs  r¨   rl  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>Õ  s   è ø€ Ð;`ÑX_ÐST¸IÈÏÉÕ<NÑX_ùrt  zØ
                def __reduce_cython__(self):
                    raise TypeError, "%(msg)s"
                def __setstate_cython__(self, __pyx_state):
                    raise TypeError, "%(msg)s"
                ÚmsgrJ  rK  z; z__pyx_result.z = __pyx_state[Ú]rî  rÈ   rÇ   Ú__pyx_unpickle_ÚUpdateUnpickledDictzExtensionTypes.czõ
                cdef extern from *:
                    int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1
                    int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1

                def z£(__pyx_type, long __pyx_checksum, tuple __pyx_state):
                    cdef object __pyx_result
                    __Pyx_CheckUnpickleChecksum(__pyx_checksum, z, zUTF-8z%)
                    __pyx_result = z].__new__(__pyx_type)
                    if __pyx_state is not None:
                        z__set_state(<z[> __pyx_result, __pyx_state)
                    return __pyx_result

                cdef z__set_state(z8 __pyx_result, __pyx_state: tuple):
                    zJ
                    __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, Údz)
            ÚCheckUnpickleChecksumr§   c              3   ó&   K  — | ]	  }d |› �–— Œ y­w)úself.Nr"   )rm  rÙ  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>	  s   è ø€ ÐGÑ5F° %¨ s¤Ñ5Fùs   ‚r   rm  z or r}  z is not NoneÚFalsezÁ
                def __reduce_cython__(self):
                    cdef tuple state
                    cdef object _dict
                    cdef bint use_setstate
                    state = (a	  )
                    _dict = getattr(self, '__dict__', None)
                    if _dict is not None and _dict:
                        state += (_dict,)
                        use_setstate = True
                    else:
                        use_setstate = zE
                    if use_setstate:
                        return z, (type(self), r   zH, None), state
                    else:
                        return zZ, state)

                def __setstate_cython__(self, __pyx_state):
                    z+__set_state(self, __pyx_state)
            ))rX  rÉ  rÃ  rî  r4  r  rc  rò  rä  ÚsortÚis_pyobjectÚcan_coerce_to_pyobjectÚcan_coerce_from_pyobjectÚis_struct_or_unionr„  r   rL   r   r?   Ú
substituterW  r$  rO   rM   r¶   Úcreate_to_py_utility_codeÚcreate_from_py_utility_coderx   rZ  Ú_calculate_pickle_checksumsrÏ   Úpunycode_class_nameÚuse_utility_coder   ÚUtilityCodeÚload_cachedÚencoder@  rV  Úenter_scopeÚ
exit_scope)r$   r%   r5  Úauto_pickle_forcedÚall_membersr6  ÚcinitÚinherited_reducer¿   Únon_pyÚstructsrv  Úpickle_funcÚall_members_namesÚixrÙ  ÚassignmentsÚ	checksumsÚunpickle_func_nameÚnum_membersÚunpickle_codeÚunpickle_funcÚmembersÚany_notnone_membersÚpickle_codes                            r&   rf  z3AnalyseDeclarationsTransform._inject_pickle_methodsª  sø  € Ø×ÑÓ ˆØ�:‰:× Ñ  Ñ/°5Ñ8àØ!ŸZ™Z×2Ñ2°=ÑAÀTÐIÐàˆØ�j‰j�o‰oˆØˆØÐØˆoØ×ÑÑm¨#¯)©)×*?Ò*?ÓmÔmØÒ:˜SŸY™Y×-Ñ-¨kÓ:ˆEØ/Òv°3·9±9×3CÑ3CÀLÓ3QÒvÐUX×U^ÑU^×UeÑUeÐfuÓUvÐØ—-‘-ˆCð	 ‰oð
 	×ÑÑ-ÐÔ.áð ñ #ó
Ù"�!Ø—6‘6×%Ò%¨q¯v©v×/LÑ/LÈSÔ/QØ23·&±&×2QÑ2QÐRUÔ2Vò �{ð 	ð 
ñ *ÓG™k˜¨Q¯V©V×-FÓ-F’1˜kˆÐGá‘F™wÑ/AÙàJ‘ÙØNÐQT×QYÑQYÑY}Ñv|ÓY}ÓQ}Ñ}‘ð
1Ø36·8±8Ñ;`ÑX_Ó;`Ó3`ña�ñ "Ü�d—h‘h Ô$ä&ð (ð
 ˜c�lñ(#ð  ¬=¸Ó+>Ð*?ôA÷ BLÁÈBÃð ð ×,Ñ,¨T¯Z©ZÔ8Ø�J‰J�{Ô#Ø�I‰I�O‰O×"Ñ" ;Õ/ó !�Ø—v‘v×)Ó)Ø—F‘F×4Ñ4°SÔ9Ø—F‘F×6Ñ6°sÕ;ð !ñ
 2=Ó =±¨A §£°ÐÐ =ØŸ)™)ä&Ð'8Ô9ô%á9‘E�B™ò 89º"Ò=Ø9ò%ó ˆKô 4Ð4EÓFˆIÜ�9‹~ Ò"à&¨)°B©-¸!Ñ*;Ð)<Ñ<¸b¸qÐA�	à#2°4×3KÑ3KÐ2LÐ!MÐÜÐ/Ó0ˆKà× Ñ ¤×!1Ñ!1×!=Ñ!=Ð>SÐUgÓ!hÔið!ð
 (Ð(ð )AàAEÇÁÈ9ÓAUÐ@VÐVXÐY]×YbÑYbÐctÓYu×Y|ÑY|ð  ~Eó  ZFð  YIð I$Ø$(§O¡OÐ#4ð 5à+Ð,¨M¸$¿/¹/Ð9Jð Kð )Ð)¨°d·o±oÐ5Fð GØ �Mð "JØJUÐVWÈð YðˆMð$ × Ñ ¤×!1Ñ!1×!=Ñ!=Ð>UÐWiÓ!jÔkä(¨¸hÔR_Ð`dÓReÐQfÔg×rÑrÐsuÓvˆMØ×.Ñ.¨t¯z©z×/?Ñ/?Ô@à�J‰J�}Ô%Ø×*Ñ*×1Ñ1°-Ô@à—i‘iÑGÑ5FÓGÓGÔRUÐVgÓRhÐlmÒRmÉ3ÐsuÑvˆGà"(§+¡+ÑU`Ó.wÑU`ÐPQÐde×djÑdj×dvÓdv°°q·v±v°h¸lÒ/KÐU`Ñ.wò  /Eð  }Dð  |Eó  #FÐðð
 &˜Yð '(ð )<Ð'<ð = à 2Ð3°?À9ÈQÁ<À.ð Q à 2Ð3°?À9ÈQÁ<À.ð Qð (Ð(ð )ð%ˆKô* ' {¸)Ì}Ð]aÓObÐNcÔd×oÑoÐprÓsˆKØ×,Ñ,¨T¯Z©ZÔ8à×Ñ˜T 4§:¡:Ô.Ø�J‰J�{Ô#Ø�O‰OÔØ�I‰I�O‰O×"Ñ" ;Õ/ùòg
ùò HùòF !>ùó%ùòX /xs+   ÄAWÅ1WÆWËWË5W
ÓW!Ó+W!c                 ón  — g }|D ]U  }|j                   }|j                  r*|j                  dvs|j                  |j                  «      sŒE|j	                  |«       ŒW |rVt        | j                  «      }|j                  }|j                  |||j                  «      \  }	}
|
j                  |«       ||
g}|S )zd
        Create function calls to the decorators and reassignments to
        the function.
        )r¼  rB  )
rZ  r  rx   rè  r¶   rø  rG   r%   r  rW  )r$   Úold_decoratorsr5  r%   rX  rZ  r  Ú	transformr…   rÛ   Úreassignmentss              r&   Ú_handle_fused_def_decoratorsz9AnalyseDeclarationsTransform._handle_fused_def_decorators7	  s©   € ð ˆ
Û'ˆIØ×&Ñ&ˆDØ—L’LØ—I‘IÐ%DÑDØ—O‘O D§I¡IÕ.à×!Ñ! )Õ,ð (ñ Ü*¨4¯<©<Ó8ˆIØ—y‘yˆHØ(×9Ñ9Ø˜* h§m¡mó 5ÑˆAˆ}à×.Ñ.¨sÔ3Ø˜-Ð(ˆDàˆr)   c                 ó"  — |j                   j                  d|j                  «       | j                  |d«       |j	                  |«       d|j                  j
                  j                  _        t        j                  j                  |j                  d¬«      }t        j                  |j                  |«      «      }||_        | j                  |j                  t        j                  |«      |«      |_        |r| j#                  |||«      }|S )z#Handle def or cpdef fused functionsr   Úpy_funcFT)Úbinding)rM   Úinsertr§  r  Úupdate_fused_defnode_entryrî  Ú	signatureÚuse_fastcallr   ÚPyCFunctionNodeÚfrom_defnoderµ  Úcoerce_to_tempÚresulting_fused_functionÚ_create_assignmentr¶  Úfused_func_assignmentr¥  )r$   rX  r5  r%   Úpycfuncs        r&   Ú_handle_defz(AnalyseDeclarationsTransform._handle_defQ	  sÙ   € ð 	�
‰
×Ñ˜!˜TŸ\™\Ô*Ø�‰˜˜iÔ(Ø×'Ñ'¨Ô,à49ˆ�‰×Ñ×$Ñ$Ô1Ü×+Ñ+×8Ñ8¸¿¹ÈtÐ8ÓTˆÜ×%Ñ% g×&<Ñ&<¸SÓ&AÓBˆØ(/ˆÔ%à%)×%<Ñ%<Ø�L‰Lœ)×-Ñ-¨gÓ6¸ó&=ˆÔ"ñ Ø×4Ñ4°ZÀÀdÓKˆDàˆr)   c                 óÈ  — ddl m} | j                  s| j                  ræ| j                  | j                  vr9| j                  rt        |j                  d«       nt        |j                  d«       | j                  j                  | j                  «       t        j                  |j                  «      |_
        |j                  D ];  }|j                  j                  sŒ|j                  j                  «       d   |_        Œ= |S t        |dd«      }|j!                  ||«      }|| _        | j#                  |«       d| _        |j$                  r| j'                  |||«      }|S )z:Create a fused function for a DefNode with fused argumentsr   )Ú	FusedNodezFused lambdas not allowedzCannot nest fused functionsr   rX  N)rm  r¶  Úfused_functionrZ  rO  r   rL   rF  r   re   rO   ry   r4  rD  Úget_fused_typesr-  ÚFusedCFuncDefNoder8   r§  r´  )r$   r5  r%   r¶  rá   rX  s         r&   Ú_create_fused_functionz3AnalyseDeclarationsTransform._create_fused_functione	  s  € åà×Ò $§.¢.Ø×"Ñ"¨$×*@Ñ*@Ñ@Ø—>’>Ü˜$Ÿ(™(Ð$?Õ@ä˜$Ÿ(™(Ð$AÔBà×"Ñ"×&Ñ& t×':Ñ':Ô;ä×*Ñ*¨4¯8©8Ó4ˆDŒIØ—y”y�Ø—8‘8×$Ó$Ø"Ÿx™x×7Ñ7Ó9¸!Ñ<�C•Hð !ð ˆKä˜T <°Ó6ˆ
Ø×*Ñ*¨4°Ó5ˆØ"ˆÔØ×Ñ˜4Ô Ø"ˆÔØ�<Š<Ø×#Ñ# J°°TÓ:ˆDàˆr)   c                 óä   — |j                   rY|j                  rMt        |j                  d«       d|_        t	        j
                  |j                  g ¬«      |j                  _        |j                  S )NzFused generators not supportedFrÊ   )Úis_generatorÚhas_fused_argumentsr   rL   r   rP   rñ  rO   r#   s     r&   Ú_handle_fusedz*AnalyseDeclarationsTransform._handle_fusedƒ	  sR   € Ø×Ò ×!9Ò!9Ü�$—(‘(Ð<Ô=Ø',ˆDÔ$Ü#×0Ñ0°·±ÀÔDˆD�J‰JŒOà×'Ñ'Ð'r)   c                 ó$  — | j                  «       }| j                  j                  t        «       «       |j                  }|j                  |«       |j                  j                  «       D ]“  \  }}|j                  |«      rŒ|j                  |«      }|r3|j                  r'|j                  r|j                  |j                  «      }|r|j                  |||j                  «       Œ~t        |j                  d«       Œ• | j!                  |«      r| j#                  ||«      }n,|j$                  j'                  |«       | j)                  |«      }| j                  j+                  «        d|j,                  v rddlm} |j3                  |«      S |S )aÒ  
        Analyse a function and its body, as that hasn't happened yet.  Also
        analyse the directive_locals set by @cython.locals().

        Then, if we are a function with fused arguments, replace the function
        (after it has declared itself in the symbol table!) with a
        FusedCFuncDefNode, and analyse its children (which are in turn normal
        functions). If we're a normal function, just analyse the body of the
        function.
        ú
Not a typerU  r   )ÚUFuncs)rX  rN  r¶   r)  rç  Údeclare_argumentsrK  r\  rè  Úanalyse_as_typerD  Úfused_to_specificÚ
specializeÚdeclare_varrL   r   r¾  rº  rO   rW  rP  r  rÃ  rm  rÁ  Úconvert_to_ufunc)r$   r%   r5  ÚlenvÚvarÚ	type_noder4  rÁ  s           r&   r  z.AnalyseDeclarationsTransform.visit_FuncDefNode‹	  sE  € ð ×ÑÓ ˆà×Ñ×#Ñ#¤C£EÔ*Ø×ÑˆØ×Ñ˜tÔ$ð #×3Ñ3×9Ñ9Ö;‰NˆC�Ø×#Ñ# CÕ(Ø ×0Ñ0°Ó6�Ù˜DŸMšM¨d×.DÒ.DØŸ?™?¨4×+AÑ+AÓB�DÙØ×$Ñ$ S¨$°	·±Õ>ä˜)Ÿ-™-¨Õ6ð <ð ×Ñ˜dÔ#Ø×.Ñ.¨s°DÓ9‰Dà�I‰I×*Ñ*¨4Ô0Ø×0Ñ0°Ó6ˆDà×Ñ× Ñ Ô"à�d—o‘oÑ%Ý Ø×*Ñ*¨4Ó0Ð0Øˆr)   c                 ó€  — | j                  |«      }t        |t        j                  «      s|S | j	                  «       }|j
                  €5t        j                  |«      |_        |j
                  j                  |«       |j                  s|j                  r|S |j                  |«      s|S || j                  ||«      gS r!   )r  rN   r   r„   rX  Úcode_objectr   ÚCodeObjectNoderW  Úfused_py_funcÚis_generator_bodyÚneeds_assignment_synthesisÚ_synthesize_assignment©r$   r%   r5  s      r&   r  z*AnalyseDeclarationsTransform.visit_DefNode´	  s§   € Ø×%Ñ% dÓ+ˆÜ˜$¤§¡Ô.ØˆKØ×ÑÓ ˆØ×ÑÐ#Ü(×7Ñ7¸Ó=ˆDÔØ×Ñ×1Ñ1°#Ô6Ø×Ò ×!7Ò!7ØˆKØ×.Ñ.¨sÔ3ØˆKØ�d×1Ñ1°$¸Ó<Ð=Ð=r)   c                 óî   — |j                   €Y|j                  €Mt        j                  j	                  |«      |_         |j                   j                  | j                  «       «       | j                  |«      S r!   )rÌ  r§  r   rÍ  Ú	for_cfuncrW  rX  r  r#   s     r&   r  z/AnalyseDeclarationsTransform.visit_CFuncDefNodeÂ	  s^   € Ø×ÑÐ#¨¯©Ð(<Ü(×7Ñ7×AÑAÀ$ÓGˆDÔØ×Ñ×1Ñ1°$×2BÑ2BÓ2DÔEØ×%Ñ% dÓ+Ð+r)   c                 ó$   — | j                  |«      S r!   )r  r#   s     r&   Úvisit_GeneratorBodyDefNodez7AnalyseDeclarationsTransform.visit_GeneratorBodyDefNodeÈ	  s   € Ø×%Ñ% dÓ+Ð+r)   c                 ó^   — | j                  |«      }|j                  |j                  _        |S r!   )r  rÌ  rñ  )r$   r%   rà   s      r&   Úvisit_GeneratorDefNodez3AnalyseDeclarationsTransform.visit_GeneratorDefNodeË	  s)   € à×#Ñ# DÓ)ˆà!%×!1Ñ!1ˆ�
‰
ÔØˆr)   c                 óÄ  — |}|j                   s|j                  r&|j                  }|j                   rŒ|j                  rŒ&|j                   xs | j                  j	                  d«      }|j
                  r(t        j                  j                  ||«      x}|_	        n t        j                  j                  ||«      }|j                  |_        | j                  |||«      S )Nr¨  )Úis_py_class_scopeÚis_c_class_scopeÚouter_scopeÚcurrent_directivesr³   Úis_closure_scoper   ÚInnerFunctionNoder®  Úpy_cfunc_noder­  r¨  Úis_cyfunctionr±  )r$   r%   r5  Úgenvr¨  rª   s         r&   rÑ  z3AnalyseDeclarationsTransform._synthesize_assignmentÒ	  s½   € àˆØ×$Ò$¨×(=Ò(=Ø×#Ñ#ˆDð ×$Ó$¨×(=Ó(=ð ×'Ñ'ÒQ¨4×+BÑ+B×+FÑ+FÀyÓ+QˆØ× Ò Ü'0×'BÑ'B×'OÑ'OÐPTÐV]Ó'^Ð^ˆC�$Õ$ä×+Ñ+×8Ñ8¸¸wÓGˆCà Ÿ[™[ˆÔØ×&Ñ& t¨S°#Ó6Ð6r)   c                 ól  — |j                   rK|j                   d d d…   D ]/  }t        j                  |j                  |j                  |g¬«      }Œ1 d |_         t        j                  |j                  t        j                  |j                  |j                  ¬«      |¬«      }|j                  |«       |S )NrÈ   r%  r¨   rÉ   )
rX  r   rp  rL   rZ  r   r·   r¸   rx   rW  )r$   r…   rª   r5  rZ  Úassmts         r&   r±  z/AnalyseDeclarationsTransform._create_assignmentá	  sš   € Ø×ÒØ%×0Ñ0±°2°Ô6�	Ü×.Ñ.Ø—M‘MØ(×2Ñ2Ø˜5ô"‘ð 7ð
 #'ˆHÔä×*Ñ*Ø�L‰LÜ×"Ñ" 8§<¡<°h·m±mÔDØôˆð 	×"Ñ" 3Ô'Øˆr)   c                 óŽ   •— | j                   j                  «       }t        ‰| �  |«       | j                   j	                  |«       y r!   )rN  r  rB   Úvisit_func_outer_attrsr¶   )r$   r%   ÚstackrH   s      €r&   ræ  z3AnalyseDeclarationsTransform.visit_func_outer_attrsñ	  s8   ø€ à×$Ñ$×(Ñ(Ó*ˆÜ‰Ñ& tÔ,Ø×Ñ×#Ñ# EÕ*r)   c                 óî  — | j                  «       }|j                  |«       |j                  r¥| j                  j	                  t        | j                  d   «      «       | j                  ||j                  «       |j                  |j                  «       | j                  |«       | j                  «        | j                  j                  «        |S |j                  |«       | j                  |«       |S rT  )rX  rW  Ú
expr_scoperN  r¶   r)  r�  Úanalyse_scoped_declarationsr8   rŽ  r  rÒ  s      r&   Úvisit_ScopedExprNodez1AnalyseDeclarationsTransform.visit_ScopedExprNode÷	  sÃ   € Ø×ÑÓ ˆØ×!Ñ! #Ô&à�?Š?Ø× Ñ ×'Ñ'¬¨D×,@Ñ,@ÀÑ,DÓ(EÔFØ×Ñ˜T 4§?¡?Ô3Ø×,Ñ,¨T¯_©_Ô=Ø×Ñ˜tÔ$Ø�O‰OÔØ× Ñ ×$Ñ$Ô&ð
 ˆð ×,Ñ,¨SÔ1Ø×Ñ˜tÔ$Øˆr)   c                 óf   — | j                  |«       |j                  | j                  «       «       |S r!   ©r8   rW  rX  r#   s     r&   Úvisit_TempResultFromStatNodez9AnalyseDeclarationsTransform.visit_TempResultFromStatNode
  ó,   € Ø×Ñ˜4Ô Ø×!Ñ! $×"2Ñ"2Ó"4Ô5Øˆr)   c                 óD   — |j                   dk(  ry | j                  |«      S r5   )r7   r`  r#   s     r&   r9   z/AnalyseDeclarationsTransform.visit_CppClassNode
  s"   € Ø�?‰?˜hÒ&Øà×*Ñ*¨4Ó0Ð0r)   c                  ó   — 	 y r!   )*r   r#  rL   r¸   r   rî  r4  rÉ  rc  r¶   rx   rr  Úinit_assignmentr„  rÏ   Ústruct_or_union_wrapperr   rP   r  Ú	is_structrº  rn  ÚreplacerM   r@  ÚshadowrO   rN   rä  ÚCSimpleBaseTypeNoder„   ry   Úkw_onlyr   rÀ  rã  r€  Úbasic_pyobject_propertyÚbasic_propertyrW  rX  r‹  )r$   r%   Ú
self_valuerc  Ú
attributesrî  Úinit_assignmentsÚattrÚ
str_formatÚwrapper_classÚ
class_bodyÚinit_methodÚarg_templaterá   Útemplater  s                   r&   r3   z8AnalyseDeclarationsTransform.visit_CStructOrUnionDefNode
  s
   € ð Ør)   c                 ó(   — | j                  |«       |S r!   r  r#   s     r&   r-   z2AnalyseDeclarationsTransform.visit_CDeclaratorNodei
  s   € à×Ñ˜4Ô Øˆr)   c                 ó   — |S r!   r"   r#   s     r&   r'   z/AnalyseDeclarationsTransform.visit_CTypeDefNoden
  r(   r)   c                  ó   — y r!   r"   r#   s     r&   r/   z0AnalyseDeclarationsTransform.visit_CBaseTypeNodeq
  s   € Ør)   c                 ó&   — |j                   dk(  r|S y )NÚpublic)r7   r#   s     r&   r1   z/AnalyseDeclarationsTransform.visit_CEnumDefNodet
  s   € Ø�?‰?˜hÒ&ØˆKàr)   c                 óD  — |j                   | j                  d   v rs| j                  «       j                  |j                   «      }|�%|j                  dk7  r9|j
                  j                  s#t        |j                  d|j                   z  «       | j                  |«       |S )NrÈ   r6   z,cdef variable '%s' declared after it is used)
rx   rN  rX  rò  r7   rÉ  rÛ  r   rL   r8   ©r$   r%   rî  s      r&   Úvisit_CNameDeclaratorNodez6AnalyseDeclarationsTransform.visit_CNameDeclaratorNodez
  sƒ   € Ø�9‰9˜×,Ñ,¨RÑ0Ñ0Ø×$Ñ$Ó&×-Ñ-¨d¯i©iÓ8ˆEØ� ×!1Ñ!1°XÒ!=Ø!ŸK™K×8Ò8Ü�d—h‘hÐ NÐQU×QZÑQZÑ ZÔ[Ø×Ñ˜4Ô Øˆr)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   r+   z.AnalyseDeclarationsTransform.visit_CVarDefNodeƒ
  s   € à×Ñ˜4Ô Ør)   c                 óx   — | j                  |d«      }|sy t        |«      t        u r|d   |_        |g|dd  z   S |S )Nr%   r   r   )r  r4  rN  r%   )r$   r%   Ú
child_nodes      r&   Úvisit_CnameDecoratorNodez5AnalyseDeclarationsTransform.visit_CnameDecoratorNodeˆ
  sH   € Ø—_‘_ T¨6Ó2ˆ
ÙØÜ�
ÓœtÑ#Ø" 1™ˆDŒIØ�6˜J q r˜NÑ*Ð*Øˆr)   c           
      óè  — |j                   dk(  r0|j                  j                  r| j                  }n(| j                  }n|j                   dk(  r| j
                  }j                  dt        j                  |j                  t        j                  |j                  d¬«      |j                  ¬«      i|j                  ¬«      j                  d   }|j                  |_        |j                  |_        |S )	Nr	  ÚreadonlyÚATTRr$   rá  )rL   r¢  rŒ  )rL   r   )r7   r4  r€  rù  rú  Úbasic_property_ror„  r   r#  rL   r¸   rx   rM   r|   )r$   rî  r  r  s       r&   re  z,AnalyseDeclarationsTransform.create_Property‘
  sÍ   € Ø×Ñ˜xÒ'Ø�z‰z×%Ò%Ø×7Ñ7‘à×.Ñ.‘Ø×Ñ Ò+Ø×-Ñ-ˆHØ×&Ñ&àœ	×/Ñ/°E·I±IÜ4=×4FÑ4FÈ5Ï9É9Ð[aÔ4bØ:?¿*¹*ôFðð
 —	‘	ð 'ó 
÷ ‰%�ñˆð Ÿ
™
ˆŒØ—y‘yˆŒØˆr)   c                 óf   — | j                  |«       |j                  | j                  «       «       |S r!   rí  r#   s     r&   r<  z;AnalyseDeclarationsTransform.visit_AssignmentExpressionNode¥
  rï  r)   ),r:   r;   r<   r   r?   rú  rù  r  ró  rò  r·  rZ  r†  r  rQ   r‡   r‹  rf  r¥  r´  rº  r¾  r  r  r  rÖ  rØ  rÑ  r±  ræ  rë  rî  r9   r3   r-   r'   r/   r1   r  r+   r  re  r<  ri   rj   s   @r&   rI  rI  H  sL  ø„ á!ð #ð ¡M°$Ó$7Ð#8ô:€Nñ +ð ,ð ¡M°$Ó$7Ð#8ô:Ðñ %ð &ð ¡M°$Ó$7Ð#8ô	:Ðñ +ð ,ñ ! Ó&Ð'ô)Ðñ #ð $ñ ! Ó&Ð'ô	)€Oð €NØ€Iô*òòòòò*K0òZò4ò(ò<(ò'òR>ò,ò,òò7òô +òò"ò
1òP7òlò
òòòòò
òö(r)   rI  c                 ó2  — dj                  | «      j                  d«      }t        j                  dk\  rddini }g }dD ]A  }	 t	        t
        |«      } ||fi |¤Žj                  «       }|j                  d|d d z   «       ŒC |S # t        t        f$ r Y ŒWw xY w)	NÚ zutf-8)rî  é	   ÚusedforsecurityF)Úsha256Úsha1Úmd5Ú0xrö  )
r„  rŒ  r   Úversion_infor-  r   Ú	hexdigestÚAttributeErrorÚ
ValueErrorr¶   )Úmember_namesÚmember_names_stringÚhash_kwargsr™  Ú	algo_nameÚ
mkchecksumÚchecksums          r&   r‡  r‡  «
  s®   € ð Ÿ(™( <Ó0×7Ñ7¸Ó@ÐÜ03×0@Ñ0@ÀFÒ0JÐ$ eÑ,ÐPR€KØ€IÛ.ˆ	ð	Ü ¤¨)Ó4ˆJÙ!Ð"5ÑE¸ÑE×OÑOÓQˆHð 	×Ñ˜ ¨¨! Ñ,Õ-ð /ð Ðøô	 ¤
Ð+ò 	áð	ús   Á'BÂBÂBc                   óh   ‡ — e Zd ZdZdZdZˆ fd„Zdd„Zd„ Zd„ Z	d„ Z
d„ Zd	„ Zd
„ Zd„ Zd„ Zd„ Zˆ xZS )Ú CalculateQualifiedNamesTransformz^
    Calculate and store the '__qualname__' and the global
    module name on some nodes.
    Fc                 óÎ   •— | j                  «       j                  | _        g | _        t        «       }|j                  | _        |j                  | _        | j                  |«       |S r!   )	Úglobal_scoperþ  rž  rB   r  rP  r`  Ú_super_visit_ClassDefNoder8   )r$   r%   Ú_superrH   s      €r&   rQ   z1CalculateQualifiedNamesTransform.visit_ModuleNodeÅ
  sX   ø€ Ø×,Ñ,Ó.×=Ñ=ˆÔØ ˆÔÜ“ˆØ(.×(@Ñ(@ˆÔ%Ø)/×)BÑ)BˆÔ&Ø×Ñ˜4Ô Øˆr)   c                 óÂ   — |r!| j                   d d  }|j                  |«       n| j                   }t        dj                  |«      «      |_        | j
                  |_        y )NrÎ  )rþ  r¶   r   r„  Úqualnamerž  )r$   r%   rx   r/  s       r&   Ú_set_qualnamez.CalculateQualifiedNamesTransform._set_qualnameÎ
  sO   € ÙØ×*Ñ*©1Ð-ˆHØ�O‰O˜DÕ!à×*Ñ*ˆHÜ% c§h¡h¨xÓ&8Ó9ˆŒØ×+Ñ+ˆÕr)   c                 ó¤   — |j                   r|j                  s|j                  g| _        y | j                  j	                  |j                  «       y r!   )Úis_pyglobalÚis_pyclass_attrrx   rþ  r¶   )r$   rî  s     r&   Ú_append_entryz.CalculateQualifiedNamesTransform._append_entry×
  s9   € Ø×Ò U×%:Ò%:Ø#(§:¡: ,ˆDÕà×Ñ×&Ñ& u§z¡zÕ2r)   c                 ó`   — | j                  ||j                  «       | j                  |«       |S r!   )r0  rx   r8   r#   s     r&   Úvisit_ClassNodez0CalculateQualifiedNamesTransform.visit_ClassNodeÝ
  s)   € Ø×Ñ˜4 §¡Ô+Ø×Ñ˜4Ô Øˆr)   c                 óJ   — | j                  |«       | j                  |«       |S r!   )r0  r8   r#   s     r&   Úvisit_PyClassNamespaceNodez;CalculateQualifiedNamesTransform.visit_PyClassNamespaceNodeâ
  s#   € à×Ñ˜4Ô Ø×Ñ˜4Ô Øˆr)   c                 ó`  — | j                   d d  }|j                  j                  rJ| j                   r>| j                   d   dk(  r,| j                   j                  «        | j	                  |«       n&| j	                  ||j                  j
                  «       | j                  |«       || _         |S ©NrÈ   ú<locals>)rþ  r…   Ú
is_wrapperr  r0  rx   r8   ©r$   r%   Úorig_qualified_names      r&   Úvisit_PyCFunctionNodez6CalculateQualifiedNamesTransform.visit_PyCFunctionNodeè
  s‘   € Ø"×1Ñ1±!Ð4ÐØ�=‰=×#Ò#¨×(;Ò(;À×@SÑ@SÐTVÑ@WÐ[eÒ@eØ×Ñ×#Ñ#Ô%Ø×Ñ˜tÕ$à×Ñ˜t T§]¡]×%7Ñ%7Ô8Ø×Ñ˜4Ô Ø1ˆÔØˆr)   c                 ó~  — |j                   rƒ| j                  rw| j                  d   dk(  sJ | j                  «       ‚| j                  d d  }| j                  j                  «        | j                  |«       | j	                  |«       || _        |S | j                  ||j
                  «       | j                  |«       |S r:  )r<  rþ  r  r0  rP  rx   r  r=  s      r&   r  z.CalculateQualifiedNamesTransform.visit_DefNodeó
  s¬   € Ø�?Š?˜t×2Ò2Ø×&Ñ& rÑ*¨jÒ8ÐM¸$×:MÑ:MÓMÐ8Ø"&×"5Ñ"5±aÐ"8ÐØ×Ñ×#Ñ#Ô%Ø×Ñ˜tÔ$Ø×)Ñ)¨$Ô/Ø"5ˆDÔð ˆð ×Ñ˜t T§Y¡YÔ/Ø×"Ñ" 4Ô(Øˆr)   c                 ó  — | j                   d d  }t        |dd «      dk(  r| j                   j                  d«       n| j                  |j                  «       | j                   j                  d«       | j                  |«       || _         |S )Nrx   z<lambda>r;  )rþ  r-  r¶   r4  rî  rP  r=  s      r&   r  z2CalculateQualifiedNamesTransform.visit_FuncDefNode   sy   € Ø"×1Ñ1±!Ð4ÐÜ�4˜ Ó&¨*Ò4Ø×Ñ×&Ñ& zÕ2à×Ñ˜tŸz™zÔ*Ø×Ñ×"Ñ" :Ô.Ø×%Ñ% dÔ+Ø1ˆÔØˆr)   c                 óš  — |j                   j                  |«      }t        j                  |j                  t        |«      |d¬«      }t        j                  |j                  |¬«      }|j                  j                  j                  dt        j                  |j                  ||¬«      j                  | j                  «       «      «       y )NT)rx   rî  Ú	is_targetrv   r   rÉ   )rÉ  rè  r   r¸   rL   r   rn  rO   rM   r©  r   r·   Úanalyse_expressionsrX  )r$   r%   rx   rw   rî  r©   rª   s          r&   Úgenerate_assignmentz4CalculateQualifiedNamesTransform.generate_assignment  s›   € Ø—
‘
×&Ñ& tÓ,ˆÜ× Ñ Ø�H‰HÜ˜tÓ$ØØô	ˆô
 ×#Ñ# D§H¡H°EÔ:ˆØ�	‰	�‰×Ñ˜q¤%×"<Ñ"<Ø�H‰HØØô#
÷ Ñ
˜d×.Ñ.Ó0Ó
1õ		3r)   c           	      óH  — | j                   }d| _         | j                  }d| _        | j                  d d  }t        |dd «      xs3 | j	                  «       j                  |j                  j                  «      }| j                  |«       | j                  |«       | j                   r5| j                  |dt        dj                  | j                  «      «      «       | j                  r&| j                  |dt        | j                  «      «       || _        || _         || _        |S )NFrî  r<   rÎ  r;   )Úneeds_qualname_assignmentÚneeds_module_assignmentrþ  r-  rX  rè  ré   rx   r4  r,  rE  r   r„  rž  )r$   r%   Úorig_needs_qualname_assignmentÚorig_needs_module_assignmentr>  rî  s         r&   r`  z3CalculateQualifiedNamesTransform.visit_ClassDefNode  s	  € Ø)-×)GÑ)GÐ&Ø).ˆÔ&Ø'+×'CÑ'CÐ$Ø',ˆÔ$Ø"×1Ñ1±!Ð4ÐÜ˜˜w¨Ó-ò BØ×!Ñ!Ó#×/Ñ/°·±×0@Ñ0@ÓAð 	à×Ñ˜5Ô!Ø×&Ñ& tÔ,Ø×)Ò)Ø×$Ñ$ T¨>Ü%2°3·8±8¸D×<OÑ<OÓ3PÓ%QôSà×'Ò'Ø×$Ñ$ T¨<Ü%2°4×3CÑ3CÓ%DôFà1ˆÔØ)GˆÔ&Ø'CˆÔ$Øˆr)   c                 óš   — | j                  «       }|j                  r.|j                  dk(  r	d| _        |S |j                  dk(  rd| _        |S )Nr<   Tr;   )rX  rÛ  rx   rG  rH  )r$   r%   rÉ  s      r&   r  z/CalculateQualifiedNamesTransform.visit_NameNode.  sQ   € Ø× Ñ Ó"ˆØ×!Ò!ð �y‰y˜NÒ*Ø15�Ô.ð ˆð —‘˜lÒ*Ø/3�Ô,Øˆr)   r!   )r:   r;   r<   r=   rG  rH  rQ   r0  r4  r6  r8  r?  r  r  rE  r`  r  ri   rj   s   @r&   r)  r)  ½
  sM   ø„ ñð !&ÐØ#Ðôó,ò3òò
ò	òò	ò3òö*r)   r)  c                   ó6   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	y)	ÚAnalyseExpressionsTransformc                 óø   — |j                   j                  «        |j                  j                  |j                   «      |_        |j                  hg| _        | j                  |«       | j                  |«       |S r!   )rÉ  Úinfer_typesrO   rD  rL   Ú	positionsr8   Ú_build_positionsr#   s     r&   rQ   z,AnalyseExpressionsTransform.visit_ModuleNode?  s\   € Ø�
‰
×ÑÔ Ø—I‘I×1Ñ1°$·*±*Ó=ˆŒ	ØŸ8™8˜*˜ˆŒØ×Ñ˜4Ô Ø×Ñ˜dÔ#Øˆr)   c                 óª  — |j                   j                  «        |j                  j                  |j                   «      |_        | j                  d   j                  |j                  «       |j                  r| j                  d   }n|j                  h}| j                  j                  |«       | j                  |«       | j                  |«       |S rT  )rç  rO  rO   rD  rP  rF  rL   r<  r¶   r8   rQ  )r$   r%   Úlocal_positionss      r&   r  z-AnalyseExpressionsTransform.visit_FuncDefNodeG  sž   € Ø×Ñ×$Ñ$Ô&Ø—I‘I×1Ñ1°$×2BÑ2BÓCˆŒ	Ø�‰�rÑ×Ñ˜tŸx™xÔ(à�?Š?à"Ÿn™n¨RÑ0‰Oà#Ÿx™x˜jˆOØ�‰×Ñ˜oÔ.à×Ñ˜4Ô Ø×Ñ˜dÔ#Øˆr)   c                 óª   — |j                   r5|j                  j                  «        |j                  |j                  «      }| j	                  |«       |S r!   )r›   ré  rO  Úanalyse_scoped_expressionsrU   r#   s     r&   rë  z0AnalyseExpressionsTransform.visit_ScopedExprNodeW  sB   € Ø×ÒØ�O‰O×'Ñ'Ô)Ø×2Ñ2°4·?±?ÓCˆDØ×Ñ˜DÔ!Øˆr)   c                 ó„   — | j                  |«       |j                  r"|j                  j                  s|j                  }|S )a¾  
        Replace index nodes used to specialize cdef functions with fused
        argument types with the Attribute- or NameNode referring to the
        function. We then need to copy over the specialization properties to
        the attribute or name node.

        Because the indexing might be a Python indexing operation on a fused
        function, or (usually) a Cython indexing operation, we need to
        re-analyse the types.
        )rU   Úis_fused_indexr4  Úis_errorr°   r#   s     r&   Úvisit_IndexNodez+AnalyseExpressionsTransform.visit_IndexNode^  s5   € ð 	×Ñ˜DÔ!Ø×Ò t§y¡y×'9Ò'9Ø—9‘9ˆDØˆr)   c                 óx   — | j                   d   j                  |j                  «       | j                  |«       |S rT  ©rP  rF  rL   r8   r#   s     r&   rU   z*AnalyseExpressionsTransform.visit_ExprNodeq  ó0   € Ø�‰�rÑ×Ñ˜tŸx™xÔ(Ø×Ñ˜4Ô Øˆr)   c                 óx   — | j                   d   j                  |j                  «       | j                  |«       |S rT  r[  r#   s     r&   rX   z*AnalyseExpressionsTransform.visit_StatNodev  r\  r)   c                 ó‚  — t        | j                  j                  «       t        dd«      d¬«      }d}d}g }|D ])  \  }}}|j	                  |||||k(  r|n|dz   f«       ||}}Œ+ |j                  «        ||_        |j                  «        t        |«      D �	�
ci c]  \  }	}
|
|	“Œ
 c}
}	|j                  _	        yc c}
}	w )zg
        Build the PEP-626 line table and "bytecode-to-position" mapping used for CodeObjects.
        r   rÇ   T)r]  ÚreverserÈ   r   N)
rÞ  rP  r  r   r¶   r_  Únode_positionsrZ  rç  Únode_positions_to_offset)r$   Ú	func_noderP  Ú	next_lineÚnext_column_in_lineÚrangesrÛ   r×  Ústart_columnr_  Úpositions              r&   rQ  z,AnalyseExpressionsTransform._build_positions{  sÙ   € ô !Ø�N‰N×ÑÓ Ü˜1˜aÓ àô	
ˆ	ð ˆ	ØÐàˆÛ%.Ñ!ˆAˆt�\Ø�M‰M˜4  |ÈDÐT]ÒL]Ñ5HÐcoÐrsÑcsÐtÔuØ-1°<Ð*‰Ið &/ð 	�‰ÔØ#)ˆ	Ô à×ÑÔô  )¨Ô3ô:
á3‘��8ð �a‰KØ3ò:
ˆ	×ÑÕ6ùó :
s   ÂB;N)
r:   r;   r<   rQ   r  rë  rY  rU   rX   rQ  r"   r)   r&   rM  rM  =  s%   „ òòò òò&ò
ó

r)   rM  c                   ó$   — e Zd Zd„ Zd„ Zd„ Zd„ Zy)ÚFindInvalidUseOfFusedTypesc                 ó6   — d| _         | j                  |«       |S rA   )Ú_in_fused_functionr$  )r$   Útrees     r&   r†  z#FindInvalidUseOfFusedTypes.__call__Ÿ  s   € Ø"'ˆÔØ�
‰
�4ÔØˆr)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   r  z%FindInvalidUseOfFusedTypes.visit_Node¤  r   r)   c                 óö   — | j                   }|j                  | _         | j                   s8|j                  s,|j                  j                  rt        |j                  d«       | j                  |«       || _         y )Nz-Return type is not specified as argument type)rk  r½  rÏ  Úreturn_typerD  r   rL   r8   )r$   r%   Úouter_statuss      r&   r  z,FindInvalidUseOfFusedTypes.visit_FuncDefNode§  sb   € Ø×.Ñ.ˆØ"&×":Ñ":ˆÔà×&Ò&ð ×)Ò)¨d×.>Ñ.>×.GÒ.GÜ�d—h‘hÐ OÔPà×Ñ˜4Ô Ø".ˆÕr)   c                 ó°   — | j                   s9|j                  r-|j                  j                  rt        |j                  d«       y | j                  |«       y )Nz6Invalid use of fused types, type cannot be specialized)rk  r4  rD  r   rL   r8   r#   s     r&   rU   z)FindInvalidUseOfFusedTypes.visit_ExprNode´  s<   € Ø×&Ò&¨4¯9ª9¸¿¹×9KÒ9KÜ�$—(‘(ÐTÕUð ×Ñ˜tÕ$r)   N)r:   r;   r<   r†  r  r  rU   r"   r)   r&   ri  ri  �  s   „ òò
!ò/ó%r)   ri  c                   ó   — e Zd Zd„ Zd„ Zy)ÚExpandInplaceOperatorsc                 óÐ  ‡	— |j                   }|j                  }|j                  j                  r|S t	        |t
        j                  «      r|S | j                  «       }dˆ	fd„	Š		  ‰	|d¬«      \  }} |j                  di |j                  ¤Ž}t        j                  |j                  |j                  ||d¬«      }d|_        |j                  |«      }|j!                  |«       |j#                  |«       t%        j&                  |j                  ||j)                  |j                  |«      ¬«      }|j+                  «        |D ]  }t-        ||«      }Œ |S # t        $ r |cY S w xY w)Nc                 ó<  •— | j                   r| g fS | j                  j                  r|st        | «      } | | gfS | j                  rR ‰| j
                  «      \  }}t        | j                  «      }t        j                  | j                  ||¬«      ||gz   fS | j                  rE ‰| j                  |¬«      \  }}t        j                  | j                  || j                  ¬«      |fS t        | t        j                  «      rt!        d«      ‚t        | «      } | | gfS )N)r°   Úindex©Úsetting)r¢  rŒ  z@Don't allow things like attributes of buffer indexing operations)r  r4  r€  r
   Úis_subscriptr°   rv  r   Ú	IndexNoderL   r  r¢  r#  rŒ  rN   ÚBufferIndexNoder!  )r%   rx  r°   Útempsrv  r¢  Úside_effect_free_references         €r&   r}  zVExpandInplaceOperators.visit_InPlaceAssignmentNode.<locals>.side_effect_free_referenceÉ  sù   ø€ Ø�|Š|Ø˜R�x�Ø—‘×&Ò&©wÜ! $Ó'�Ø˜d˜V�|Ð#Ø×"Ò"Ù8¸¿¹ÓC‘��eÜ" 4§:¡:Ó.�Ü ×*Ñ*¨4¯8©8¸$ÀeÔLÈeÐW\ÐV]ÉoÐ]Ð]Ø×"Ò"Ù7¸¿¹È'ÔR‘
��UÜ ×.Ñ.¨t¯x©x¸SÈDÏNÉNÔ[Ð]bÐbÐbÜ˜D¤)×";Ñ";Ô<Ü Ð!cÓdÐdä! $Ó'�Ø˜d˜V�|Ð#r)   Trw  )r·  Úoperand1Úoperand2ÚinplacerÉ   rh   r"   )r©   rª   r4  Úis_cpp_classrN   r   r{  rX  r!  rH   rk  Ú
binop_noderL   r·  rC  Úanalyse_target_typesÚanalyse_typesÚanalyse_operationr   r·   Ú	coerce_tor_  r	   )
r$   r%   r©   rª   r5  Úlet_ref_nodesÚdupÚbinopÚtr}  s
            @r&   Úvisit_InPlaceAssignmentNodez2ExpandInplaceOperators.visit_InPlaceAssignmentNode¾  sD  ø€ Ø�h‰hˆØ�h‰hˆØ�8‰8× Ò àˆKÜ�cœ9×4Ñ4Ô5àˆKà×ÑÓ ˆõ	$ð$	Ù!;¸CÈÔ!NÑˆC�ð ˆc�m‰mÑ+˜cŸl™lÑ+ˆÜ×$Ñ$ T§X¡XØ04·±Ø03Ø03Ø-1ô	3ˆð ˆŒØ×&Ñ& sÓ+ˆØ×Ñ˜#ÔØ×Ñ Ô$Ü×)Ñ)Ø�H‰HØØ—‘ §¡¨#Ó.ô0ˆð
 	×ÑÔÛˆAÜ˜1˜dÓ#‰Dð àˆøô+ ò 	ØŠKð	ús   Á%E ÅE%Å$E%c                 ó   — |S r!   r"   r#   s     r&   rU   z%ExpandInplaceOperators.visit_ExprNodeô  rÅ  r)   N)r:   r;   r<   r‹  rU   r"   r)   r&   rs  rs  ¼  s   „ ò4ólr)   rs  c                   ó>   — e Zd ZdZdZd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zy
)ÚAdjustDefByDirectiveszÆ
    Adjust function and class definitions by the decorator directives:

    @cython.cfunc
    @cython.cclass
    @cython.ccall
    @cython.inline
    @cython.nogil
    @cython.critical_section
    )r‘   Útotal_orderingr\  c                 óX   — |j                   | _         d| _        | j                  |«       |S rA   )rÃ  Úin_py_classr8   r#   s     r&   rQ   z&AdjustDefByDirectives.visit_ModuleNode  s(   € ØŸ/™/ˆŒØ ˆÔØ×Ñ˜4Ô Øˆr)   c                 óp   — | j                   }|j                   | _         | j                  |«       || _         |S r!   rã  rä  s      r&   ræ  z2AdjustDefByDirectives.visit_CompilerDirectivesNode  s0   € ØŸ™ˆØŸ/™/ˆŒØ×Ñ˜4Ô Ø(ˆŒØˆr)   c           	      óT  — g }d| j                   v r|j                  d«       | j                   j                  d«      }| j                   j                  d«      }| j                   j                  d«      }|€dnd}| j                   j                  d«      }|€"| j                   d   r|j                  }|�|€d	}n
|€d |rdndf}| j                   j                  d
«      r$d| j                   vrt	        |j
                  d«       d| j                   v rdd| j                   v rt	        |j
                  d«       |rt	        |j
                  d«       |j                  d|||||¬«      }| j                  |«      S d| j                   v rL| j                  rt	        |j
                  d«       n)|j                  d||||||¬«      }| j                  |«      S d|v rt	        |j
                  d«       |rt	        |j
                  d«       |rt	        |j
                  d«       | j                  |«       |S )Nr�  rR  rS  r-  FTÚreturnsÚannotation_typingrS   Úc_compile_guardrT  z+c_compile_guard only allowed on C functionsÚccallz-cfunc and ccall directives cannot be combinedz-ccall functions cannot be declared 'with_gil')Úoverridabler”  rR  r”  Ú
except_valÚhas_explicit_exc_clausez#cfunc directive is not allowed here)r˜  r”  rR  rS  r”  r™  rš  z,Python functions cannot be declared 'inline'z+Python functions cannot be declared 'nogil'z.Python functions cannot be declared 'with_gil')
rÃ  r¶   r³   Úreturn_type_annotationr   rL   Úas_cfunctionr$  r‘  r  )r$   r%   r”  rR  rS  r™  rš  Úreturn_type_nodes           r&   r  z#AdjustDefByDirectives.visit_DefNode  s	  € Øˆ	Ø�t—‘Ñ&Ø×Ñ˜XÔ&Ø—‘×#Ñ# GÓ,ˆØ—?‘?×&Ñ& zÓ2ˆØ—_‘_×(Ñ(¨Ó5ˆ
Ø+5Ð+=¡%À4ÐØŸ?™?×.Ñ.¨yÓ9ÐØÐ#¨¯©Ð8KÒ(LØ#×:Ñ:ÐàÐ+°
Ð0BØ)‘
ØÐàÑ(8¡¸eÐDˆJØ�?‰?×ÑÐ0Ô1°gÀTÇ_Á_Ñ6TÜ�$—(‘(ÐIÔJØ�d—o‘oÑ%Ø˜$Ÿ/™/Ñ)Ü�d—h‘hÐ OÔPÙÜ�d—h‘hÐ OÔPØ×$Ñ$Ø ¨I¸UØ(°ZÐYpð %ó rˆDð —:‘:˜dÓ#Ð#Ø�d—o‘oÑ%Ø×ÒÜ�d—h‘hÐ EÕFà×(Ñ(Ø %°À%ÐRZØ,¸Ð]tð )ó v�ð —z‘z $Ó'Ð'Ø�yÑ Ü�$—(‘(ÐJÔKÙä�$—(‘(ÐIÔJÙÜ�$—(‘(ÐLÔMØ×Ñ˜tÔ$Øˆr)   c                 ó8  — d| j                   v rz| j                   d   }|�t        |j                  d«       t        j                  |j                  t        j                  |j                  |¬«      g|j                  ¬«      }||_        | j                  |«       |S )Nrg  z2critical_section decorator does not take arguments)rb  rt  )	rÃ  r   rL   r   ru  r   Ú#FirstArgumentForCriticalSectionNoderO   r8   )r$   r%   rw   Únew_bodys       r&   r  z'AdjustDefByDirectives.visit_FuncDefNodeB  s„   € Ø §¡Ñ0Ø—O‘OÐ$6Ñ7ˆEØÐ Ü�d—h‘hÐ TÔUÜ×4Ñ4Ø—‘Ü×CÑCÀDÇHÁHÐX\Ô]Ð^Ø—Y‘YôˆHð
 !ˆDŒIØ×Ñ˜4Ô Øˆr)   c                 ó   — |S r!   r"   r#   s     r&   r‡   z&AdjustDefByDirectives.visit_LambdaNodeP  rÅ  r)   c                 óÜ   ‡ — t        ˆ fd„‰ j                  D «       «      r!|j                  «       }‰ j                  |«      S ‰ j                  }d‰ _        ‰ j                  |«       |‰ _        |S )Nc              3   ó:   •K  — | ]  }|‰j                   v –— Œ y ­wr!   )rÃ  )rm  rÈ  r$   s     €r&   rn  z=AdjustDefByDirectives.visit_PyClassDefNode.<locals>.<genexpr>U  s   øè ø€ ÐUÑ=T°	ˆy˜DŸO™OÔ+Ñ=Tùs   ƒT)ÚanyÚconverts_to_cclassÚ	as_cclassr$  r‘  r8   ©r$   r%   Úold_in_pyclasss   `  r&   rP  z*AdjustDefByDirectives.visit_PyClassDefNodeT  s`   ø€ ÜÓU¸T×=TÒ=TÓUÔUØ—>‘>Ó#ˆDØ—:‘:˜dÓ#Ð#à!×-Ñ-ˆNØ#ˆDÔØ×Ñ˜tÔ$Ø-ˆDÔØˆKr)   c                 ó\   — | j                   }d| _         | j                  |«       || _         |S rA   )r‘  r8   r§  s      r&   r‹  z)AdjustDefByDirectives.visit_CClassDefNode_  s0   € Ø×)Ñ)ˆØ ˆÔØ×Ñ˜4Ô Ø)ˆÔØˆr)   N)r:   r;   r<   r=   r¥  rQ   ræ  r  r  r‡   rP  r‹  r"   r)   r&   rŽ  rŽ  ù  s4   „ ñ	ð OÐòòò,ò\òò	ór)   rŽ  c                   ó0   — e Zd ZdZd„ Zd„ Zdd„Zd„ Zd„ Zy)	ÚAlignFunctionDefinitionszq
    This class takes the signatures from a .pxd file and applies them to
    the def methods in a .py file.
    c                 óJ   — |j                   | _         | j                  |«       |S r!   )rÉ  r8   r#   s     r&   rQ   z)AlignFunctionDefinitions.visit_ModuleNodem  s    € Ø—Z‘ZˆŒ
Ø×Ñ˜4Ô Øˆr)   c                 ó|  — | j                   j                  |j                  «      }|r”|j                  r | j	                  |j                  «       |«      S |j                   r|j                   j                  sFt        |j                  d|j                  z  «       |j                  rt        |j                  d«       y |S ©Nz'%s' redeclaredzprevious declaration here)	rÉ  rò  rx   Ú	is_cclassr‹  r¦  Úis_builtin_scoper   rL   ©r$   r%   Úpxd_defs      r&   rP  z-AlignFunctionDefinitions.visit_PyClassDefNoder  s‰   € Ø—*‘*×#Ñ# D§I¡IÓ.ˆÙØ× Ò Ø×/Ñ/°·±Ó0@À'ÓJÐJØ—]’]¨'¯-©-×*HÒ*HÜ�d—h‘hÐ 1°D·I±IÑ =Ô>Ø—;’;Ü˜'Ÿ+™+Ð'BÔCØØˆr)   Nc                 óö   — |€%| j                   j                  |j                  «      }|r5|j                  s|S | j                   }|j                  j                   | _         | j                  |«       |r| _         |S r!   ©rÉ  rò  r@  Údefined_in_pxdr4  r8   ©r$   r%   r²  rÜ  s       r&   r‹  z,AlignFunctionDefinitions.visit_CClassDefNode~  óg   € Øˆ?Ø—j‘j×'Ñ'¨¯©Ó8ˆGÙØ×)Ò)Ø�ØŸ*™*ˆKØ Ÿ™×+Ñ+ˆDŒJØ×Ñ˜4Ô ÙØ$ˆDŒJØˆr)   c                 ó^  — | j                   j                  |j                  «      }|r…|j                   r|j                   j                  sc|j                  sFt        |j                  d|j                  z  «       |j                  rt        |j                  d«       y |j                  |«      }|S r®  )rÉ  rò  rx   r°  Úis_cfunctionr   rL   rœ  r±  s      r&   r  z&AlignFunctionDefinitions.visit_DefNode‹  s€   € Ø—*‘*×#Ñ# D§I¡IÓ.ˆÙ˜GŸMšM°·±×1OÒ1OØ×'Ò'Ü�d—h‘hÐ 1°D·I±IÑ =Ô>Ø—;’;Ü˜'Ÿ+™+Ð'BÔCØØ×$Ñ$ WÓ-ˆDð ˆr)   c                 ó   — |S r!   r"   r#   s     r&   rU   z'AlignFunctionDefinitions.visit_ExprNode˜  rÅ  r)   r!   )	r:   r;   r<   r=   rQ   rP  r‹  r  rU   r"   r)   r&   r«  r«  g  s    „ ñò
ò

óòór)   r«  c                   ó,   — e Zd Zd„ Zd„ Zdd„Zd„ Zd„ Zy)ÚAutoCpdefFunctionDefinitionsc                 óŠ   — |j                   | _         t        «       | _        |j                  | _        | j	                  |«       |S r!   )rÃ  r)  rü  rÉ  r8   r#   s     r&   rQ   z-AutoCpdefFunctionDefinitions.visit_ModuleNodeŸ  s5   € ØŸ/™/ˆŒÜ!›eˆÔØ—Z‘ZˆŒ
Ø×Ñ˜4Ô Øˆr)   c                 óØ   — | j                   j                  rS| j                  d   rD|j                  | j                  vr,|j                  «       r|j                  | j                   ¬«      }|S )NÚ
auto_cpdef)rÉ  )rÉ  Úis_module_scoperÃ  rx   rü  Úis_cdef_func_compatiblerœ  r#   s     r&   r  z*AutoCpdefFunctionDefinitions.visit_DefNode¦  sT   € Ø�J‰J×&Ò&¨4¯?©?¸<Ò+HØ—I‘I T×%8Ñ%8Ñ8Ø×0Ñ0Ô2à×$Ñ$¨4¯:©:Ð$Ó6ˆDØˆr)   Nc                 óö   — |€%| j                   j                  |j                  «      }|r5|j                  s|S | j                   }|j                  j                   | _         | j                  |«       |r| _         |S r!   r´  r¶  s       r&   r‹  z0AutoCpdefFunctionDefinitions.visit_CClassDefNode®  r·  r)   c                 ó�   — | j                   j                  r/|j                  D ]   \  }}| j                  j	                  |«       Œ" |S r!   )rÉ  rÀ  r\  rü  rF  )r$   r%   rx   rÛ   s       r&   r  z5AutoCpdefFunctionDefinitions.visit_FromImportStatNode»  s<   € ð �:‰:×%Ò%ØŸ:œ:‘��aØ×#Ñ#×'Ñ'¨Õ-ð &àˆr)   c                 ó   — |S r!   r"   r#   s     r&   rU   z+AutoCpdefFunctionDefinitions.visit_ExprNodeÄ  rÅ  r)   r!   )r:   r;   r<   rQ   r  r‹  r  rU   r"   r)   r&   r¼  r¼  �  s   „ òòóòór)   r¼  c                   ó0   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚRemoveUnreachableCodec                 ó>  — | j                   d   s|S | j                  |«       t        |j                  «      dk(  rOt	        |j                  d   t
        j                  «      r(|j                  d   j                  s|j                  d d …= t        |j                  d«      D ]z  \  }}|j                  sŒ|t        |j                  «      k  rG| j                   d   r$t        |j                  |   j                  dd«       |j                  d | |_        d|_         |S  |S )NÚremove_unreachabler   r   úwarn.unreachableúUnreachable coderÇ   T)rÝ  r8   rÏ   rM   rN   r   rP   rZ  r:  r   rL   )r$   r%   Úidxr#  s       r&   r[   z(RemoveUnreachableCode.visit_StatListNodeË  sð   € Ø×&Ñ&Ð';Ò<ØˆKØ×Ñ˜4Ô Üˆt�z‰z‹?˜aÒ¤J¨t¯z©z¸!©}¼e×>PÑ>PÔ$QÐZ^×ZdÑZdÐefÑZg×ZmÒZmØ—
‘
š1�Ü" 4§:¡:¨qÖ1‰IˆC�Ø×!Ó!Øœ˜TŸZ™Z›Ò(Ø×.Ñ.Ð/AÒBÜ §
¡
¨3¡× 3Ñ 3Ð5GÈÔKØ!%§¡¨D¨SÐ!1�D”JØ%)�Ô"ØØˆð 2ð ˆr)   c                 ób   — | j                  |«       |j                  j                  rd|_        |S rS   )r8   rO   r:  r#   s     r&   Úvisit_IfClauseNodez(RemoveUnreachableCode.visit_IfClauseNodeÛ  s*   € Ø×Ñ˜4Ô Ø�9‰9×"Ò"Ø!%ˆDÔØˆr)   c                 óº   — | j                  |«       |j                  r=|j                  j                  r'|j                  D ]  }|j                  rŒ |S  d|_        |S rS   )r8   r—  r:  r®  )r$   r%   Úclauses      r&   Úvisit_IfStatNodez&RemoveUnreachableCode.visit_IfStatNodeá  sW   € Ø×Ñ˜4Ô Ø×Ò × 0Ñ 0× >Ò >ØŸ/œ/�Ø×+Ó+Øð ˆð *ð &*�Ô"Øˆr)   c                 óÚ   — | j                  |«       |j                  j                  rC|j                  r7| j                  d   r!t        |j                  j                  dd«       d |_        |S )NrÉ  rÊ  rÇ   )r8   rO   r:  r—  rÝ  r   rL   r#   s     r&   Úvisit_TryExceptStatNodez-RemoveUnreachableCode.visit_TryExceptStatNodeë  sZ   € Ø×Ñ˜4Ô Ø�9‰9×"Ò" t×'7Ò'7Ø×&Ñ&Ð'9Ò:Ü˜×(Ñ(×,Ñ,Ð.@À!ÔDØ#ˆDÔØˆr)   c                 ób   — | j                  |«       |j                  j                  rd|_        |S rS   )r8   ræ   r:  r#   s     r&   Úvisit_TryFinallyStatNodez.RemoveUnreachableCode.visit_TryFinallyStatNodeó  s,   € Ø×Ñ˜4Ô Ø×Ñ×,Ò,Ø!%ˆDÔØˆr)   c                 óf   — | j                   d   s!t        j                  |j                  g ¬«      }|S )zEliminate useless PassStatNodeÚ	linetracerK   )rÝ  r   rP   rL   r#   s     r&   Úvisit_PassStatNodez(RemoveUnreachableCode.visit_PassStatNodeù  s-   € ð ×&Ñ& {Ò3Ü×%Ñ%¨$¯(©(¸"Ô=ˆDØˆr)   N)	r:   r;   r<   r[   rÍ  rÐ  rÒ  rÔ  r×  r"   r)   r&   rÆ  rÆ  É  s    „ òò òòòór)   rÆ  c                   ód   ‡ — e Zd Zg fˆ fd„	Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zˆ xZS )r}   c                 ó’   •— t         ‰| �  «        g | _        g | _        g | _        g | _        d| _        d| _        d| _        || _	        y rA   )
rB   rC   Úyieldsr”  ÚfinallysÚexceptsÚhas_return_valuer   r€   Úexcludes)r$   rÞ  rH   s     €r&   rC   zYieldNodeCollector.__init__  sG   ø€ Ü‰ÑÔØˆŒØˆŒØˆŒØˆŒØ %ˆÔØˆŒØˆŒØ ˆ�r)   c                 óD   — || j                   vr| j                  |«       y y r!   )rÞ  r8   r#   s     r&   r  zYieldNodeCollector.visit_Node  s!   € Ø�t—}‘}Ñ$Ø×Ñ˜tÕ$ð %r)   c                 ój   — | j                   j                  |«       d| _        | j                  |«       y rS   )rÚ  r¶   r   r8   r#   s     r&   Úvisit_YieldExprNodez&YieldNodeCollector.visit_YieldExprNode  ó)   € Ø�‰×Ñ˜4Ô ØˆŒØ×Ñ˜4Õ r)   c                 ój   — | j                   j                  |«       d| _        | j                  |«       y rS   )rÚ  r¶   r€   r8   r#   s     r&   Úvisit_AwaitExprNodez&YieldNodeCollector.visit_AwaitExprNode  râ  r)   c                 ó‚   — | j                  |«       |j                  rd| _        | j                  j	                  |«       y rS   )r8   rw   rÝ  r”  r¶   r#   s     r&   Úvisit_ReturnStatNodez'YieldNodeCollector.visit_ReturnStatNode  s1   € Ø×Ñ˜4Ô Ø�:Š:Ø$(ˆDÔ!Ø�‰×Ñ˜DÕ!r)   c                 ó\   — | j                  |«       | j                  j                  |«       y r!   )r8   rÛ  r¶   r#   s     r&   rÔ  z+YieldNodeCollector.visit_TryFinallyStatNode"  s"   € Ø×Ñ˜4Ô Ø�‰×Ñ˜TÕ"r)   c                 ó\   — | j                  |«       | j                  j                  |«       y r!   )r8   rÜ  r¶   r#   s     r&   rÒ  z*YieldNodeCollector.visit_TryExceptStatNode&  s"   € Ø×Ñ˜4Ô Ø�‰×Ñ˜DÕ!r)   c                  ó   — y r!   r"   r#   s     r&   r`  z%YieldNodeCollector.visit_ClassDefNode*  r  r)   c                  ó   — y r!   r"   r#   s     r&   r  z$YieldNodeCollector.visit_FuncDefNode-  r  r)   c                  ó   — y r!   r"   r#   s     r&   r‡   z#YieldNodeCollector.visit_LambdaNode0  r  r)   c                 ó˜   — t        |j                  t        j                  «      r&| j	                  |j                  j
                  «       y y r!   )rN   r”   r   Ú_ForInStatNoder$  r‰   r#   s     r&   r™   z0YieldNodeCollector.visit_GeneratorExpressionNode3  s3   € ä�d—i‘i¤×!5Ñ!5Ô6ð �J‰J�t—y‘y×)Ñ)Õ*ð 7r)   c                  ó   — y r!   r"   r#   s     r&   Úvisit_CArgDeclNodez%YieldNodeCollector.visit_CArgDeclNode:  s   € ð 	r)   )r:   r;   r<   rC   r  rá  rä  ræ  rÔ  rÒ  r`  r  r‡   r™   rï  ri   rj   s   @r&   r}   r}     sB   ø„ à "õ 	!ò%ò!ò
!ò
"ò#ò"òòòò+ör)   r}   c                   ó0   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚMarkClosureVisitorc                 óD   — d| _         g | _        | j                  |«       |S rA   )Úneeds_closurerÞ  r8   r#   s     r&   rQ   z#MarkClosureVisitor.visit_ModuleNodeD  s$   € Ø"ˆÔØˆŒØ×Ñ˜4Ô Øˆr)   c                 ó¼  — d| _         | j                  |«       | j                   |_         d| _         t        | j                  «      }|j                  |«       |j                  rrt
        j                  }|j                  r6t
        j                  }|j                  |j                  z   D ]	  }d|_        Œ n| j                  d   rpt
        j                  }n_|j                  r4t        d„ |j                  D «       «      }t!        |j"                  d«       |S |j                  rt
        j$                  }n|S t'        |j                  d«      D ]  \  }}||_        Œ |j                  |j*                  z   |j,                  z   D ]	  }d|_        Œ t        j0                  |j"                  |j2                  |j4                  |j                  |j                  xr |j                  ¬«      } ||j"                  |j2                  |j6                  |j8                  |j:                  |j<                  |j>                  ||j@                  |jB                  |jD                  ¬«      }	|	S )	NFTÚiterable_coroutinec              3   ó:   K  — | ]  }|j                   sŒ|–— Œ y ­wr!   )Úis_await)rm  Úys     r&   rn  z7MarkClosureVisitor.visit_FuncDefNode.<locals>.<genexpr>\  s   è ø€ ÐCÑ$4˜q¸¿
»
œÑ$4ùs   ‚”z/'await' not allowed in generators (use 'yield')r   )rL   rx   rO   Úis_coroutine_bodyÚis_async_gen_body)rL   rx   ry   rz   r{   r|   rX  rñ  Úlambda_namer›  rŽ   )#ró  r8   r}   rÞ  r�   r   ÚAsyncDefNoder   ÚAsyncGenNoderÚ  r”  Úin_async_genrÝ  ÚIterableAsyncDefNoder€   Únextr   rL   ÚGeneratorDefNoderZ  Ú	label_numrÛ  rÜ  Úin_generatorÚGeneratorBodyDefNoderx   rO   ry   rz   r{   r|   rX  rû  r›  rŽ   )
r$   r%   r†   Úcoroutine_typeÚ
yield_exprÚfoundr_  Úretnoderñ  Ú	coroutines
             r&   r  z$MarkClosureVisitor.visit_FuncDefNodeJ  sò  € Ø"ˆÔØ×Ñ˜4Ô Ø!×/Ñ/ˆÔØ!ˆÔä& t§}¡}Ó5ˆ	Ø×Ñ Ô%à×ÒÜ"×/Ñ/ˆNØ×"Ò"Ü!&×!3Ñ!3�Ø"+×"2Ñ"2°Y×5FÑ5FÔ"F�JØ.2�JÕ+ñ #Gà×(Ñ(Ð)=Ò>Ü!&×!;Ñ!;‘Ø× Ò ÜÑC I×$4Ò$4ÓCÓCˆEÜ�%—)‘)ÐNÔOØˆKØ× Ò Ü"×3Ñ3‰NàˆKä& y×'7Ñ'7¸Ö;‰MˆAˆzØ#$ˆJÕ ð <à ×(Ñ(¨9×+=Ñ+=Ñ=À	×@QÑ@QÔQˆGØ#'ˆGÕ ð Rô ×*Ñ*Ø—‘˜tŸy™y¨t¯y©yØ"×/Ñ/Ø"×/Ñ/ÒG°I×4GÑ4GôIˆñ #Ø—‘˜tŸy™y¨t¯y©yØ—]‘]°×1BÑ1BØ—‘ T§_¡_Ø T×%5Ñ%5Ø#'×#>Ñ#>Ø$(×$@Ñ$@ôBˆ	ð Ðr)   c                 óÂ   — d| _         | j                  |«       | j                   |_         d| _         |j                   r"|j                  rt        |j                  d«       |S )NFTz1closures inside cpdef functions not yet supported)ró  r8   r˜  r   rL   r#   s     r&   r  z%MarkClosureVisitor.visit_CFuncDefNodev  sS   € Ø"ˆÔØ×Ñ˜4Ô Ø!×/Ñ/ˆÔØ!ˆÔØ×Ò $×"2Ò"2Ü�$—(‘(ÐOÔPØˆr)   c                 óf   — d| _         | j                  |«       | j                   |_         d| _         |S )NFT)ró  r8   r#   s     r&   r‡   z#MarkClosureVisitor.visit_LambdaNode  s3   € Ø"ˆÔØ×Ñ˜4Ô Ø!×/Ñ/ˆÔØ!ˆÔØˆr)   c                 ó6   — | j                  |«       d| _        |S rS   )r8   ró  r#   s     r&   r`  z%MarkClosureVisitor.visit_ClassDefNode†  s   € Ø×Ñ˜4Ô Ø!ˆÔØˆr)   c                 óª  — | j                   }t        |j                  t        j                  «      r|j                  j
                  g| _         | j                  |«      }|| _         t        |j                  t        j                  «      s|S |j                  j
                  j                  }|j                  r|S t        |«      j                  |«       |S r!   )rÞ  rN   r”   r   rí  r‰   r‡   r˜  rE  rÇ  r$  )r$   r%   rÞ  Úitseqs       r&   r™   z0MarkClosureVisitor.visit_GeneratorExpressionNode‹  s    € Ø—=‘=ˆÜ�d—i‘i¤×!5Ñ!5Ô6Ø!ŸY™Y×/Ñ/Ð0ˆDŒMØ×$Ñ$ TÓ*ˆØ ˆŒÜ˜$Ÿ)™)¤U×%9Ñ%9Ô:ð ˆKØ—	‘	×"Ñ"×+Ñ+ˆà×ÒØˆKÜ+¨DÓ1×7Ñ7¸Ô>Øˆr)   N)	r:   r;   r<   rQ   r  r  r‡   r`  r™   r"   r)   r&   rñ  rñ  @  s!   „ òò*òXòòó
r)   rñ  c                   óP   ‡ — e Zd Zˆ fd„Zd„ Zd„ Zd
d„Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zˆ xZS )ÚCreateClosureClassesc                 ó@   •— t         ‰| �  |«       g | _        d| _        y rA   )rB   rC   ÚpathrZ  rF   s     €r&   rC   zCreateClosureClasses.__init__¡  s   ø€ Ü‰Ñ˜Ô!ØˆŒ	Øˆ�r)   c                 óJ   — |j                   | _        | j                  |«       |S r!   )rÉ  rá  r8   r#   s     r&   rQ   z%CreateClosureClasses.visit_ModuleNode¦  s!   € Ø ŸJ™JˆÔØ×Ñ˜4Ô Øˆr)   c                 ó  — g }g }|j                   j                  «       D ]g  }|j                  j                  «       D ]H  \  }}|sŒ	|j                  r|j                  ||f«       Œ)|j                  sŒ6|j                  ||f«       ŒJ Œi ||fS r!   )rç  Úiter_local_scopesr>  r\  Úfrom_closurer¶   rð  )r$   r%   r  rð  rÉ  rx   rî  s          r&   Úfind_entries_used_in_closuresz2CreateClosureClasses.find_entries_used_in_closures«  s‰   € ØˆØˆ
Ø×%Ñ%×7Ñ7Ö9ˆEØ$Ÿ}™}×2Ñ2Ö4‘��eÙØØ×%Ò%Ø ×'Ñ'¨¨u¨Õ6Ø×%Ó%Ø×%Ñ% t¨U mÕ4ñ  5ð :ð ˜ZÐ'Ð'r)   c                 óð  — |j                   rl|j                  j                  «       D ]O  }|j                  j	                  «       D ]0  }|j
                  rŒ|j                  rŒ|j                  rŒ*d|_        Œ2 ŒQ | j                  |«      \  }}|j                  «        d|_        d|_        |j                  }|j                  j                  }	|	j                  s|	j                   r&|	j"                  }	|	j                  rŒ|	j                   rŒ&|sA| j$                  s|r3|s#|j&                  st)        d«      ‚|j&                  }d|_        d|_        |j                   rn'|s|sy |s d|_        |	j.                  |_        d|_        y |j1                  t2        j4                  «      ›d|j                  j6                  j9                  dd«      ›�}
t;        |
«      }
|j=                  |
|j>                  dd¬«      }d|j@                  _!        ||_        |j@                  j                  }d|_"        d|_#        |jH                  s|j                   rd|jJ                  d<   tL        jN                  rtL        jN                  |jJ                  d	<   |re|	jP                  sJ ‚|jS                  |j>                  t2        jT                  t2        jT                  |	j.                  j@                  d¬
«       d|_        |D ]e  \  }}|jS                  |j>                  |jV                  s|jX                  nd |j6                  |j@                  d¬
«      }|jZ                  sŒ_d|_-        Œg d|_        |j]                  |j.                  «       y )NTFz%DefNode does not have assignment noderÛ   rÎ  Ú__)rx   rL   ÚdefiningÚimplementingÚno_gc_clearÚfreelist)rL   rx   rï  r4  Úis_cdefr   )/r¼  rç  r  r>  r+  r  r2  Ú
is_cglobalrð  r  r  ró  Úneeds_outer_scoperî  rÉ  rÚ  rÛ  rÜ  r  rà  r   Úneeds_closure_codeÚis_passthroughÚscope_classÚnext_idr   Úclosure_class_prefixrï  rõ  r   Údeclare_c_classrL   r4  Úis_final_typeÚis_internalÚis_closure_class_scoper�   rÃ  r   Úclosure_freelist_sizerÞ  rÆ  Úouter_scope_cnameÚin_subscoperx   Úis_declared_genericÚcheck_c_class)r$   r%   Útarget_module_scopeÚ
inner_noderÉ  rî  r  rð  Ú
func_scopeÚcscoperŸ  Úclass_scoperx   Úclosure_entrys                 r&   Úcreate_class_from_scopez,CreateClosureClasses.create_class_from_scope¸  s  € à×ÒØ×)Ñ)×;Ñ;Ö=�Ø"Ÿ]™]×1Ñ1Ö3�EØ!×.Ó.°%×2CÓ2CÀu×GWÓGWØ+/˜Õ(ñ 4ð >ð
 $(×#EÑ#EÀdÓ#KÑ ˆ�jØ�‰Ôð #ˆÔØ!&ˆÔà×%Ñ%ˆ
Ø—‘×!Ñ!ˆØ×&Ò&¨&×*AÒ*AØ×'Ñ'ˆFð ×&Ó&¨&×*AÓ*Añ  §¢©jÙØ×)Ò)Ü'Ð(OÓPÐPØ!×/Ñ/�
Ø,1ˆJÔ)Ø%*ˆDÔ"à×ÒØÙ¡LØÙØ(,ˆJÔ%Ø%+×%7Ñ%7ˆJÔ"Ø%)ˆDÔ"Øð  ×'Ñ'¬×(CÑ(CÕDØ�J‰J×Ñ×$Ñ$ S¨Ô.ð0ˆô   Ó(ˆà#×3Ñ3Ø˜dŸh™h°Øð 4ó ˆð $(ˆ�
‰
Ô à!&ˆ
ÔØ—j‘j×&Ñ&ˆØ"&ˆÔØ-1ˆÔ*Ø×Ò × 1Ò 1à48ˆK×"Ñ" =Ñ1Ü×(Ò(Ü18×1NÑ1NˆK×"Ñ" :Ñ.áØ×*Ò*Ð*Ð*Ø×#Ñ#¨¯©Ü)/×)AÑ)AÜ*0×*BÑ*BØ)/×);Ñ);×)@Ñ)@Ø,0ð	 $ô 2ð
 &*ˆDÔ"Û%‰KˆD�%Ø'×3Ñ3Ø—I‘IØ',×'8Ò'8�U—Z’Z¸dØ—k‘kØ—Z‘ZØð 4ó ˆMð ×(Ó(Ø45�Õ1ð &ð "ˆÔà×)Ñ)¨*×*@Ñ*@ÕAr)   c                 óö   — t        |j                  t        j                  «      s|S | j                  }d| _        | j                  |j                  | j                  |«       | j                  |«       || _        |S rS   )rN   r…   r   r„   rZ  r5  rá  r8   )r$   r%   Úwas_in_lambdas      r&   r‡   z%CreateClosureClasses.visit_LambdaNode
  s_   € Ü˜$Ÿ-™-¬¯©Ô7àˆKàŸ™ˆØˆŒØ×$Ñ$ T§]¡]°D×4EÑ4EÀtÔLØ×Ñ˜4Ô Ø&ˆŒØˆr)   c                 ó8  — | j                   r| j                  |«       |S |j                  s| j                  rb| j	                  || j
                  «       | j                  j                  |«       | j                  |«       | j                  j                  «        |S r!   )rZ  r8   ró  r  r5  rá  r¶   r  r#   s     r&   r  z&CreateClosureClasses.visit_FuncDefNode  ss   € Ø�>Š>Ø×Ñ˜tÔ$ØˆKØ×Ò §¢Ø×(Ñ(¨¨t×/@Ñ/@ÔAØ�I‰I×Ñ˜TÔ"Ø×Ñ˜tÔ$Ø�I‰I�M‰MŒOØˆr)   c                 ó(   — | j                  |«       |S r!   r  r#   s     r&   rÖ  z/CreateClosureClasses.visit_GeneratorBodyDefNode!  ó   € Ø×Ñ˜4Ô Øˆr)   c                 ób   — |j                   s| j                  |«      S | j                  |«       |S r!   )r˜  r  r8   r#   s     r&   r  z'CreateClosureClasses.visit_CFuncDefNode%  s/   € Ø×ÒØ×)Ñ)¨$Ó/Ð/à×Ñ˜tÔ$ØˆKr)   c                 óD   —  t        «       |«      }| j                  |«      S r!   )rÏ  r‡   r#   s     r&   r™   z2CreateClosureClasses.visit_GeneratorExpressionNode,  s#   € Ø*Ô(Ó*¨4Ó0ˆØ×$Ñ$ TÓ*Ð*r)   r!   )r:   r;   r<   rC   rQ   r  r5  r‡   r  rÖ  r  r™   ri   rj   s   @r&   r  r  �  s3   ø„ ôò
ò
(óPBòd
ò	òòö+r)   r  c                   óR   — e Zd ZdZdZd„ ZeZeZd„ Zd„ Z	d„ Z
d„ Zej                  Zy)	ÚInjectGilHandlinga
  
    Allow certain Python operations inside of nogil blocks by implicitly acquiring the GIL.

    Must run before the AnalyseDeclarationsTransform to make sure the GILStatNodes get
    set up, parallel sections know that the GIL is acquired inside of them, etc.
    Fc                 ób   — | j                   r"t        j                  |j                  d|¬«      }|S )zYAllow the (Python statement) node in nogil sections by wrapping it in a 'with gil' block.rf  ©rn  rO   )rR  r   rr  rL   r#   s     r&   Ú_inject_gil_in_nogilz&InjectGilHandling._inject_gil_in_nogil<  s&   € à�:Š:Ü×$Ñ$ T§X¡X°UÀÔFˆDØˆr)   c                 óv   — | j                   }|j                  dk(  | _         | j                  |«       || _         |S )NrR  )rR  rn  r8   ©r$   r%   Ú	was_nogils      r&   Úvisit_GILStatNodez#InjectGilHandling.visit_GILStatNodeJ  s5   € Ø—J‘Jˆ	Ø—j‘j GÑ+ˆŒ
Ø×Ñ˜4Ô ØˆŒ
Øˆr)   c                 óþ   — | j                   }t        |j                  t        j                  «      r4|j                  j                   xr |j                  j
                   | _         | j                  |«       || _         |S r!   )rR  rN   rã  r   ÚCFuncDeclaratorNoderS  r8   rC  s      r&   r  z$InjectGilHandling.visit_CFuncDefNodeQ  s\   € Ø—J‘Jˆ	Ü�d—o‘o¤u×'@Ñ'@ÔAØŸ™×.Ñ.ÒO°t·±×7OÑ7OÐ3OˆDŒJØ×Ñ˜4Ô ØˆŒ
Øˆr)   c                 óp   — | j                   }|j                   | _         | j                  |«       || _         |S r!   )rR  r8   rC  s      r&   Úvisit_ParallelRangeNodez)InjectGilHandling.visit_ParallelRangeNodeY  s0   € Ø—J‘Jˆ	Ø—Z‘ZˆŒ
Ø×Ñ˜4Ô ØˆŒ
Øˆr)   c                 ó   — |S r!   r"   r#   s     r&   rU   z InjectGilHandling.visit_ExprNode`  rÅ  r)   N)r:   r;   r<   r=   rR  rA  Úvisit_RaiseStatNodeÚvisit_PrintStatNoderE  r  rI  rU   r   r¥  r  r"   r)   r&   r>  r>  1  sB   „ ñð €Eòð /ÐØ.Ðòòòòð "×5Ñ5�Jr)   r>  c                   ód   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zˆ xZS )ÚGilChecka,  
    Call `node.gil_check(env)` on each node to make sure we hold the
    GIL when we need it.  Raise an error when on Python operations
    inside a `nogil` environment.

    Additionally, raise exceptions for closely nested with gil or with nogil
    statements. The latter would abort Python.
    c                 óÂ   •— |j                   g| _        t        j                  j                  | _        t        j                  j                  | _        t        ‰| �!  |«      S r!   )	rÉ  Ú	env_stackr   Ú
NoGilStateÚHasGilÚnogil_stateÚ"nogil_state_at_current_gilstatnoderB   r†  )r$   rQ  rH   s     €r&   r†  zGilCheck.__call__q  sH   ø€ ØŸ*™*˜ˆŒÜ ×+Ñ+×2Ñ2ˆÔä27×2BÑ2B×2IÑ2IˆÔ/Ü‰wÑ Ó%Ð%r)   c                 ót  — | j                   }|j                  }|r|t        | j                  «      dkD  rd| j                  d   j                  rt
        j                  j                  nt
        j                  j                  | _         | j                  ||«       || _         | j                  |d |¬«       || _         y )Nr   éþÿÿÿrŠ   )
rS  Úouter_attrsrÏ   rP  rR  r   rQ  ÚNoGilrR  r8   )r$   r%   rS  rD  rW  s        r&   Ú_visit_scoped_childrenzGilCheck._visit_scoped_childrenx  s–   € Ø×$Ñ$ˆ	Ø×&Ñ&ˆÙœ3˜tŸ~™~Ó.°Ò2à*.¯.©.¸Ñ*<×*BÒ*B”× Ñ ×&Ò&Ì×HXÑHX×H_ÑH_ð Ôà×Ñ˜t [Ô1à&ˆÔØ×Ñ˜4 t°[ÐÔAØ$ˆÕr)   c                 ó¢  — | j                   j                  |j                  «       |j                  j                  }| j                  }|rt
        j                  j                  | _        |r'|j                  r|j                  |j                  «       | j                  || j                  «       || _        | j                   j                  «        |S r!   )rP  r¶   rç  rR  rS  r   rQ  Ú
NoGilScopeÚnogil_checkrY  r  )r$   r%   Úinner_nogilrS  s       r&   r  zGilCheck.visit_FuncDefNode„  s¡   € Ø�‰×Ñ˜d×.Ñ.Ô/Ø×&Ñ&×,Ñ,ˆà×&Ñ&ˆÙÜ$×/Ñ/×:Ñ:ˆDÔá˜4×+Ò+Ø×Ñ˜T×-Ñ-Ô.à×#Ñ# D¨$×*:Ñ*:Ô;ð 'ˆÔà�‰×ÑÔØˆr)   c                 ón  — |j                   �/t        |j                   j                  d|j                  z  «       |S | j                  r|j
                  r|j                  «        | j                  }|j                  dk(  }||k(  rV| j                  t        j                  j                  k(  s/|st        |j                  d«       nt        |j                  d«       | j                  t        j                  j                  k(  rd|_	        t        |j                  t        j                  «      r|j                  j                  \  |_        | j                  }| j                  | _        |rt        j                  j                  nt        j                  j                   }| j#                  ||«       || _        |S )Nz<Non-constant condition in a `with %s(<condition>)` statementrR  z3Trying to acquire the GIL while it is already held.z;Trying to release the GIL while it was previously released.F)ro  r   rL   rn  rS  r\  r   rQ  r[  Úscope_gil_state_knownrN   ræ   rP   rM   rT  rX  rR  rY  )r$   r%   rD  Úis_nogilrT  rS  s         r&   rE  zGilCheck.visit_GILStatNode˜  se  € Ø�>‰>Ð%Ü�$—.‘.×$Ñ$ð5Ø7;·z±zñBôCð ˆKà×Ò × 0Ò 0Ø×ÑÔà×$Ñ$ˆ	Ø—J‘J 'Ñ)ˆà˜Ò ¨×)9Ñ)9¼U×=MÑ=M×=XÑ=XÒ)XÙÜ�d—h‘hð !0õ 1ô �d—h‘hð !7ô 8à×Ñœu×/Ñ/×:Ñ:Ò:Ø).ˆDÔ&ä�d×)Ñ)¬5×+=Ñ+=Ô>ð $(×#6Ñ#6×#<Ñ#<Ñ ˆDÔà-1×-TÑ-TÐ*Ø26×2BÑ2BˆÔ/Ù08”e×&Ñ&×,Ò,¼e×>NÑ>N×>UÑ>UˆØ×#Ñ# D¨+Ô6Ø2TˆÔ/Øˆr)   c                 óþ  — |j                   s'| j                  t        j                  j                  k(  rw|j                   dc}|_         t        j
                  |j                  d|¬«      }|s.| j                  t        j                  j                  k(  rd|_        | j                  |«      S | j                  st        |j                  d«       y |j                  | j                  d   «       | j                  |«       |S )NFrR  r@  z)prange() can only be used without the GILrÈ   )rR  rS  r   rQ  r[  rr  rL   r_  rE  r   r\  rP  r8   )r$   r%   Únode_was_nogils      r&   rI  z GilCheck.visit_ParallelRangeNode»  sÈ   € Ø�:Š:˜×)Ñ)¬U×-=Ñ-=×-HÑ-HÒHØ)-¯©°UÐ&ˆN˜DœJÜ×$Ñ$ T§X¡X°WÀ4ÔHˆDÙ! d×&6Ñ&6¼%×:JÑ:J×:UÑ:UÒ&Uð .3�Ô*Ø×)Ñ)¨$Ó/Ð/à×ÒÜ�$—(‘(ÐGÔHàà×Ñ˜Ÿ™¨Ñ+Ô,Ø×Ñ˜4Ô Øˆr)   c                 ó„  — | j                   st        |j                  d«       y | j                   t        j                  j
                  k(  r:t        j                  |j                  d|¬«      }d|_        | j                  |«      S |j                  r|j                  | j                  d   «       | j                  |«       |S )Nz5The parallel section may only be used without the GILrR  r@  FrÈ   )rS  r   rL   r   rQ  r[  rr  r_  rE  r\  rP  r8   r#   s     r&   Úvisit_ParallelWithBlockNodez$GilCheck.visit_ParallelWithBlockNodeÎ  s£   € Ø×ÒÜ�$—(‘(ð &ô 'àØ×Ñœu×/Ñ/×:Ñ:Ò:ô ×$Ñ$ T§X¡X°WÀ4ÔHˆDØ).ˆDÔ&Ø×)Ñ)¨$Ó/Ð/à×Òð ×Ñ˜TŸ^™^¨BÑ/Ô0à×Ñ˜4Ô Øˆr)   c                 ó~   — | j                   s| j                  |«      S d|_        d|_        | j	                  |«       |S )zM
        Take care of try/finally statements in nogil code sections.
        NT)rS  r  r\  Úis_try_finally_in_nogilr8   r#   s     r&   rÔ  z!GilCheck.visit_TryFinallyStatNodeâ  s?   € ð ×ÒØ—?‘? 4Ó(Ð(àˆÔØ'+ˆÔ$Ø×Ñ˜4Ô Øˆr)   c                 ó$   — | j                  |«      S r!   ©r  r#   s     r&   Úvisit_CriticalSectionStatNodez&GilCheck.visit_CriticalSectionStatNodeî  ó   € à�‰˜tÓ$Ð$r)   c                 ó$   — | j                  |«      S r!   rh  r#   s     r&   Úvisit_CythonLockStatNodez!GilCheck.visit_CythonLockStatNodeò  rj  r)   c                 ó„   — | j                   t        j                  j                  k(  rd|_        | j                  |«       |S rA   )rT  r   rQ  r[  r_  r8   r#   s     r&   Úvisit_GILExitNodezGilCheck.visit_GILExitNodeö  s7   € Ø×2Ñ2´e×6FÑ6F×6QÑ6QÒQØ).ˆDÔ&Ø×Ñ˜4Ô Øˆr)   c                 ó8  — | j                   r6| j                  r*|j                  r|j                  | j                   d   «       |j                  r| j	                  || j                  «       n| j                  |«       | j                  r| j                  |_        |S rT  )rP  rS  r\  rW  rY  r8   Úin_nogil_contextr#   s     r&   r  zGilCheck.visit_Nodeü  sy   € Ø�>Š>˜d×.Ò.°4×3CÒ3CØ×Ñ˜TŸ^™^¨BÑ/Ô0Ø×ÒØ×'Ñ'¨¨d×.>Ñ.>Õ?à×Ñ˜tÔ$Ø×ÒØ$(×$4Ñ$4ˆDÔ!Øˆr)   c                 ó‚  — |j                   �r"|j                   j                  j                  �r|j                  j                  rë|j                  j
                  dk(  rÒt        |j                  «      dk(  rºd }| j                  t        j                  j                  k(  rd}n)| j                  t        j                  j                  k(  rd}|rct        j                  |j                  |j                  j                   j"                  |z   |j                  j                  |j                   g¬«      }| j%                  |«      S )NÚacquirer   ÚNogilÚGilr²  )r$   r4  Úis_cython_lock_typer  r  rŒ  rÏ   ry   rS  r   rQ  rX  rR  r   ÚPythonCapiCallNoderL   rî  rï  r  )r$   r%   Úsuffixs      r&   Úvisit_SimpleCallNodezGilCheck.visit_SimpleCallNode  så   € Ø�I‹I˜$Ÿ)™)Ÿ.™.×<Ó<Ø—‘×*Ò*¨t¯}©}×/FÑ/FÈ)Ò/SÜ�D—I‘I“ !Ò#ð ˆFØ×Ñ¤5×#3Ñ#3×#9Ñ#9Ò9Ø ‘Ø×!Ñ!¤U×%5Ñ%5×%<Ñ%<Ò<Ø�ÙÜ ×3Ñ3Ø—H‘HØ—M‘M×'Ñ'×-Ñ-°Ñ6Ø—M‘M×&Ñ&ØŸ)™)˜ô	�ð �‰˜tÓ$Ð$r)   )r:   r;   r<   r=   r†  rY  r  rE  rI  rd  rÔ  ri  rl  rn  r  rx  ri   rj   s   @r&   rN  rN  g  sE   ø„ ñô&ò
%òò(!òFò&ò(
ò%ò%òò	ö%r)   rN  c                   ó.   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚCoerceCppTempsaÍ  
    For temporary expression that are implemented using std::optional it's necessary the temps are
    assigned using `__pyx_t_x = value;` but accessed using `something = (*__pyx_t_x)`. This transform
    inserts a coercion node to take care of this, and runs absolutely last (once nothing else can be
    inserted into the tree)

    TODO: a possible alternative would be to split ExprNode.result() into ExprNode.rhs_result() and ExprNode.lhs_result()???
    c                 ó\   — | j                  «       j                  r| j                  |«       |S r!   )rX  r0  r8   r#   s     r&   rQ   zCoerceCppTemps.visit_ModuleNode&  s'   € Ø×ÑÓ×!Ò!à×Ñ˜tÔ$Øˆr)   c                 ó  — | j                  |«       | j                  «       j                  d   rQ|j                  «       rA|j                  j
                  r+|j                  j                  st        j                  |«      }|S )NÚ
cpp_locals)	r8   rX  rÃ  Úresult_in_tempr4  r�  Úis_fake_referencer   ÚCppOptionalTempCoercionr#   s     r&   rU   zCoerceCppTemps.visit_ExprNode,  sa   € Ø×Ñ˜4Ô Ø×ÑÓ×)Ñ)¨,Ò7Ø×#Ñ#Ô%¨$¯)©)×*@Ò*@à—I‘I×/Ò/Ü×4Ñ4°TÓ:ˆDàˆr)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CppOptionalTempCoercionz,CoerceCppTemps.visit_CppOptionalTempCoercion6  r(   r)   c                 ó   — |S r!   r"   r#   s     r&   Úvisit_CppIteratorNodez$CoerceCppTemps.visit_CppIteratorNode9  r(   r)   c                 ó<   — | j                  |j                  «       |S r!   )r8   rc   r#   s     r&   rf   z!CoerceCppTemps.visit_ExprStatNode<  s   € à×Ñ˜4Ÿ9™9Ô%Øˆr)   N)	r:   r;   r<   r=   rQ   rU   r‚  r„  rf   r"   r)   r&   rz  rz    s    „ ñòòòòór)   rz  c                   óŠ   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zˆ fd„Zˆ fd„Zd„ Zd„ Zˆ xZS )ÚTransformBuiltinMethodszÏ
    Replace Cython's own cython.* builtins by the corresponding tree nodes.
    Also handle some Python special builtin functions (e.g. super()/locals())
    that require introspection by the compiler.
    c                 ó2   •— t        ‰| �  |i |¤Ž i | _        y r!   )rB   rC   Údef_node_body_insertions)r$   ry   r'  rH   s      €r&   rC   z TransformBuiltinMethods.__init__H  s   ø€ Ü‰Ñ˜$Ð' $Ò'Ø(*ˆÕ%r)   c                 óB   — |j                   ry | j                  |«       |S r!   )Údeclaration_onlyr8   r#   s     r&   rÂ   z2TransformBuiltinMethods.visit_SingleAssignmentNodeL  s!   € Ø× Ò Øà×Ñ˜tÔ$ØˆKr)   c                 óF   — | j                  |«       | j                  |«      S r!   )r8   Úvisit_cython_attributer#   s     r&   r¤  z+TransformBuiltinMethods.visit_AttributeNodeS  s!   € Ø×Ñ˜4Ô Ø×*Ñ*¨4Ó0Ð0r)   c                 óª   — |j                   dk(  r4| j                  «       }|j                  d«      }|s| j                  |«      }| j	                  |«      S )NrH   )rx   rX  rè  Ú_inject_classr�  )r$   r%   rÈ  rî  s       r&   r  z&TransformBuiltinMethods.visit_NameNodeW  sP   € Ø�9‰9˜Ò$Ø×#Ñ#Ó%ˆDØ×$Ñ$ \Ó2ˆEÙØ×)Ñ)¨$Ó/�Ø×*Ñ*¨4Ó0Ð0r)   c                 óP  — |j                  «       }|�r|dk(  r2ddlm} t        j                  |j
                  t        |«      ¬«      }|S |dk(  r!t        j                  |j
                  «      }|S |dv rXt        j                  |j
                  t        |«      | j                  «       j                  «       j                  |«      ¬«      }|S t        j                  |«      r	 |S | j                  j                  j!                  |«      r	 |S t#        |j
                  d|z  «       |S )	NÚ__version__rÇ   )r‘  rv   r«  )r)  Ú	frozensetr¼  ©rx   rî  z>'%s' not a valid cython attribute or is being used incorrectly)r  rm  r‘  r   rn  rL   r   ÚNullNoder¸   rX  Úbuiltin_scoperè  r   ré  rG   Úcython_scopeÚlookup_qualified_namer   )r$   r%   rŒ  Úversions       r&   r�  z.TransformBuiltinMethods.visit_cython_attribute_  s  € Ø×,Ñ,Ó.ˆ	ÚØ˜MÒ)Ý5Ü ×,Ñ,¨T¯X©X¼]È7Ó=SÔT�ð ˆð ˜fÒ$Ü ×)Ñ)¨$¯(©(Ó3�ð ˆð ÐBÑBÜ ×)Ñ)¨$¯(©(¼ÀyÓ9QØ04×0@Ñ0@Ó0B×0PÑ0PÓ0R×0^Ñ0^Ð_hÓ0iôk�ð ˆô ×,Ñ,¨YÔ7Øð
 ˆð	 —‘×*Ñ*×@Ñ@ÀÔKØð ˆô �d—h‘hÐ `ÐclÑ lÔmØˆr)   c                 ó�  — | j                  «       }| j                  |«       t        |j                  «      dk(  rŒ|j                  j	                  t        j                  |j                  «      «       |j                  sH|j                  j	                  t        j                  |j                  | j                  «       |«      «       |S r8  )rX  r8   rÏ   ry   r¶   r   ÚGlobalsExprNoderL   rÀ  ÚLocalsExprNodeÚcurrent_scope_node)r$   r%   rÈ  s      r&   Úvisit_ExecStatNodez*TransformBuiltinMethods.visit_ExecStatNoder  s•   € Ø×ÑÓ!ˆØ×Ñ˜4Ô Üˆt�y‰y‹>˜QÒØ�I‰I×ÑœY×6Ñ6°t·x±xÓ@ÔAØ×'Ò'Ø—	‘	× Ñ Ü×,Ñ,ØŸ™ $×"9Ñ"9Ó";¸TóCôDð ˆr)   c                 óž  — | j                  «       }|j                  |«      }|r|S |j                  }|dv rÓ|dk(  rFt        |j                  «      dkD  r.t        | j                  dt        |j                  «      z  «       |S |dk(  r^t        |j                  «      dkD  r,t        | j                  dt        |j                  «      z  «       t        |j                  «      dkD  r|S t        j                  || j                  «       |«      S t        |j                  «      dkD  r,t        | j                  dt        |j                  «      z  «       t        |j                  «      dkD  r|S |j                  s|j                  rf|j                  r0| j                  «       }t        j                  |j                  «      }nt        j                  |«      }t        j                  |«      S t        d	„ |j                   j#                  «       D «       «      }|D �	cg c]  }	t        j$                  ||	¬
«      ‘Œ }
}	t        j&                  ||
¬«      S c c}	w )N)rH  ÚvarsrH  r   zGBuiltin 'locals()' called with wrong number of args, expected 0, got %drŸ  r   zGBuiltin 'vars()' called with wrong number of args, expected 0-1, got %dzFBuiltin 'dir()' called with wrong number of args, expected 0-1, got %dc              3   óN   K  — | ]  }|j                   sŒ|j                   –— Œ y ­wr!   r¨   )rm  rÉ  s     r&   rn  z9TransformBuiltinMethods._inject_locals.<locals>.<genexpr>Ÿ  s   è ø€ Ð WÑ5J¨cÈcÏhËh §¥Ñ5Jùs   ‚%”%rv   r²  )rX  rè  rL   rÏ   ry   r   r   r›  rœ  rÚ  rÀ  r¶  r   rš  ÚSortedDictKeysNoderÞ  r>  r+  ÚIdentifierStringNoder~  )r$   r%   Ú	func_namerÈ  rî  rL   r�   Úlocals_dictÚlocal_namesrÉ  r\  s              r&   Ú_inject_localsz&TransformBuiltinMethods._inject_locals}  sè  € à×ÑÓ!ˆØ× Ñ  Ó+ˆÙàˆKØ�h‰hˆØÐ*Ñ*Ø˜HÒ$¬¨T¯Y©Y«¸!Ò);Ü�d—h‘hÐ iÜ˜DŸI™I›ñ!'ô (à�Ø˜fÒ$Ü�t—y‘y“> AÒ%Ü˜$Ÿ(™(Ð$mÜ §	¡	›Nñ%+ô ,ä�t—y‘y“> AÒ%Ø�KÜ×+Ñ+¨C°×1HÑ1HÓ1JÈDÓQÐQä�4—9‘9‹~ Ò!Ü�d—h‘hÐ hÜ˜DŸI™I›ñ!'ô (ä�4—9‘9‹~ Ò!à�Ø×%Ò%¨×)=Ò)=Ø×)Ò)Ø"×5Ñ5Ó7�GÜ"+×"5Ñ"5°g·l±lÓ"C‘Kä"+×";Ñ";¸CÓ"@�KÜ ×3Ñ3°KÓ@Ð@Ü Ñ W°T·\±\×5HÑ5HÔ5JÓ WÓWˆKá +ó-Ù +˜ô ×3Ñ3°C¸sÖCØ +ð ð -ä×%Ñ% c°Ô6Ð6ùò-s   ÈI
c                 ó  — | j                  |«       |j                  dv rgt        |j                  t        j
                  «      rC|j                  j                  }t        |t        j                  «      r|j                  }||_        |S )NÚnot_in)r8   r·  rN   r  r   r¡  rá   ÚNoneCheckNode)r$   r%   rá   s      r&   Úvisit_PrimaryCmpNodez,TransformBuiltinMethods.visit_PrimaryCmpNode¤  sd   € à×Ñ˜4Ô Ø�=‰=˜HÑ$Ü˜$Ÿ-™-¬×)EÑ)EÔFØ—m‘m×'Ñ'�Ü˜c¤9×#:Ñ#:Ô;ØŸ'™'�CØ #�”Øˆr)   c                 ó$   — | j                  |«      S r!   )rª  r#   s     r&   Úvisit_CascadedCmpNodez-TransformBuiltinMethods.visit_CascadedCmpNode¯  s   € Ø×(Ñ(¨Ó.Ð.r)   c                 ó°  — | j                  «       }|j                  |«      }t        |j                  «      dk7  s|r|j                  s|S |j                  j                  t        j                  |j                  «      «       |j                  sH|j                  j                  t        j                  |j                  | j                  «       |«      «       |S r8  )rX  rò  rÏ   ry   Ú
is_builtinr¶   r   rš  rL   rÀ  r›  rœ  )r$   r%   r£  rÈ  rî  s        r&   Ú_inject_evalz$TransformBuiltinMethods._inject_eval²  s£   € Ø×ÑÓ!ˆØ—‘˜IÓ&ˆÜˆt�y‰y‹>˜QÒ¡5°×1AÒ1AØˆKà�	‰	×Ñœ×2Ñ2°4·8±8Ó<Ô=Ø×#Ò#Ø�I‰I×ÑÜ×(Ñ(Ø—H‘H˜d×5Ñ5Ó7¸ó?ô@ð ˆr)   c           	      ó´  — | j                  «       }t        |t        j                  «      s|S d x}x}}t	        | j
                  «      D ]o  \  }}t        |t        j                  «      r|}|} nLt        |t        j                  «      r|}|j                  }|}	ŒQt        |t        j                  «      sŒl|}|}	Œq |r|s|S || j                  v�r	|j                  j                  }
j                  r7t        j                  |
|j                  j                   |j"                  ¬«      }nJ|j$                  r<t        j&                  |
|d u¬«      }|rd|_        nd|_        d|j*                  _        n|S t        j.                  |
t        j                  |
t1        d«      ¬«      |¬«      }|j3                  	«       || j                  vsJ ‚|| j                  |<   |S )Nr“  ©r¼  TrH   r¨   rÉ   )rœ  rN   r   ÚFuncDefNodeÚreversedrP  ÚClassDefNoder  rñ  r‰  rO   rL   rÛ  r   r¸   rÉ  rx   rî  rÚ  ÚClassCellNodeÚrequires_classobjÚ
class_cellÚ	is_activer·   r   rW  )r$   r%   Úcurrent_def_nodeÚ	fdef_nodeÚ
class_nodeÚgenerator_nodeÚ
stack_nodeÚstack_scoper3  Ú
fdef_scoperL   rª   rØ   s                r&   r�  z%TransformBuiltinMethods._inject_class¿  s¹  € à×2Ñ2Ó4ÐäÐ*¬E×,=Ñ,=Ô>ØˆKð 37Ð6ˆ	Ð6�J Ü'/°·±Ö'?Ñ#ˆJ˜Ü˜*¤e×&8Ñ&8Ô9Ø'�
Ø)�ÙÜ˜J¬×(>Ñ(>Ô?Ø!+�Ø&×,Ñ,�	Ø(‘
Ü˜J¬×(9Ñ(9Õ:Ø&�	Ø(‘
ð (@ñ ¡
àˆKð ˜D×9Ñ9Ò9Ø—.‘.×$Ñ$ˆCØ×+Ò+ô  ×(Ñ(Ø j×&6Ñ&6×&;Ñ&;Ø",×"2Ñ"2ô4‘ð ×.Ò.Ü×-Ñ-¨cÀÐVZÐ@ZÔ[�Ù!Ø7;�NÕ4à26�IÔ/Ø26�
×%Ñ%Õ/à�ä×4Ñ4°SÜ×&Ñ& s´¸{Ó1KÔLØôˆKð ×,Ñ,¨ZÔ8à D×$AÑ$AÑAÐAÐAØ7BˆD×)Ñ)¨)Ñ4àˆr)   c                 óZ  — | j                  «       }|j                  |«      }|s|j                  r|S | j                  «       }t	        |t
        j                  «      r$|j                  rt        | j                  «      dk  r|S | j                  d   \  }}|j                  r‚d|_
        d|j                  _        t        j                  |j                  |j                   ¬«      t        j"                  |j                  |j                  d   j$                  ¬«      g|_        |S |j&                  r}t        j"                  |j                  |j(                  j$                  |j*                  ¬«      t        j"                  |j                  |j                  d   j$                  ¬«      g|_        |S )NrÇ   rV  Tr±  r   r¨   r“  )rX  rè  ry   rœ  rN   r   r„   rÏ   rP  rÚ  r¶  r·  r¸  r   rµ  rL   r¼  r¸   rx   rÛ  rÉ  rî  )r$   r%   r£  rÈ  rî  r…   r»  r3  s           r&   Ú_inject_superz%TransformBuiltinMethods._inject_superú  sU  € Ø×ÑÓ!ˆØ× Ñ  Ó+ˆÙ�D—I’IØˆKà×*Ñ*Ó,ˆÜ˜(¤E§M¡MÔ2¸(¿-º-Ì3ÈtÏ~É~ÓK^ÐabÒKbØˆKØ"&§.¡.°Ñ"4Ñˆ
�KØ×(Ò(Ø)-ˆHÔ&Ø.2ˆJ×!Ñ!Ô+ä×'Ñ'Ø—H‘H¨8×+@Ñ+@ôBä×"Ñ" 4§8¡8°(·-±-ÀÑ2B×2GÑ2GÔHðˆDŒIð ˆð ×)Ò)ä×"Ñ"Ø—H‘H :×#3Ñ#3×#8Ñ#8Ø$×*Ñ*ô,ô ×"Ñ" 4§8¡8°(·-±-ÀÑ2B×2GÑ2GÔHð	ˆDŒIð ˆr)   c                 óP  — | j                   j                  |d «      }|rˆt        |j                  t        j
                  «      r'|j                  j                  j                  d|«       y t	        j
                  |j                  j                  ||j                  g¬«      |_        y y )Nr   rÊ   )	r‰  r  rN   rO   r   rP   rM   r©  rL   )r$   r%   Úbody_insertions      r&   Ú_do_body_insertionz*TransformBuiltinMethods._do_body_insertion  sw   € Ø×6Ñ6×:Ñ:¸4ÀÓFˆÙÜ˜$Ÿ)™)¤U×%7Ñ%7Ô8Ø—	‘	—‘×&Ñ& q¨.Õ9ä!×.Ñ.¨t¯y©y¯}©}Ø6DÀdÇiÁiÐ5PôR�•	ð	 r)   c                 óH   •— t         ‰| �  |«      }| j                  |«       |S r!   )rB   r  rÄ  r‡  s     €r&   r  z)TransformBuiltinMethods.visit_FuncDefNode  s%   ø€ Ü‰wÑ(¨Ó.ˆØ×Ñ Ô%Øˆr)   c                 óH   •— t         ‰| �  |«      }| j                  |«       |S r!   )rB   rÖ  rÄ  r‡  s     €r&   rÖ  z2TransformBuiltinMethods.visit_GeneratorBodyDefNode#  s%   ø€ Ü‰wÑ1°$Ó7ˆØ×Ñ Ô%Øˆr)   c                 ó¢
  — |j                   j                  «       }|�r–|t        j                  v rzt	        |j
                  «      dk7  r%t        |j                   j                  d|z  «       �nGt        j                  |   |j                   j                  |j
                  d   ¬«      }�n
|t        j                  v rˆt	        |j
                  «      dk7  r%t        |j                   j                  d|z  «       �n»t        j                  |   |j                   j                  |j
                  d   |j
                  d   ¬«      }�np|dk(  rÉt	        |j
                  «      dk7  r"t        |j                   j                  d	«       �n1|j
                  d   j                  | j                  «       «      }|r<t        j                  |j                   j                  ||j
                  d   d
¬«      }�nÇt        |j
                  d   j                  d«       �n¢|dk(  rÏt	        |j
                  «      dk7  r"t        |j                   j                  d«       �nc|j
                  d   j                  | j                  «       «      }|r-t        j                  |j                   j                  |¬«      }�nt        j                  |j                   j                  |j
                  d   ¬«      }�nÎ|dk(  r‰t	        |j
                  «      dk7  r"t        |j                   j                  d«       �n�t        j                  |j                   j                  d|j
                  d   |j
                  d   «      }d|_        �n@|dk(  rˆt	        |j
                  «      dk7  r"t        |j                   j                  d«       �nt        j                  |j                   j                  d|j
                  d   |j
                  d   «      }d|_        n³|dk(  r0t        j"                  |j                  t%        d«      ¬«      |_         n~|dk(  r0t        j"                  |j                  t%        d«      ¬«      |_         nI| j&                  j(                  j+                  |«      rn#t        |j                   j                  d|z  «       | j-                  |«       t/        |t        j0                  «      rp|j                   j2                  rZ|j                   j4                  }|dv r| j7                  ||«      S |dk(  r| j9                  ||«      S |dk(  r| j;                  ||«      S |S )Nr   z%s() takes exactly one argumentr   r¬  rÇ   z %s() takes exactly two arguments)r~  r  r¬  úDcast() takes exactly two arguments and an optional typecheck keywordF©r4  r­  Ú	typecheckrÀ  r®  z#sizeof() takes exactly one argument)Úarg_typeÚcmodz"cmod() takes exactly two argumentsÚ%TÚcdivz"cdiv() takes exactly two argumentsÚ/r)  r¨   r¼  z*'%s' not a valid cython language construct)ÚdirrH  rŸ  ÚevalrB   )r  r  r§  r{  rÏ   ry   r   rL   r}  rÃ  rX  r   ÚTypecastNodeÚSizeofTypeNodeÚSizeofVarNoder‚  Ú	cdivisionr¸   r   rG   r–  r—  r8   rN   rp  r  rx   r¦  r¯  rÁ  )r$   r%   r  r4  r£  s        r&   rx  z,TransformBuiltinMethods.visit_SimpleCallNode(  s  € à—=‘=×4Ñ4Ó6ˆÚØÔ6×HÑHÑHÜ�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ð-NÐQYÑ-YÖZä6×HÑHÈÑRØŸ™×)Ñ)°4·9±9¸Q±<ôA’DàÔ8×KÑKÑKÜ�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ð-OÐRZÑ-ZÖ[ä6×IÑIÈ(ÑSØŸ™×)Ñ)°D·I±I¸a±LÈ4Ï9É9ÐUVÉ<ôY’Dà˜VÒ#Ü�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ø`öbð  Ÿ9™9 Q™<×7Ñ7¸×8HÑ8HÓ8JÓK�DÙÜ(×5Ñ5Ø ŸM™M×-Ñ-°DÀ$Ç)Á)ÈAÁ,ÐZ_ô ašô ˜dŸi™i¨™l×.Ñ.°Ö=Ø˜XÒ%Ü�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ð-RÖSàŸ9™9 Q™<×7Ñ7¸×8HÑ8HÓ8JÓK�DÙÜ(×7Ñ7¸¿¹×8IÑ8IÐTXÔYšä(×6Ñ6°t·}±}×7HÑ7HÐRV×R[ÑR[Ð\]ÑR^Ô_šØ˜VÒ#Ü�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ð-QÖRä$×/Ñ/°·±×0AÑ0AÀ3ÈÏ	É	ÐRSÉÐVZ×V_ÑV_Ð`aÑVbÓc�DØ%)�D–NØ˜VÒ#Ü�t—y‘y“> QÒ&Ü˜$Ÿ-™-×+Ñ+Ð-QÖRä$×/Ñ/°·±×0AÑ0AÀ3ÈÏ	É	ÐRSÉÐVZ×V_ÑV_Ð`aÑVbÓc�DØ%)�D•NØ˜UÒ"Ü )× 2Ñ 2°4·8±8Ä-ÐPUÓBVÔ W�•Ø˜^Ò+Ü )× 2Ñ 2°4·8±8Ä-ÐP^ÓB_Ô `�•Ø—‘×*Ñ*×@Ñ@ÀÔJØä�d—m‘m×'Ñ'ØBÀXÑMôOð 	×Ñ˜4Ô ä�dœI×4Ñ4Ô5¸$¿-¹-×:OÒ:OØŸ™×*Ñ*ˆIØÐ5Ñ5Ø×*Ñ*¨4°Ó;Ð;Ø˜FÒ"Ø×(Ñ(¨¨yÓ9Ð9Ø˜GÒ#Ø×)Ñ)¨$°	Ó:Ð:Øˆr)   c                 óh  — |j                   j                  «       }|dk(  �r |j                  j                  }|j                  j                  d «      }t        |«      dk7  s t        |«      dkD  st        |«      dk(  r%d|vr!t        |j                   j                  d«       n€|d   j                  | j                  «       «      }|rC|j                  dd«      }t        j                  |j                   j                  ||d   |¬«      }nt        |d   j                  d	«       | j                  |«       |S )
Nr¬  rÇ   r   rÊ  rÈ  r   FrÉ  rÀ  )r  r  r�  ry   r�  r/  rÏ   r   rL   rÃ  rX  r³   r   rÒ  r8   )r$   r%   r  ry   rŽ  r4  rÊ  s          r&   Úvisit_GeneralCallNodez-TransformBuiltinMethods.visit_GeneralCallNoden  s  € Ø—=‘=×4Ñ4Ó6ˆØ�vÓà×'Ñ'×,Ñ,ˆDØ×&Ñ&×9Ñ9¸$Ó?ˆFÜ�D“	˜Q’¤# f£+°¢/Ü˜“[ AÒ%¨+¸VÑ*CÜ�d—m‘m×'Ñ'Ø\õ^ð ˜A‘w×.Ñ.¨t×/?Ñ/?Ó/AÓB�ÙØ &§
¡
¨;¸Ó >�IÜ$×1Ñ1ØŸ™×)Ñ)°¸dÀ1¹gÐQZô\‘Dô ˜$˜q™'Ÿ+™+ |Ô4à×Ñ˜4Ô Øˆr)   )r:   r;   r<   r=   rC   rÂ   r¤  r  r�  r�  r¦  rª  r¬  r¯  r�  rÁ  rÄ  r  rÖ  rx  r×  ri   rj   s   @r&   r‡  r‡  B  sb   ø„ ñô
+òò1ò1òò&	ò%7òN	ò/òò9òvò6Rôô
ò
DöLr)   r‡  c                   ó@   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	ˆ xZ
S )ÚReplaceFusedTypeChecksa0  
    This is not a transform in the pipeline. It is invoked on the specific
    versions of a cdef function with fused argument types. It filters out any
    type branches that don't match. e.g.

        if fused_t is mytype:
            ...
        elif fused_t in other_fused_type:
            ...
    c                 óX   •— t         ‰| �  «        || _        ddlm}  |d¬«      | _        y )Nr   )ÚConstantFoldingT)Ú
reevaluate)rB   rC   rç  ÚOptimizerÛ  r£  )r$   rç  rÛ  rH   s      €r&   rC   zReplaceFusedTypeChecks.__init__�  s%   ø€ Ü‰ÑÔØ&ˆÔå-Ù(°DÔ9ˆ�r)   c                 óF   — | j                  |«       | j                  |«      S )zc
        Filters out any if clauses with false compile time type check
        expression.
        ©r8   r£  r#   s     r&   rÐ  z'ReplaceFusedTypeChecks.visit_IfStatNode—  s!   € ð
 	×Ñ˜4Ô Ø�~‰~˜dÓ#Ð#r)   c                 óF   — | j                  |«       | j                  |«      S )z9
        Fold constant condition of GILStatNode.
        rß  r#   s     r&   rE  z(ReplaceFusedTypeChecks.visit_GILStatNodeŸ  s!   € ð 	×Ñ˜4Ô Ø�~‰~˜dÓ#Ð#r)   c                 ó  — t        j                  d¬«      5  |j                  j                  | j                  «      }|j
                  j                  | j                  «      }d d d «       �r‹�rˆt        j                  |j                  d¬«      }t        j                  |j                  d¬«      }| j                  ||j                  j                  «      }|j                  }|dv rG| j                  ||j
                  j                  «      }|j                  |«      }|dv }|r|s|s|s|S |S |dv rÃt        |t        j                  «      r|j                  }|j                   r"t#        |j                  j                  d«       |S |j                   s"t#        |j
                  j                  d	«       |S t        j$                  |«      }	|	D ]   }
|j                  |
«      sŒ|d
k(  r|c S |c S  |dk(  r|S |S |S # 1 sw Y   �ŒšxY w)NT)ÚignoreFrv   )ÚisÚis_notú==z!=)rã  rå  )Úinr¨  zType is fusedz-Can only use 'in' or 'not in' on a fused typeræ  r¨  )r   Úlocal_errorsr~  rÃ  rç  r  r   r  rL   Úspecialize_typer·  Úsame_asrN   r   ÚCTypedefTypeÚtypedef_base_typerD  r   Úget_specialized_types)r$   r%   Útype1Útype2Ú
false_nodeÚ	true_nodeÚopÚis_sameÚeqÚtypesÚspecialized_types              r&   rª  z+ReplaceFusedTypeChecks.visit_PrimaryCmpNode¦  sÊ  € Ü× Ñ ¨Ö-Ø—M‘M×1Ñ1°$×2BÑ2BÓCˆEØ—M‘M×1Ñ1°$×2BÑ2BÓCˆE÷ .ò ’UÜ"×+Ñ+¨D¯H©H¸EÔBˆJÜ!×*Ñ*¨4¯8©8¸4Ô@ˆIà×(Ñ(¨°·±×0AÑ0AÓBˆEØ—‘ˆBàÐ1Ñ1Ø×,Ñ,¨U°D·M±M×4EÑ4EÓF�àŸ-™-¨Ó.�Ø˜<Ð'�á¡©G¹BØ$Ð$ð6 Ðð3 Ð'Ñ'ô ˜e¤Z×%<Ñ%<Ô=Ø!×3Ñ3�Eà—>’>Ü˜$Ÿ-™-×+Ñ+¨_Ô=ð" Ðð! ŸšÜ˜$Ÿ-™-×+Ñ+ØIôKð Ðô '×<Ñ<¸UÓC�Eã,1Ð(Ø Ÿ=™=Ð)9Õ:Ø! TšzØ'0Ò 0à'1Ò 1ð -2ð ˜X’~Ø(Ð(àÐàˆ÷_ .Ñ-ús   —AG:Ç:Hc                 óˆ   — 	 |j                  | j                  j                  «      S # t        $ r t	        |d«       |cY S w xY w)NzType is not specific)rÅ  rç  rÄ  ÚKeyErrorr   )r$   r4  rL   s      r&   rè  z&ReplaceFusedTypeChecks.specialize_typeØ  sA   € ð	Ø—?‘? 4×#3Ñ#3×#EÑ#EÓFÐFøÜò 	Ü�#Ð-Ô.ØŠKð	ús   ‚$' §AÁ Ac                 ó(   — | j                  |«       |S r!   r  r#   s     r&   r  z!ReplaceFusedTypeChecks.visit_Nodeß  r:  r)   )r:   r;   r<   r=   rC   rÐ  rE  rª  rè  r  ri   rj   s   @r&   rÙ  rÙ  …  s'   ø„ ñ	ô:ò$ò$ò0òdör)   rÙ  c                   óF   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
ˆ xZS )	ÚDebugTransformz9
    Write debug information for this Cython module.
    c                 ó¶   •— t         ‰| �  |«       t        «       | _        | j                  j
                  | _        |j                  | _        g | _	        d| _
        y rA   )rB   rC   r)  ÚvisitedrG   Úgdb_debug_outputwriterÚtbÚc_fileÚc_output_fileÚnested_funcdefsÚregister_stepinto)r$   rG   Úoptionsrà   rH   s       €r&   rC   zDebugTransform.__init__é  sL   ø€ Ü‰Ñ˜Ô!Ü“uˆŒð —,‘,×5Ñ5ˆŒà#Ÿ]™]ˆÔð  "ˆÔð "'ˆÕr)   c                 ó°  — |j                   | j                  _        t        |j                   |j                  d   j
                  | j                  ¬«      }| j                  j                  d|«       | j                  j                  d«       | j                  |«       | j                  D ]  }| j                  |«       Œ d| _        | j                  |«       d| _        | j                  j                  d«       | j                  j                  d«       i }|j                  j                  j!                  «       D ]m  \  }}|j"                  | j$                  vsŒ|j&                  j)                  d«      rŒ;|j*                  j,                  rŒR|j*                  j.                  rŒi|||<   Œo | j1                  |«       | j                  j                  d«       |S )	Nr   )rž  ÚfilenameÚ
c_filenameÚModuleÚ	FunctionsTFÚGlobalsÚ__pyx_)Úfull_module_namerþ  rž  r   rL   r  r   Ústartr8   r  r  r  Ú serialize_modulenode_as_functionÚendrÉ  r>  r\  rþ  rü  rx   rÐ  r4  r¹  rA  Úserialize_local_variables)r$   r%   r‹   Únested_funcdefr>  rØ  rÙ  s          r&   rQ   zDebugTransform.visit_ModuleNodeù  sk  € Ø"×3Ñ3ˆ�‰ÔÜØ×-Ñ-Ø—X‘X˜a‘[×)Ñ)Ø×)Ñ)ô+ˆð
 	�‰�‰�h Ô&ð 	�‰�‰�kÔ"à×Ñ˜4Ô ð #×2Ô2ˆNØ×"Ñ" >Õ2ð 3ð "&ˆÔØ×-Ñ-¨dÔ3Ø!&ˆÔØ�‰�‰�KÔ ð 	�‰�‰�iÔ Øˆà—J‘J×&Ñ&×,Ñ,Ö.‰DˆAˆqØ× Ñ ¨¯©Ò4Ø—F‘F×%Ñ% hÕ/Ø—F‘F×'Ó'Ø—F‘F×,Ó,Ø�˜’
ð /ð 	×&Ñ& wÔ/Ø�‰�‰�IÔð ˆr)   c           
      óN  — | j                   j                  |j                  j                  «       t	        |dd«      r|S | j
                  r| j                  j                  |«       |S |j                  €d}n |j                  j                  j                  }|j                  j                  xs |j                  j                  }t        |j                  j                  xs t	        |dd«      |||j                  j                  t        |j                  d   «      ¬«      }| j                   j#                  d|¬	«       | j                   j#                  d
«       | j%                  |j                  j&                  «       | j                   j)                  d
«       | j                   j#                  d«       |j                  j*                  D ]L  }| j                   j#                  |j                  «       | j                   j)                  |j                  «       ŒN | j                   j)                  d«       | j                   j#                  d«       d| _        | j-                  |«       d| _        | j                   j)                  d«       | j                   j)                  d«       |S )Nr<  Frm  rx   z	<unknown>r   )rx   rï  Úpf_cnamerþ  ÚlinenoÚFunction©r‹   ÚLocalsÚ	ArgumentsÚStepIntoFunctionsT)rü  rF  rç  rþ  r-  r  r  r¶   r§  rî  Ú
func_cnameÚpyfunc_cnamer   rx   rÂ  rL   rþ  r  r  r>  r  Úarg_entriesr8   )r$   r%   r  rï  r‹   rá   s         r&   r  z DebugTransform.visit_FuncDefNode!  sæ  € Ø�‰×Ñ˜×)Ñ)×8Ñ8Ô9ä�4˜ uÔ-ØˆKà×!Ò!Ø× Ñ ×'Ñ'¨Ô-ØˆKð �<‰<ÐØ‰Hà—|‘|×)Ñ)×4Ñ4ˆHð
 —
‘
×'Ñ'Ò@¨4¯:©:×+@Ñ+@ˆäØ—‘—‘ÒF¤G¨D°&¸+Ó$FØØØ×+Ñ+×:Ñ:Ü�t—x‘x ‘{Ó#ô%ˆð 	�‰�‰�j¨ˆÔ.à�‰�‰�hÔØ×&Ñ& t×'7Ñ'7×'?Ñ'?Ô@Ø�‰�‰�HÔà�‰�‰�kÔ"Ø×#Ñ#×/Ô/ˆCØ�G‰G�M‰M˜#Ÿ(™(Ô#Ø�G‰G�K‰K˜Ÿ™Õ!ð 0ð 	�‰�‰�KÔ à�‰�‰Ð)Ô*Ø!%ˆÔØ×Ñ˜4Ô Ø!&ˆÔØ�‰�‰Ð'Ô(Ø�‰�‰�JÔàˆr)   c                 óz  — | j                   r�|j                  �‘|j                  j                  r{t        |dd«      rn|j                  j
                  �Xt        |j                  j
                  ¬«      }| j                  j                  d|¬«       | j                  j                  d«       | j                  |«       |S )NÚ	is_calledFr¨   ÚStepIntoFunctionr  )r  r4  r¹  r-  rî  r  r   rþ  r  r  r8   ©r$   r%   r‹   s      r&   r  zDebugTransform.visit_NameNodeR  s�   € Ø×"Ò"Ø—	‘	Ð%Ø—	‘	×&Ò&Ü˜˜k¨5Ô1Ø—
‘
×%Ñ%Ð1ô ˜dŸj™j×3Ñ3Ô4ˆEØ�G‰G�M‰MÐ,°EˆMÔ:Ø�G‰G�K‰KÐ*Ô+à×Ñ˜4Ô Øˆr)   c                 óš   — | j                  |t        |j                  j                  d«      d   |j	                  «       dddd¬«      «       y)zÆ
        Serialize the module-level code as a function so the debugger will know
        it's a "relevant frame" and it will know where to set the breakpoint
        for 'break modulename'.
        rÎ  rÈ   rm  Ú1ÚTrue)rx   rï  r  rþ  r  Úis_initmodule_functionN)Ú!_serialize_modulenode_as_functionr   r  Ú
rpartitionÚmodule_init_func_cnamer#   s     r&   r  z/DebugTransform.serialize_modulenode_as_functiond  sN   € ð 	×.Ñ.¨t´TØ×&Ñ&×1Ñ1°#Ó6°rÑ:Ø×-Ñ-Ó/Øð ØØ#)ô	6
õ 		r)   c                 ó@  — | j                   j                  d|¬«       | j                   j                  d«       | j                  |j                  j                  «       | j                   j                  d«       | j                   j                  d«       | j                   j                  d«       | j                   j                  d«       d| _        | j                  |«       d| _        | j                   j                  d«       | j                   j                  d«       y )Nr  r  r  r  r  TF)rþ  r  r  rÉ  r>  r  r  r8   r  s      r&   r$  z0DebugTransform._serialize_modulenode_as_functionu  s¾   € Ø�‰�‰�j¨ˆÔ.à�‰�‰�hÔØ×&Ñ& t§z¡z×'9Ñ'9Ô:Ø�‰�‰�HÔà�‰�‰�kÔ"Ø�‰�‰�KÔ à�‰�‰Ð)Ô*Ø!%ˆÔØ×Ñ˜4Ô Ø!&ˆÔØ�‰�‰Ð'Ô(à�‰�‰�JÕr)   c                 ó
  — |j                  «       D �]o  }|j                  sŒ|j                  j                  rd}nd}|j                  rpt
        j                  ›d|j                  j                  ›�}|j                  j                  j                  ›d|j                  j                  ›d|j                  ›�}nP|j                  r,t
        j                  ›d|j                  ›�}|j                  }n|j                  }|j                  }|j                  sd}nt        |j                  d   «      }t        |j                  ||||¬«      }| j                   j#                  d|«       | j                   j%                  d«       �Œr y )	NÚPythonObjectÚCObjectz->rÎ  Ú0r   )rx   rï  rþ  r4  r  ÚLocalVar)r+  rï  r4  r€  r  r   Úcur_scope_cnameÚouter_entryrÉ  rÜ  rþ  rx   rð  rL   rÂ  r   rþ  r  r  )r$   r>  rî  Úvartyperï  Úqnamer  r‹   s           r&   r  z(DebugTransform.serialize_local_variables‡  s1  € Ø—^‘^×%ˆEØ—;’;àØ�z‰z×%Ò%Ø(‘à#�à×!Ò!ô %+×$:Ó$:Ø$)×$5Ñ$5×$;Ò$;ð=�ð ',§k¡k×&=Ñ&=×&LÓ&LØ&+§k¡k×&6Ó&6Ø&+§j¢jð2‘ð ×!Ò!Ü$*×$:Ó$:Ø$)§K¢Kð1�à×,Ñ,‘àŸ™�Ø×,Ñ,�à—9’9ð ‘ä˜UŸY™Y q™\Ó*�äØ—Z‘ZØØ$ØØôˆEð �G‰G�M‰M˜* eÔ,Ø�G‰G�K‰K˜
Ö#ñU &r)   )r:   r;   r<   r=   rC   rQ   r  r  r  r$  r  ri   rj   s   @r&   rú  rú  ä  s-   ø„ ñô'ò &òP/òbò$ò" ö$+$r)   rú  c                   óv   ‡ — e Zd ZdZˆ fd„Zdefd„Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zˆ xZS )ÚHasNoExceptionHandlingVisitorz½
    Used by finalExceptClauseNode to work out if the body
    needs to handle exceptions at all. This includes:

    1. Can raise an exception.
    2. May try to access the traceback.
    c                 ó>   •— d| _         d | _        t        ‰| �  «        y rS   )Úuses_no_exceptionsÚassignment_lhsrB   rC   r  s    €r&   rC   z&HasNoExceptionHandlingVisitor.__init__½  s   ø€ Ø"&ˆÔØ"ˆÔÜ‰ÑÕr)   Úreturnc                 ó<   — | j                  |«       | j                  S r!   )r$  r4  r#   s     r&   r†  z&HasNoExceptionHandlingVisitor.__call__Â  s   € Ø�
‰
�4ÔØ×&Ñ&Ð&r)   c                 ó   — d| _         y rA   ©r4  r#   s     r&   r  z(HasNoExceptionHandlingVisitor.visit_NodeÆ  s
   € Ø"'ˆÕr)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   rf   z0HasNoExceptionHandlingVisitor.visit_ExprStatNodeÉ  r   r)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   r[   z0HasNoExceptionHandlingVisitor.visit_StatListNodeÌ  r   r)   c                 ó,   — |j                   sd| _        y y rA   )rE  r4  r#   s     r&   rU   z,HasNoExceptionHandlingVisitor.visit_ExprNodeÏ  s   € Ø�ŠØ&+ˆDÕ#ð r)   c                 ó   — d| _         y rA   r9  r#   s     r&   r’  z,HasNoExceptionHandlingVisitor.visit_CallNodeÓ  s   € ð #(ˆÕr)   c                  ó   — y r!   r"   r#   s     r&   r×  z0HasNoExceptionHandlingVisitor.visit_PassStatNodeØ  r  r)   c                 ó@   — | j                   sy | j                  |«       y r!   )r4  r8   r#   s     r&   ræ  z2HasNoExceptionHandlingVisitor.visit_ReturnStatNodeÛ  s   € Ø×&Ò&ØØ×Ñ˜4Õ r)   c                 óH  — | j                   sy |j                  | _        | j                  |j                  «       d | _        |j                  j
                  }|j                  s|j                  s|j                  sd| _         | j                   sy | j                  |dg¬«       y )NFr©   r9  )
r4  r©   r5  r$  rª   r4  Ú
is_numericr€  Úis_memoryviewslicer8   )r$   r%   Úrhs_types      r&   rÂ   z8HasNoExceptionHandlingVisitor.visit_SingleAssignmentNodeà  sƒ   € Ø×&Ò&ØØ"Ÿh™hˆÔØ�
‰
�4—8‘8ÔØ"ˆÔØ—8‘8—=‘=ˆØ×#Ò# x×';Ò';¸x×?ZÒ?Zð ',ˆDÔ#Ø×&Ò&ØØ×Ñ˜4¨%¨ÐÕ1r)   c                 ó  — | j                   sy |j                  }| j                  |u rI|j                  s<|j                  s/|j
                  s"|j                  s|j                  sd| _         y y y y y y |j                  r"|j                  r|j                  rd| _         y y y |j                  s$|j
                  s|j                  s|j                  r8|j                  s|j                  r|j                  j                  sd| _         y y y d| _         y rA   )r4  rî  r5  r  Úis_argÚis_localrð  r  Úis_cpp_optionalrå  Ú
cf_is_nullÚcf_maybe_nullr4  rA  r  s      r&   r  z,HasNoExceptionHandlingVisitor.visit_NameNodeï  s÷   € Ø×&Ò&ØØ—
‘
ˆØ×Ñ $Ñ&Ø×$Ò$¨¯ªØ—N’N e×&6Ò&6¸%×:LÒ:LØ*/�Ô'Øð ;MÐ&6�Nð )5Ð$ð
 ×ÒØ×(Ò(¨T×-CÒ-Cà.3�DÔ+Øð .DÐ(ð —’ §¢°5×3CÒ3CÀu×GYÒGYØ—O’O t×'9Ò'9À4Ç9Á9×CWÒCWð /4�DÔ+Øð DXÐ'9ð +0�Ô'Ør)   c                 ó|  — |j                   rd| _        nA|j                  j                  s|j                  j
                  r| j                  |urd| _        |j                  j                  s3|j                  j                  s|j                  j                  sd| _        | j                  r| j                  |«       y y rA   )
Ú
is_py_attrr4  r4  rB  rî  rG  r5  r€  rA  r8   r#   s     r&   r¤  z1HasNoExceptionHandlingVisitor.visit_AttributeNode
  s‹   € Ø�?Š?Ø&+ˆDÕ#Ø�i‰i×*Ò*¨d¯j©j×.HÒ.HÈd×NaÑNaÐimÑNmð ',ˆDÔ#à—	‘	×%Ò%¨¯©×)=Ò)=ÀÇÁ×A]ÒA]Ø&+ˆDÔ#Ø×"Ò"Ø×Ñ˜tÕ$ð #r)   c                 óÎ   — |j                   j                  j                  s'|j                   j                  j                  sd| _        | j                  sy | j                  |«       y rA   )r°   r4  Úis_arrayÚis_ptrr4  r8   r#   s     r&   rY  z-HasNoExceptionHandlingVisitor.visit_IndexNode  sE   € Ø—	‘	—‘×'Ò'¨4¯9©9¯>©>×+@Ò+@Ø&+ˆDÔ#Ø×&Ò&ØØ×Ñ˜4Õ r)   c                 ó&   — | j                  |«       y r!   r  r#   s     r&   Úvisit_CoerceToTempNodez4HasNoExceptionHandlingVisitor.visit_CoerceToTempNode  r   r)   )r:   r;   r<   r=   rC   rp  r†  r  rf   r[   rU   r’  r×  ræ  rÂ   r  r¤  rY  rP  ri   rj   s   @r&   r2  r2  µ  sU   ø„ ñôð
' ó 'ò(ò!ò!ò,ò(ò
ò!ò
2òò6%ò!ö!r)   r2  r"   )Orõ  r¯  rY  r   r   r   r·  r   rm  r   r   r   r   r   r   r   r   rÑ  r   r   r   r   r   r   r	   r
   r   ÚStringEncodingr   r   r   r   r   r   r?   rl   rµ   r    r´   rn   r  r•   rÎ   rÓ   rh  rT  rN  rÍ   rq  rƒ  r™  r§  r  r¡  rÇ  rÏ  rø  r+  r3  rI  r‡  r)  rM  ri  rs  rŽ  r«  r¼  rÆ  r}   rñ  r  r>  rN  rz  r‡  rÙ  rú  r2  r"   r)   r&   Ú<module>rR     s  ðÛ Ø €‡�ò "™&ð "©ð "¹6ð "Éð "Ùð"Ù)/ð"Ù9?ð"á ð"á/5ð"áEKð"ñ ð"ñ &,ð"ñ 39ð"ñ CIð"ñ OUð"ñ !ñ	"ó Û Û 
Ý å Ý Ý Ý Ý Ý Ý Ý ç 2ß JÑ Jß *Ý &Ý )ß ?Ó ?÷ñ ôBI�Oô IôX )�\Ô (ð ^Ð ØEÐ ØQÐ ôK,Ð&ô K,ô\!¨Kô !ô<V! ;ô V!òr,8ò\"òD	ð ‡�ðH#¨ð H#°dò H#ó ðH#ðV ‡�ð$@¨ð $@À4ð $@ÐSWð $@Ðcgò $@ó ð$@ôN6�?Ð$4ô 6ôr6Ð+Ð-=ô 6ô*{	% /ô {	%ô|l'˜_Ð.>ô l'ô^C6Ð$Ð&6ô C6ôL/¨+Ð7Gô /ô2`6Ð 0Ð2Bô `6ôFz$Ð/Ð1Aô z$ôz,(˜Ð0@ô ,(ô^6˜/ô 6ôr`	 <ô `	òFô$} |ô }ô@]
 /ô ]
ô@% ô %ô>:˜\ô :ôzk˜OÐ-=ô kô\3˜ô 3ôl) ?ô )ôX5˜Oô 5ôp<˜ô <ô~Z˜ô ZôzQ+˜?ô Q+ôh36Ð(Ð*:ô 36ôls%Ðô s%ôl"�\Ð#3ô "ôJ@˜lô @ôF
\Ð-ô \ô~N$�_ô N$ôbk! Kõ k!r)   