Ë
    Ç[;jŠ¥  ã                   ó’   — d dl Z d dlZddlmZmZmZmZmZmZ ddlm	Z	m
Z
mZmZ ddlmZmZmZ ddlmZ ddlmZmZ  G d	„ d
e«      Zy)é    Né   )Ú	ExprNodesÚ
PyrexTypesÚParseTreeTransformsÚStringEncodingÚErrorsÚNaming)Ú	CloneNodeÚCodeObjectNodeÚ	ProxyNodeÚ	TupleNode)ÚFuncDefNodeÚStatListNodeÚDefNodeé   )Ú
OrderedSet)ÚerrorÚCannotSpecializec                   óö   ‡ — e Zd ZdZdZdZdZdZdZdZ	e
j                  g d¢z   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#ˆ fd„Z$d„ Z%ˆ xZ&S )ÚFusedCFuncDefNodea{  
    This node replaces a function with fused arguments. It deep-copies the
    function for every permutation of fused types, and allocates a new local
    scope for it. It keeps track of the original function in self.node, and
    the entry of the original function in the symbol table is given the
    'fused_cfunction' attribute which points back to us.
    Then when a function lookup occurs (to e.g. call it), the call can be
    dispatched to the right function.

    node    FuncDefNode    the original function
    nodes   [FuncDefNode]  list of copies of node with different specific types
    py_func DefNode        the fused python function subscriptable from
                           Python space
    __signatures__         A DictNode mapping signature specialization strings
                           to PyCFunction nodes
    resulting_fused_function  PyCFunction for the fused DefNode that delegates
                              to specializations
    fused_func_assignment   Assignment of the fused function to the function name
    defaults_tuple          TupleNode of defaults (letting PyCFunctionNode build
                            defaults would result in many different tuples)
    specialized_pycfuncs    List of synthesized pycfunction nodes for the
                            specializations

    fused_compound_types    All fused (compound) types (e.g. floating[:])
    N)Ú__signatures__Úresulting_fused_functionÚfused_func_assignmentc                 ó†  •— t         ‰| �  |j                  «       g | _        || _        t        | j                  t        «      }|r| j                  |«       n| j                  |«       | j                  D ]¦  }|j                  j                  j                  rJ ‚|j                  j                  j                  rJ ‚|j                  j                  r|j                  j                  rJ ‚|rŒx|j                  j                  sŒ�|j                  j                   rŒ¦J ‚ | |j                  _        | j                  d d  | _        y ©N)ÚsuperÚ__init__ÚposÚnodesÚnodeÚ
isinstancer   Úcopy_defÚ	copy_cdefÚentryÚtypeÚis_fusedÚlocal_scopeÚreturn_typeÚcfunc_declaratorÚoptional_arg_countÚop_arg_structÚfused_cfunctionÚstats)Úselfr    ÚenvÚis_defÚnÚ	__class__s        €úbG:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\Cython/Compiler/FusedNode.pyr   zFusedCFuncDefNode.__init__2   sò   ø€ Ü‰Ñ˜Ÿ™Ô"àˆŒ
ØˆŒ	ä˜DŸI™I¤wÓ/ˆÙà�M‰M˜#Õà�N‰N˜3Ôð —”ˆAØ—w‘w—|‘|×,Ò,Ð,Ð,Ø—}‘}×0Ñ0×9Ò9Ð9Ð9Ø×Ñ×(Ò(ØŸ=™=×1Ò1Ð1Ð1â˜a×0Ñ0×CÓCØ—v‘v×+Ó+Ð+Ð+ð ð &*ˆ�
‰
Ô"ð —Z‘Z¡�]ˆ�
ó    c           	      óV  — t        j                  | j                  j                  D �cg c]%  }|j                  j
                  sŒ|j                  ‘Œ' c}«      }| j                  |«      }t        j                  |«      }|| _        | j                  j                  |j                  v r/|j                  j                  | j                  j                  «       |D �]  \  }}t        j                  | j                  «      }| j                  j                  j                  |j                  _        | j                  |j                  |«       | j                  j                   j#                  |«      |_        t%        |«      |_        |j)                  |«       | j+                  |||«       | j-                  ||| j                  j                  ||«       t        j.                  |j                  |«       d|j                  _        |j                  |j2                  |j                  j4                  <   t7        | j                  j                  |j                  «      D �	�
cg c]8  \  }	}
|	j                  j
                  r|
j                  j9                  dd¬«      ‘Œ: }}	}
t;        j<                  |j4                  › ddj?                  |«      › d�«      |_        | jA                  |«      r�Œ n | j                  | _!        | jE                  | j                  |d¬«      | _#        yc c}w c c}
}	w )	zh
        Create a copy of the original def or lambda function for specialized
        versions.
        TÚ )Úfor_displayÚ[Ú,Ú]©r0   N)$r   Úuniquer    Úargsr%   r&   Ú_get_fused_base_typesÚ get_all_specialized_permutationsÚfused_compound_typesr$   Úpyfunc_entriesÚremoveÚcopyÚdeepcopyÚ	signatureÚ_specialize_function_argsr(   Ú
specializer   Úcode_objectÚanalyse_declarationsÚcreate_new_local_scopeÚspecialize_copied_defÚspecialize_entryÚusedÚentriesÚnameÚzipÚdeclaration_coder   ÚEncodedStringÚjoinÚreplace_fused_typechecksÚorig_py_funcÚmake_fused_cpdefÚpy_func)r.   r/   Úargr@   Úfused_typesÚpermutationsÚcnameÚfused_to_specificÚcopied_nodeÚfargÚsargÚspecialised_type_namess               r3   r"   zFusedCFuncDefNode.copy_defO   s‡  € ô
  *×0Ñ0Ø!%§¡§¢ÓE¡˜#°3·8±8×3DÓ3DˆS�X‹X ÑEó GÐà×0Ñ0Ð1EÓFˆÜ!×BÑBÀ;ÓOˆà$8ˆÔ!à�9‰9�?‰?˜c×0Ñ0Ñ0Ø×Ñ×%Ñ% d§i¡i§o¡oÔ6ä(4Ñ$ˆEÐ$ÜŸ-™-¨¯	©	Ó2ˆKà*.¯)©)¯/©/×*CÑ*CˆK×ÑÔ'à×*Ñ*¨;×+;Ñ+;Ð=NÔOØ&*§i¡i×&;Ñ&;×&FÑ&FØ4Eó'GˆKÔ#ä&4°[Ó&AˆKÔ#Ø×,Ñ,¨SÔ1ð ×'Ñ'¨°SÐ:KÔLØ×&Ñ& {°E¸4¿9¹9¿?¹?Ø'8Ð:NôPô ×'Ñ'¨×(9Ñ(9¸5ÔAØ%)ˆK×ÑÔ"Ø2=×2CÑ2CˆC�K‰K˜×)Ñ)×.Ñ.Ñ/ô %(¨¯	©	¯©¸×8HÑ8HÔ$Iô&á$I‘L�T˜4Ø—9‘9×%Ò%ð —	‘	×*Ñ*¨2¸4Ð*Õ@Ø$Ið #ñ &ô
  .×;Ñ;¸{×?OÑ?OÐ>PÐPQÐRU×RZÑRZÐ[qÓRrÐQsÐstÐ<uÓvˆKÔà×0Ñ0°Ö=Ùð9 )5ð< !ŸI™IˆÔØ×,Ñ,¨T¯Y©Y¸ÀDÐ,ÓIˆ�ùòQ Fùó:&s   ¨L ÁL É=L%c                 ó  — | j                   j                  j                  «       }| j                   j                  x| _        }d| j                   _        |r%|j
                  j                  |j                  «       | j                   j                  j                  «       }|| _	        g }|D �]‘  \  }}t        j                  | j                   «      }	 |j                  j                  |«      }	|j                  }
|	j!                  |
|«       |j"                  D ]  }|
j$                  |j$                  k(  sŒ|	j'                  |j                  «      sŒ9||_        |j                  j(                  s|
j(                  |j                  _        |}
|j                  }	 n |j+                  |
«       |	|_        |	|
c|
_        |	_        |
j,                  xs< | j                   j                  j.                  xs |j0                  xs |
j2                  |
_        | j                   j4                  j6                  r(| j                   j4                  j9                  |	||¬«       |	j:                  |_        | j=                  |||«       | j?                  |j4                  j@                  |«       |jC                  |«       |j                  rl|j
                  j                  |j                  j                  «       | jE                  |j                  || j                   j                  jF                  ||«       | jI                  |«      r�Œ’ n | j                   j                  |j"                  v rB|j"                  jK                  | j                   j                  «      }||j"                  ||dz    n|j"                  jM                  |«       |r| jO                  ||d¬«      | _        y|| _        y# t        $ r! t        |j                  d«       d| _        Y  yw xY w)zf
        Create a copy of the original c(p)def function for all specialized
        versions.
        NzQReturn type is a fused type that cannot be determined from the function arguments)Úfused_cnamer   Fr;   )(r    r%   r?   rW   rU   rA   rB   r$   Úget_fused_typesr@   rC   rD   rG   r   r   r   rL   Úcfunc_entriesr[   Úsame_as_resolved_typeÚ
func_cnameÚappendrM   Údefined_in_pxdÚis_c_class_scopeÚ
is_cmethodr)   r*   Údeclare_optional_arg_structr(   rJ   rF   r=   Údeclare_cpdef_wrapperrK   Úas_variablerT   ÚindexÚextendrV   )r.   r/   rZ   rU   rY   Únew_cfunc_entriesr[   r\   r]   r%   r$   Ú
orig_entryÚcindexs                r3   r#   zFusedCFuncDefNode.copy_cdef   sp  € ð
 —y‘y—~‘~×FÑFÓHˆð ,0¯9©9×+<Ñ+<Ð<ˆÔ˜LØ ˆ�	‰	ÔÙØ×Ñ×%Ñ% l×&8Ñ&8Ô9à—i‘i—n‘n×4Ñ4Ó6ˆØ$/ˆÔ!àÐÜ(4Ñ$ˆEÐ$ÜŸ-™-¨¯	©	Ó2ˆKðØ"×'Ñ'×2Ñ2Ð3DÓE�ð  ×%Ñ%ˆEØ×!Ñ! %¨Ô/ð "×/Ô/�
Ø—;‘; *×"2Ñ"2Ó2°t×7QÑ7QÐR\×RaÑRaÕ7bØ(2�KÔ%Ø&×,Ñ,×7Ò7Ø7<×7GÑ7G˜×)Ñ)Ô4Ø&�EØ%Ÿ?™?�DÙð 0ð "×(Ñ(¨Ô/à#ˆKÔØ%)¨5Ð"ˆEŒJ˜œ
àŸ*™*ò +ØŸ)™)Ÿ/™/×8Ñ8ò+à×.Ñ.ò+ð  ×*Ñ*ð ŒJð
 �y‰y×)Ñ)×<Ò<Ø—	‘	×*Ñ*×FÑFØ+/°À%ð Gô Ið '+×&6Ñ&6ˆKÔ#Ø×'Ñ'¨°SÐ:KÔLð ×*Ñ*¨;×+GÑ+G×+LÑ+LØ+<ô>ð
 ×-Ñ-¨cÔ2Ø×"Ò"Ø×"Ñ"×)Ñ)¨+×*=Ñ*=×*CÑ*CÔDà×*Ñ*Ø#×+Ñ+¨U°D·I±I·O±O×4OÑ4OØ)¨;ô8ð ×0Ñ0°Ö=Ùðs )5ðx �9‰9�?‰?˜c×/Ñ/Ñ/Ø×&Ñ&×,Ñ,¨T¯Y©Y¯_©_Ó=ˆFØ1BˆC×Ñ˜f V¨A¡XÑ.à×Ñ×$Ñ$Ð%6Ô7áØ×0Ñ0°¸sØ8=ð 1ó ?ˆD�Lð (ˆD�LøôA $ò ä�k—o‘oð (Bô Cà#�”Úðús   ÃO!Ï!&PÐ
Pc                 óR   — g }t        «       }|D ]  }|j                  ||¬«       Œ |S )zq
        Get a list of unique basic fused types, from a list of
        (possibly) compound fused types.
        )ÚresultÚseen)Úsetrc   )r.   r@   Ú
base_typesru   Ú
fused_types        r3   r>   z'FusedCFuncDefNode._get_fused_base_typesÛ   s3   € ð
 ˆ
Ü‹uˆÛ.ˆJØ×&Ñ&¨j¸tÐ&ÕDð /àÐr4   c                 ó2  — |D ]’  }|j                   j                  sŒ|j                   j                  |«      |_         |j                   j                  r%|j                   j	                  |j
                  «       |j                  sŒ‚d|j                  _        Œ” y )NT)r%   r&   rG   Úis_memoryviewsliceÚvalidate_memslice_dtyper   Ú
annotationÚuntyped)r.   r=   r\   rX   s       r3   rF   z+FusedCFuncDefNode._specialize_function_argsæ   sh   € ÛˆCØ�x‰x× Ó ØŸ8™8×.Ñ.Ð/@ÓA�”Ø—8‘8×.Ò.Ø—H‘H×4Ñ4°S·W±WÔ=Ø—>“>ð .2�C—N‘NÕ*ñ r4   c                 óŒ   — |j                  |«       ||j                  _        d|_        | j                  j                  |«       y)a¥  
        Create a new local scope for the copied node and append it to
        self.nodes. A new local scope is needed because the arguments with the
        fused types are already in the local scope, and we need the specialized
        entries created after analyse_declarations on each specialized version
        of the (CFunc)DefNode.
        f2s is a dict mapping each fused type to its specialized version
        FN)Úcreate_local_scoper'   r\   Úhas_fused_argumentsr   rg   )r.   r    r/   Úf2ss       r3   rJ   z(FusedCFuncDefNode.create_new_local_scopeñ   s<   € ð 	×Ñ Ô$Ø-0ˆ×ÑÔ*ð $)ˆÔ Ø�
‰
×Ñ˜$Õr4   c                 ó€  — | j                  |«      }|D �cg c]  }t        j                  ||«      ‘Œ }}dj                  |«      |_        t        j
                  ||j                  j                  «      |j                  _        |j                  |j                  _        |j                  |j                  _	        yc c}w )zwSpecialize the copy of a DefNode given the copied node,
        the specialization cname and the original DefNode entryÚ|N)
r>   r   Úspecialization_signature_stringrS   Úspecialized_signature_stringÚget_fused_cnamer$   Úpymethdef_cnameÚdocÚ	doc_cname)	r.   r    r[   Úpy_entryr�   r@   rY   rx   Útype_stringss	            r3   rK   z'FusedCFuncDefNode.specialize_copied_def  s¤   € ð ×0Ñ0Ð1EÓFˆñ #.ó
á"-�Jô ×6Ñ6°zÀ3ÕGØ"-ð 	ð 
ð
 -0¯H©H°\Ó,BˆÔ)ä%/×%?Ñ%?Ø(-¨t¯z©z×/IÑ/Ió&Kˆ�
‰
Ô"à!Ÿ™ˆ�
‰
ŒØ'×1Ñ1ˆ�
‰
Õùò
s   –B;c                 óª   — t        j                  «       }t        j                  |j                  «      } ||«       t        j                  «       |kD  ryy)zã
        Branch-prune fused type checks like

            if fused_t is int:
                ...

        Returns whether an error was issued and whether we should stop in
        in order to prevent a flood of errors.
        FT)r   Úget_errors_countr   ÚReplaceFusedTypeChecksr'   )r.   r]   Ú
num_errorsÚ	transforms       r3   rT   z*FusedCFuncDefNode.replace_fused_typechecks  sK   € ô ×,Ñ,Ó.ˆ
Ü'×>Ñ>Ø'2×'>Ñ'>ó@ˆ	á�+Ôä×"Ñ"Ó$ zÒ1Øàr4   c                 óv   — |D ]4  }|j                  «       }|j                  d|› d|j                  › d�«       Œ6 y)zl
        Generate Cython code for instance checks, matching an object to
        specialized types.
        z(
                    if isinstance(arg, z#):
                        return 'ú'
                N)Úpy_type_nameÚ	put_chunkÚspecialization_string)r.   Únormal_typesÚpyx_coder/   Úspecialized_typer“   s         r3   Ú_fused_instance_checksz(FusedCFuncDefNode._fused_instance_checks&  sQ   € ó
 !-Ðà+×8Ñ8Ó:ˆLØ×Ñð(Ø(4 ~ð 6!Ø!1×!GÑ!GÐ Hð Iðõñ !-r4   c                 óš   — t        |«      j                  dd«      j                  dd«      }|j                  rt        j                  |z   }|S )NÚ_Ú__Ú )ÚstrÚreplaceÚ
is_typedefr	   Úfused_dtype_prefix)r.   ÚdtyperO   s      r3   Ú_dtype_namezFusedCFuncDefNode._dtype_name5  sC   € Ü�5‹z×!Ñ! # tÓ,×4Ñ4°S¸#Ó>ˆØ×ÒÜ×,Ñ,¨tÑ3ˆDØˆr4   c                 óR   — |j                   r| j                  |«      S t        |«      S r   )r    r£   rž   ©r.   r¢   s     r3   Ú_dtype_typezFusedCFuncDefNode._dtype_type;  s&   € Ø×ÒØ×#Ñ# EÓ*Ð*Ü�5‹zÐr4   c                 óF   — |j                   ryd| j                  |«      › d�S )Nzsizeof(void *)zsizeof(Ú))Úis_pyobjectr¦   r¥   s     r3   Ú_sizeof_dtypezFusedCFuncDefNode._sizeof_dtype@  s)   € Ø×ÒØ#à˜T×-Ñ-¨eÓ4Ð5°QÐ7Ð7r4   c                 ó´  — |j                  d«      5  |j                  d«       |j                  d«       ddd«       |j                  d«      5  |j                  d«       |j                  d«       ddd«       |j                  d«      5  |j                  d«       |j                  d«       ddd«       y# 1 sw Y   Œ‚xY w# 1 sw Y   ŒRxY w# 1 sw Y   yxY w)	z?Setup some common cases to match dtypes against specializationszif kind in u'iu':ÚpassÚ	dtype_intNzelif kind == u'f':Údtype_floatzelif kind == u'c':Údtype_complex)ÚindenterÚputlnÚnamed_insertion_point)r.   r—   s     r3   Ú%_buffer_check_numpy_dtype_setup_casesz7FusedCFuncDefNode._buffer_check_numpy_dtype_setup_casesF  s®   € à×ÑÐ2Õ3Ø�N‰N˜6Ô"Ø×*Ñ*¨;Ô7÷ 4ð ×ÑÐ3Õ4Ø�N‰N˜6Ô"Ø×*Ñ*¨=Ô9÷ 5ð ×ÑÐ3Õ4Ø�N‰N˜6Ô"Ø×*Ñ*¨?Ô;÷ 5Ð4÷ 4Ð3ú÷ 5Ð4ú÷ 5Ð4ús#   ’#B6Á#CÂ
#CÂ6B?ÃCÃCc                 óR  — | j                  |«       ||z   D �]  }|}|j                  r|j                  }|j                  }| j	                  |«      dz   }d| j                  |«      › d�}|j                  |d   f|j                  |d   f|j                  |d   fg}	|	D ]x  \  }
}|
sŒ	|› d|j                  › �}|j                  r||z  }|j                  r|dz  }|j                  d	|› d
�«      5  |j                  d|j                  › d�«       ddd«       Œz �Œ y# 1 sw Y   ŒˆxY w)zO
        Match a numpy dtype object to the individual specializations.
        z == itemsizez
 and not (z_is_signed ^ dtype_signed)r­   r®   r¯   z and (<Py_ssize_t>arg.ndim) == z and arg_is_pythran_compatiblezif Ú:zreturn 'Ú'N)r³   Úis_pythran_exprÚ
org_bufferr¢   rª   r£   Úis_intÚis_floatÚ
is_complexÚndimr°   r±   r•   )r.   r—   Úspecialized_buffer_typesÚpythran_typesr˜   Ú
final_typer¢   Úitemsize_matchÚsigned_matchÚdtypesÚdtype_categoryÚ
codewriterÚconds                r3   Ú_buffer_check_numpy_dtypez+FusedCFuncDefNode._buffer_check_numpy_dtypeT  sS  € ð 	×2Ñ2°8Ô<à -Ð.FÕ FÐØ)ˆJØ×/Ò/Ø#3×#>Ñ#>Ð Ø$×*Ñ*ˆEà!×/Ñ/°Ó6¸ÑGˆNØ'¨×(8Ñ(8¸Ó(?Ð'@Ð@ZÐ[ˆLð —‘˜x¨Ñ4Ð5Ø—‘ ¨-Ñ!8Ð9Ø×!Ñ! 8¨OÑ#<Ð=ðˆFó /5Ñ*� 
Ù%Øà(Ð)Ð)HÐIY×I^ÑI^ÐH_Ð`�Ø—<’<Ø˜LÑ(�DØ×-Ò-ØÐ<Ñ<�Dà×(Ñ(¨3¨t¨f°A¨Õ7à×$Ñ$ x°
×0PÑ0PÐ/QÐQRÐ%SÔT÷ 8Ð7ò /5ñ !G÷2 8Ð7ús   Ã/ DÄD&c                 ó¸  — |j                   }|j                  rdg|j                  z  }n|j                  }t	        j
                  ||«      }|j                  |«       |j                  }|j                  t        j                  › d|› d�«       |j                  }	| j                  |«      }
|j                  }|j                  d|› d|
› d|
› d|› d|› d	|	› d
�«       y)zô
        For each specialized type, try to coerce the object to a memoryview
        slice of that type. This means obtaining a buffer and parsing the
        format string.
        TODO: separate buffer acquisition from format parsing
        )ÚdirectÚstridedr�   z(object, int)z
                # try zH
                if (((itemsize == -1 and arg_as_memoryview.itemsize == z))
                        or itemsize == z8)
                        and arg_as_memoryview.ndim == z"):
                    memslice = zñ(arg_as_memoryview, 0)
                    if memslice.memview:
                        __PYX_XCLEAR_MEMVIEW(&memslice, 1)
                        # print 'found a match for the buffer through format parsing'
                        return 'zT'
                    else:
                        __pyx_PyErr_Clear()
            N)r¢   Ú	is_bufferr¼   Úaxesr   ÚMemoryViewSliceTypeÚcreate_from_py_utility_codeÚfrom_py_functionr±   r	   Úmemviewslice_cnamer•   rª   r”   )r.   r—   Ú	decl_coder˜   r/   r¢   rË   Úmemslice_typeÚcoerce_from_py_funcÚmatchÚsizeof_dtypeÚ
ndim_dtypes               r3   Ú!_buffer_parse_format_string_checkz3FusedCFuncDefNode._buffer_parse_format_string_checkw  s  € ð !×&Ñ&ˆØ×%Ò%Ø)Ð*Ð-=×-BÑ-BÑB‰Dà#×(Ñ(ˆDä"×6Ñ6°u¸dÓCˆØ×1Ñ1°#Ô6Ø+×<Ñ<Ðà�‰Ü×(Ñ(Ð)¨Ð+>Ð*?¸}ÐMô	Oð !×6Ñ6ˆØ×)Ñ)¨%Ó0ˆØ%×*Ñ*ˆ
ð 	×ÑðØ�gð HØHTÀ~ð V(Ø(4 ~ð 67Ø7A°lð C Ø 3Ð4ð 5!ð "' ð (ðõ	
r4   c                 óÌ  — |j                  d|rdndz   dz   |rdndz   dz   «       |j                  d«       |r|j                  d«       | j                  |||«       |j                  d«       |r"|j                  d	|d
   j                  › d�«       |j                  d«       |j                  d«      5  |D ]  }| j                  ||||«       Œ 	 ddd«       y# 1 sw Y   yxY w)a^  
        Generate Cython code to match objects to buffer specializations.
        First try to get a numpy dtype object and match it against the individual
        specializations. If that fails, try naively to coerce the object
        to each specialization, which obtains the buffer each time and tries
        to match the format string.
        z
                z!arg_is_pythran_compatible = Falser6   zœ
                if ndarray is not None:
                    if isinstance(arg, ndarray):
                        dtype = arg.dtype
                        z arg_is_pythran_compatible = TrueaD  
                    elif __pyx_memoryview_check(arg):
                        arg_base = arg.base
                        if isinstance(arg_base, ndarray):
                            dtype = arg_base.dtype
                        else:
                            dtype = None
                    else:
                        dtype = None

                    itemsize = -1
                    if dtype is not None:
                        itemsize = dtype.itemsize
                        kind = ord(dtype.kind)
                        dtype_signed = kind == u'i'
            r   aS  
                        # Pythran only supports the endianness of the current compiler
                        byteorder = dtype.byteorder
                        if byteorder == "<" and not __Pyx_Is_Little_Endian():
                            arg_is_pythran_compatible = False
                        elif byteorder == ">" and __Pyx_Is_Little_Endian():
                            arg_is_pythran_compatible = False
                        if arg_is_pythran_compatible:
                            cur_stride = itemsize
                            shape = arg.shape
                            strides = arg.strides
                            for i in range(arg.ndim-1, -1, -1):
                                if (<Py_ssize_t>strides[i]) != cur_stride:
                                    arg_is_pythran_compatible = False
                                    break
                                cur_stride *= <Py_ssize_t> shape[i]
                            else:
                                arg_is_pythran_compatible = not (arg.flags.f_contiguous and (<Py_ssize_t>arg.ndim) > 1)
                z=
                if arg is None:
                    return 'r   r’   z“
            try:
                arg_as_memoryview = memoryview(arg)
            except (ValueError, TypeError):
                pass
            zelse:N)r”   ÚindentrÆ   Údedentr•   r°   rÖ   )r.   Úbuffer_typesr¾   r—   rÐ   Úaccept_noner/   r˜   s           r3   Ú_buffer_checksz FusedCFuncDefNode._buffer_checks¡  s  € ð 	×ÑðÙ>KÑ:ÐQSñUðXññ
 FSÑAÐXZñ\ð
_ñô	ð, 	�‰˜ÔÙØ×Ñðôð( 	×&Ñ& x°¸}ÔMØ�‰˜Ôáð
 ×Ñðà)¨!™_×BÑBÐCð Dðôð 	×Ñðô	ð ×Ñ˜wÕ'Û$0Ð Ø×6Ñ6Ø  )Ð-=¸sõDñ %1÷ (×'Ñ'ús   Â4CÃC#c           
      ó¶  — |j                  dt        j                  › dt        j                  › d�«       |d   j                  dt        j                  › d�«       |r|d   j                  d«       |d   j                  d«       t        «       }t        «       }t        «       }|D �]1  }|j                  }	| j                  |	«      }
|	j                  rI|
|vr�|j                  |
«       |j                  d	|	j                  › d
|
› d|	j                  «       › d�«       nX|	j                  rL|
|vrH|j                  |
«       |j                  d	|	j                  «       › d
|
› d|	j                  «       › d�«       |	j                  sŒÛt        |	«      |vsŒé|j                  t        |	«      «       | j                  |	«      }|d   j                  d|
› d|
› d|› d�«       �Œ4 y)zg
        If we have any buffer specializations, write out some variable and type declarations.
        z!
                ctypedef struct zO:
                    void *memview

                void __PYX_XCLEAR_MEMVIEW(zR *, int have_gil)
                bint __pyx_memoryview_check(object)
            Úlocal_variable_declarationsz
                cdef z§ memslice
                cdef Py_ssize_t itemsize
                cdef bint dtype_signed
                cdef Py_UCS4 kind

                itemsize = -1
            zŽ
                cdef bint arg_is_pythran_compatible
                cdef Py_ssize_t cur_stride
                cdef Py_ssize_t i
            z?
                cdef memoryview arg_as_memoryview
            z	ctypedef r�   z "z": passÚ"z'
                            cdef bint z'_is_signed
                            z_is_signed = not (<z"> -1 > 0)
                        N)r”   r	   rÏ   rv   r¢   r£   Úis_struct_or_unionÚaddr±   ÚkindÚempty_declaration_coder    Úresolver¹   rž   r¦   )r.   r—   rÐ   Úall_buffer_typesr¾   Úseen_typedefsÚseen_int_dtypesÚseen_structsÚbuffer_typer¢   Ú
dtype_nameÚ
dtype_types               r3   Ú_buffer_declarationsz&FusedCFuncDefNode._buffer_declarationsô  s  € ð 	×Ñð!Ü!'×!:Ñ!:Ð ;ð <+ô ,2×+DÑ+DÐ*Eð Fð	ô	ð 	Ð.Ñ/×9Ñ9ðÜ×/Ñ/Ð0ð 1ðô	ñ ØÐ2Ñ3×=Ñ=ð ?ô ð 	Ð.Ñ/×9Ñ9ðô	
ô ›ˆÜ›%ˆÜ“uˆÜ+ˆKØ×%Ñ%ˆEØ×)Ñ)¨%Ó0ˆJØ×'Ò'Ø \Ñ1Ø ×$Ñ$ ZÔ0Ø—O‘OØ# E§J¡J <¨q°°¸B¸u×?[Ñ?[Ó?]Ð>^Ð^eÐfõhð ×!Ò!Ø ]Ñ2Ø!×%Ñ% jÔ1Ø—O‘OØ# E§M¡M£OÐ#4°A°j°\ÀÀE×D`ÑD`ÓDbÐCcÐcdÐeôgð �|‹|Ü�u“: _Ò4Ø#×'Ñ'¬¨E«
Ô3Ø!%×!1Ñ!1°%Ó!8�JØÐ:Ñ;×EÑEð'Ø'1 lð 3Ø'˜LÐ(;¸J¸<ð Hðöñ) ,r4   c                 ó²  — t        j                  |j                  «      }|j                  «        t	        «       }g g g }}}d}|D ]Œ  }|j                  «       }	|	r0|	|v rŒ|j                  |	«       |	dk(  rd}Œ3|j                  |«       ŒE|j                  r|j                  |«       Œc|j                  s|j                  sŒ||j                  |«       ŒŽ ||||fS )zV
        Specialize fused types and split into normal types and buffer types.
        FÚobjectT)r   Úget_specialized_typesr%   Úsortrv   r“   rá   rg   r·   rÊ   rz   )
r.   rX   Úspecialized_typesÚseen_py_type_namesr–   rÚ   r¾   Úhas_object_fallbackr˜   r“   s
             r3   Ú_split_fused_typesz$FusedCFuncDefNode._split_fused_types5  sà   € ô '×<Ñ<¸S¿X¹XÓFÐð 	×ÑÔ ä ›UÐØ46¸¸B M�lˆØ#ÐÛ 1ÐØ+×8Ñ8Ó:ˆLÙØÐ#5Ñ5ØØ"×&Ñ& |Ô4Ø 8Ò+Ø*.Ñ'à ×'Ñ'Ð(8Õ9Ø!×1Ò1Ø×$Ñ$Ð%5Õ6Ø!×+Ò+Ð/?×/RÓ/RØ×#Ñ#Ð$4Õ5ð !2ð ˜\¨=Ð:MÐMÐMr4   c                 óz  — |j                  d|› d|› d|› d|j                  › d|j                  › d�«       |j                  «        |j                  r|j	                  d|› d�«       nD||k  r |j	                  d	|› d
|dk7  rdnd› d�«       n|j	                  d|j                  › d�«       |j                  «        y )Nz'
                # PROCESSING ARGUMENT z
                if z= < len(<tuple>args):
                    arg = (<tuple>args)[z/]
                elif kwargs is not None and 'z=' in <dict>kwargs:
                    arg = (<dict>kwargs)['z%']
                else:
            zarg = (<tuple>defaults)[r:   z=raise TypeError("Expected at least %d argument%s, got %d" % (ú, r   z"s"z""z, len(<tuple>args)))z9raise TypeError("Missing keyword-only argument: '%s'" % "z"))r”   rO   rØ   Údefaultr±   rÙ   )r.   r—   rX   Úarg_tuple_idxÚmin_positional_argsÚdefault_idxs         r3   Ú_unpack_argumentz"FusedCFuncDefNode._unpack_argumentR  sã   € Ø×Ñð'Ø'4 oð 6Ø!�?ð #)Ø)6¨ð 8.Ø.1¯h©h¨Zð 8+Ø+.¯8©8¨*ð 5ðô		
ð 	�‰ÔØ�;Š;Ø�N‰NØ*¨;¨-°qÐ9õ;àÐ0Ò0Ø�N‰NØOØ(Ð)¨Ð5HÈAÒ5M©EÐSWÐ+XÐXlðpõð
 �N‰NÐXÐY\×YaÑYaÐXbÐbdÐgÔhØ�‰Õr4   c                 óø  — ddl m}m}m} |r-| j                  j
                  | j                  j                  z
  n%t        d„ | j                  j                  D «       «      }|j                  «       }|j                  «       }	|j                  «       }
|	j                  d«       |	j                  «        |j                  d«       |j                  «        |j                  d«       d}d}t        «       }t        «       }t        | j                  j                  «      D �]Z  \  }}|j                   j"                  r8|j                   j%                  «       }t'        |«      dkD  rt)        d«      ‚|d   }|j                   j"                  �rÜ|v�r×|j+                  |«       | j-                  |«      \  }}}}| j/                  |||||«       d	d
g}dg}|s|r|j1                  d«       dj3                  d„ t5        ||«      D «       «      }dj3                  |«      }|
j7                  «       }|j                  d«       |j                  «        |
j9                  d«       |
j9                  d«       |
j;                  d|› d�«      5  |
j                  d«       |r| j=                  ||
|«       |s|rgt        «       }|j?                  |«       |j?                  d„ |D «       «       | jA                  |
|||«       | jC                  |||
||jD                  |«       |
j9                  |rdnd«       ddd«       |
jG                  «       }|
jI                  «        tK        jL                  |jO                  d«      «      jQ                  «       }d|dd › dt'        |«      › dt'        |jR                  «      › dtU        jV                  |jR                  «      › �}|jY                  dd|› d�«      }|j[                  |j]                  ||¬ «      «       |	j9                  d!|› d"|› d#�«       |j9                  d$|› d%|› d"|› d#�«       |dz  }|j?                  |«       |j?                  d&„ |D «       «       |j^                  s�ŒV|dz  }�Œ] |r•|j[                  |j                  ja                  d'd(«      «       |j[                  |j                  ja                  d)d*«      «       |j[                  |j                  ja                  d+d*«      «       |d   j                  d,«       t'        |«      dk(  r=|j[                  |j\                  jc                  d-d.«      «       |j                  d/«       nj|j[                  |j\                  jc                  d0d.«      «       dj3                  d1„ te        t'        |«      «      D «       «      } |j                  d2| › d3�«       |jG                  «       }!dd4l3m4}" |j                  |!d5 |"«       g¬6«      }# |jk                  | j                  jl                  «      |#jn                  «      }$|jq                  |	jG                  «       |js                  «       «       ||$_:        |$jw                  |«       |$jx                  d7   }%|$jt                  | _=        t}        | j                  t~        «      r| j€                  dd |%_A        |%S | j€                  D �&cg c]  }&|&j„                  ‘Œ c}&|%_A        |%S # 1 sw Y   �ŒÇxY wc c}&w )8a!  
        This creates the function that is indexable from Python and does
        runtime dispatch based on the argument types. The function gets the
        arg tuple and kwargs dict (or None) and the defaults tuple
        as arguments from the Binding Fused Function's tp_call.
        r   )ÚTreeFragmentÚCodeÚUtilityCodec              3   ó:   K  — | ]  }|j                   �Œd–— Œ y ­w)Nr   )r÷   )Ú.0rX   s     r3   Ú	<genexpr>z5FusedCFuncDefNode.make_fused_cpdef.<locals>.<genexpr>v  s   è ø€ ÐC™^�c¨s¯{©{Ñ/B”™^ùs   ‚”af  
                cdef extern from *:
                    type __Pyx_ImportNumPyArrayTypeIfAvailable()

                    # from FusedFunction utility code
                    object __pyx_ff_match_signatures_single(dict signatures, dest_type)
                    object __pyx_ff_match_signatures(dict signatures, tuple dest_sig, dict sigindex)
            a�  
                def __pyx_fused_cpdef(signatures, args, kwargs, defaults, _fused_sigindex={}):
                    # FIXME: use a typed signature - currently fails badly because
                    #        default arguments inherit the types we specify here!

                    if kwargs is not None and not kwargs:
                        kwargs = None

                    # instance check body
            Úimportsr   zODetermination of more than one fused base type per argument is not implemented.rî   r%   rX   Úndarrayrö   c              3   ó0   K  — | ]  \  }}|› d |› �–— Œ y­w)r�   N© )r  ÚatypeÚanames      r3   r  z5FusedCFuncDefNode.make_fused_cpdef.<locals>.<genexpr>­  s"   è ø€ Ð&vÑNu¹l¸eÀU¨%¨°°%°Ô'9ÑNuùs   ‚z²
                    cdef extern from *:
                        void __pyx_PyErr_Clear "PyErr_Clear" ()
                        int __Pyx_Is_Little_Endian()
                    r6   z@TYPE_MAPPER_CNAME_PLACEHOLDERzcdef str map_fused_type(z):rÞ   c              3   ó4   K  — | ]  }|j                   –— Œ y ­wr   ©r¸   ©r  Útys     r3   r  z5FusedCFuncDefNode.make_fused_cpdef.<locals>.<genexpr>Æ  s   è ø€ Ð2YÉ=ÀR°2·=µ=É=ùó   ‚zreturn 'object'zreturn NoneNzutf-8Ú__pyx_ff_map_fused_é   r›   z 
@TYPE_MAPPER_CNAME_PLACEHOLDER
z	
@cname('z')
)rO   zstr Ú(r¨   Údest_sigz = c              3   ó4   K  — | ]  }|j                   –— Œ y ­wr   r
  r  s     r3   r  z5FusedCFuncDefNode.make_fused_cpdef.<locals>.<genexpr>æ  s   è ø€ Ð'NÁ¸"¨¯­Áùr  ÚIsLittleEndianzModuleSetupCode.cÚImportzImportExport.cÚImportNumPyArrayz}
                    cdef type ndarray
                    ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable()
                Úmatch_signatures_singlezFusedFunction.pyxzg
                return __pyx_ff_match_signatures_single(<dict> signatures, dest_sig0)
                Úmatch_signaturesc              3   ó&   K  — | ]	  }d |› �–— Œ y­w)r  Nr  )r  Úis     r3   r  z5FusedCFuncDefNode.make_fused_cpdef.<locals>.<genexpr>  s   è ø€ Ð&\Ñ?[¸!¨°!°¤~Ñ?[ùs   ‚zF
                return __pyx_ff_match_signatures(<dict> signatures, (z+), <dict> _fused_sigindex)
                )ÚConstantFoldingÚmodule)ÚlevelÚpipelineéÿÿÿÿ)Cr6   rý   rþ   rÿ   r    Únum_required_argsÚnum_required_kw_argsÚsumr=   ÚPyxCodeWriterr”   rØ   r²   r   rv   Ú	enumerater%   r&   rc   ÚlenÚNotImplementedErrorrá   rô   rû   rg   rS   rP   Úinsertion_pointr±   r°   r™   Úupdaterì   rÜ   rÛ   ÚgetvalueÚresetÚhashlibÚsha256ÚencodeÚ	hexdigestÚtypesr   Útype_list_identifierrŸ   Úuse_utility_codeÚCythonUtilityCoder÷   Úload_cachedÚloadÚrangeÚOptimizer  ÚSetPosTransformr   ÚrootÚdeclare_declarations_in_scopeÚglobal_scopeÚscoperI   r-   Úfragment_scoper!   r   r   Úspecialized_cpdefsrW   )'r.   rU   r/   r0   rý   rþ   rÿ   rù   r—   rÐ   Útype_mapperÚfused_indexrú   rå   Úseen_fused_typesr  rX   Úarg_fused_typesrx   r–   rÚ   r¾   ró   Úmapper_arg_typesÚmapper_arg_namesÚ
mapper_sigÚmapper_argsÚmapper_decl_codeÚmapper_buffer_typesÚtype_mapper_implÚ	impl_hashÚtype_mapper_cnameÚdest_sig_tupleÚfragment_coder  ÚfragmentÚastrW   r1   s'                                          r3   rV   z"FusedCFuncDefNode.make_fused_cpdefj  s¬  € ÷ 	6Ñ5ñ ð �I‰I×'Ñ'¨$¯)©)×*HÑ*HÒHäÑC˜TŸY™YŸ^š^ÓCÓCð 	ð ×%Ñ%Ó'ˆØ×&Ñ&Ó(ˆ	Ø×(Ñ(Ó*ˆØ×Ñðô	ð 	×ÑÔà×Ñð	ô
	ð 	�‰ÔØ×&Ñ& yÔ1àˆØˆÜ%›<ÐÜ›5ÐÜ §	¡	§¡×/‰FˆAˆsØ�x‰x× Ò Ø"%§(¡(×":Ñ":Ó"<�Ü�Ó'¨!Ò+Ü-ð /Vó Wð Wà,¨QÑ/�
à�x‰x× Ó  ZÐ7GÒ%GØ ×$Ñ$ ZÔ0àQU×QhÑQhÐilÓQmÑN�˜l¨MÐ;NØ×%Ñ% h°°QÐ8KÈ[ÔYà$,¨fÐ#5Ð Ø$) 7Ð Ù¡=Ø$×+Ñ+¨IÔ6à!ŸY™YÑ&vÌcÐRbÐdtÔNuÓ&vÓv�
Ø"Ÿi™iÐ(8Ó9�à#.×#>Ñ#>Ó#@Ð Ø ×*Ñ*ðôð !×'Ñ'Ô)à×!Ñ! "Ô%Ø×!Ñ!Ð"BÔCØ ×)Ñ)Ð,DÀZÀLÐPRÐ*SÕTà×5Ñ5Ð6SÔTá#Ø×3Ñ3°LÀ+ÈsÔSá#¡}Ü.8«lÐ+Ø+×2Ñ2°<Ô@Ø+×2Ñ2Ñ2YÉ=Ó2YÔYà×1Ñ1°+Ð?OÐQdÐfsÔtà×+Ñ+Ø(¨-¸ÐFVØŸO™O¨Sô2ð  ×%Ñ%Ñ;NÑ&7ÐTaÔb÷% Uð( $/×#7Ñ#7Ó#9Ð Ø×!Ñ!Ô#ô $ŸN™NÐ+;×+BÑ+BÀ7Ó+KÓL×VÑVÓX�	à)¨)°B°Q¨-¨ØœÐ,Ó-Ð.¨a´°J×4DÑ4DÓ0EÐ/FØœ
×7Ñ7¸
×8HÑ8HÓIÐJðLð "ð
 $4×#;Ñ#;Ø8¸JÐGXÐFYÐY]Ð:^ó$`Ð ð ×$Ñ$Ø×1Ñ1Ð2BÐIZÐ1Ó[ô]ð —‘ $Ð'8Ð&9¸¸:¸,ÀaÐ HÔIØ—‘ ¨+¨°cÐ:KÐ9LÈAÈkÈ]ÐZ[Ð\Ô]à˜qÑ �Ø ×'Ñ'¨Ô5Ø ×'Ñ'Ñ'NÁÓ'NÔNà�{Œ{Ø˜qÑ ’ð_ 0ñb Ø× Ñ Ø× Ñ ×,Ñ,Ð-=Ð?RÓSôUà× Ñ Ø× Ñ ×,Ñ,¨XÐ7GÓHôJà× Ñ Ø× Ñ ×,Ñ,Ð-?ÐAQÓRôTð �YÑ×)Ñ)ðôô ÐÓ  AÒ%à× Ñ Ø×-Ñ-×2Ñ2Ð3LÐNaÓbôdà×Ñðõð × Ñ Ø×-Ñ-×2Ñ2Ð3EÐGZÓ[ô]à!ŸY™YÑ&\¼uÄSÐIYÓEZÔ?[Ó&\Ó\ˆNØ×ÑðFØFTÐEUð Vðôð !×)Ñ)Ó+ˆõ 	.Ø×,Ñ,Ø ±_Ó5FÐ4Gð -ó Iˆà9ˆl×*Ñ*¨4¯9©9¯=©=Ó9¸(¿-¹-ÓHˆØ×1Ñ1Ø×ÑÓ  #×"2Ñ"2Ó"4ô	6àˆŒ	à× Ñ  Ô%Ø—)‘)˜B‘-ˆØ!Ÿi™iˆÔä�d—i‘i¤Ô)Ø)-¯©±A¨ˆGÔ&ð ˆð >B¿ZºZÓ)H¹Z¸¨!¯)«)¸ZÑ)HˆGÔ&àˆ÷K UÑTüòF *Is   É>B'[*Û[7Û*[4	c           	      óÄ  — d}| j                   j                  }|D ]-  }t        ||t        | j                  j                  |«      «       Œ/ | j                  j
                  | j                   _        | j                  j                  | j                   _        |j                  j                  dd «       t        | j                  t        «      r||j                  |j
                  <   n||j                  |j
                     _        |j                  j                  |«       | | j                   j                  _        g }| j                   D ]†  }t        | j                  t        «      r#|j                  |«       | j                   |_        Œ@|j                  |j                   «       | j                   |j                   _        ||j                  _        Œˆ | j%                  |«       y )N)
rO   r   r[   rf   Úpyfunc_cnamer‡   rˆ   r‰   Ú	is_memberr:  Ú__pyx_fused_cpdef)rW   r$   ÚsetattrÚgetattrrU   rO   rˆ   rN   Úpopr!   r    r   rm   rA   rg   r,   r   Úfused_py_funcÚsynthesize_defnodes)r.   r/   Úcopy_attributesr$   ÚattrÚ	def_nodesr    s          r3   Úupdate_fused_defnode_entryz,FusedCFuncDefNode.update_fused_defnode_entry#  s_  € ð
ˆð —‘×"Ñ"ˆã#ˆDÜ�E˜4Ü˜D×-Ñ-×3Ñ3°TÓ:õ<ð $ð !×-Ñ-×2Ñ2ˆ�‰ÔØ×,Ñ,×0Ñ0ˆ�‰Ôà�‰�‰Ð+¨TÔ2Ü�d—i‘i¤Ô)Ø&+ˆC�K‰K˜Ÿ
™
Ò#à27ˆC�K‰K˜Ÿ
™
Ñ#Ô/à×Ñ×!Ñ! %Ô(à-1ˆ�‰×ÑÔ*Øˆ	Ø—J”JˆDÜ˜$Ÿ)™)¤WÔ-Ø× Ñ  Ô&Ø%)§\¡\�Õ"à× Ñ  §¡Ô.Ø-1¯\©\�—‘Ô*Ø).�—
‘
Õ&ð ð 	× Ñ  Õ+r4   c                 ó|  — | j                   D ]F  }|j                  «       D ]1  }|j                  D ]   }|j                  sŒ|j	                  |«       Œ" Œ3 ŒH | j
                  r€| j                  j                  |«      | _        | j
                  j                  |«      | _        | j                  j                  |«      | _        | j                  j                  |«      | _	        g x| _
        }| j                  j                  D ]¸  }|j                  r™|j                  j                  |«      |_        |j                  j                  r/|j                  t!        j                   |j                  «      «       Œt|j                  t#        |j                  j%                  |«      «      «       Œ¨|j                  d«       Œº t'        | j(                  «      D ]Í  \  }}|j                  |«      x}| j(                  |<   t+        |t,        «      sŒ7|| j
                  usŒFt/        |j                  |«      D ]o  \  }}	|	€Œ	|	j                  r"|	j1                  |j2                  |«      |_        Œ7t5        |	«      j                  |«      j1                  |j2                  |«      |_        Œq ŒÏ | j
                  �r	|D �	cg c]  }	|	sŒt5        |	«      ‘Œ }
}	t7        | j8                  |
¬«      | _        | j:                  j=                  |d¬«      j?                  |«      | _        t#        | j:                  «      | _        | j                  j@                  }t5        | j:                  «      |_        t'        | jB                  «      D ]?  \  }}|j=                  |«      x}| jB                  |<   t5        | j:                  «      |_        ŒA | S c c}	w )z‘
        Analyse the expressions. Take care to only evaluate default arguments
        once and clone the result for all specializations
        N)r=   T)Úskip_children)"r@   rc   r.  r»   Úcreate_declaration_utility_coderW   r   Úanalyse_expressionsr   r   Údefaultsr    r=   r÷   Ú
is_literalrg   rC   r   Úcoerce_to_tempr#  r-   r!   r   rP   Ú	coerce_tor%   r
   r   r   Údefaults_tupleÚanalyse_typesÚcoerce_to_pyobjectrX   Úspecialized_pycfuncs)r.   r/   Úfused_compound_typerx   Úspecialization_typer_  rX   r  Ústatr÷   r=   Ú
fused_funcÚpycfuncs                r3   r^  z%FusedCFuncDefNode.analyse_expressionsH  s÷  € ð
 $(×#<Ô#<ÐØ1×AÑAÖC�
Ø+5×+;Ô+;Ð'Ø*×5Ó5Ø+×KÑKÈCÕPñ ,<ñ Dð $=ð �<Š<Ø"&×"5Ñ"5×"IÑ"IÈ#Ó"NˆDÔØŸ<™<×;Ñ;¸CÓ@ˆDŒLØ,0×,IÑ,I×,]Ñ,]Ð^aÓ,bˆDÔ)Ø)-×)CÑ)C×)WÑ)WÐX[Ó)\ˆDÔ&à#%Ð%ˆŒ˜à—9‘9—>”>ˆCØ�{Š{Ø!Ÿk™k×=Ñ=¸cÓB�”Ø—;‘;×)Ò)Ø—O‘O¤D§I¡I¨c¯k©kÓ$:Õ;ð —O‘O¤I¨c¯k©k×.HÑ.HÈÓ.MÓ$NÕOà—‘ Õ%ð "ô ! §¡Ö,‰GˆAˆtØ#'×#;Ñ#;¸CÓ#@Ð@ˆD�4—:‘:˜a‘=Ü˜$¤Õ,°¸T¿\¹\Ò1Iä$'¨¯	©	°8Ö$<‘L�C˜ØÑ*Ø"×-Ò-Ø*1×*;Ñ*;¸C¿H¹HÀcÓ*J˜C�Kä*3°GÓ*<×*PÑ*PÐQTÓ*U×*_Ñ*_Ð`c×`hÑ`hÐjmÓ*n˜C�Kñ %=ð	 -ð �<‹<Ù6>ÓJ±h¨7Â'”I˜gÕ&°hˆDÐJÜ"+¨D¯H©H¸4Ô"@ˆDÔØ"&×"5Ñ"5×"CÑ"CÀCÐW[Ð"CÓ"\×"oÑ"oÐpsÓ"tˆDÔÜ"+¨D×,?Ñ,?Ó"@ˆDÔà×6Ñ6×:Ñ:ˆJÜ(1°$×2EÑ2EÓ(FˆJÔ%ä'¨×(AÑ(AÖB‘
��7Ø9@×9NÑ9NÈsÓ9SÐS�˜$×3Ñ3°AÑ6Ü)2°4×3FÑ3FÓ)G�Õ&ð Cð ˆùò Ks   Ê2N9Ê:N9c                 ól  — |D ]  }d|j                   j                  _        Œ |D �cg c]!  }t        j                  |j
                  «      ‘Œ# }}t        ||«      D ��cg c]&  \  }}t        j                  |j                  |¬«      ‘Œ( }}}|D �cg c]#  }t        j                  j                  |d¬«      ‘Œ% }}t        j                  j                  | j                  t        ||«      «      | _        || _        |D ]	  }d|_        Œ t#        |d   «      | j$                  _        yc c}w c c}}w c c}w )zT
        Create the __signatures__ dict of PyCFunctionNode specializations.
        F)ÚvalueT)Úbindingr   N)r$   rE   Úuse_fastcallr   rR   r…   rP   r   ÚUnicodeNoder   ÚPyCFunctionNodeÚfrom_defnodeÚDictNodeÚ
from_pairsr   rf  Úis_specializationr   rW   rH   )r.   r   r    Ú
signaturesÚsigÚkeysÚvaluesÚpycfuncnodes           r3   rV  z%FusedCFuncDefNode.synthesize_defnodes  s2  € ó
 ˆDØ05ˆD�J‰J× Ñ Õ-ð ñ #(ó)Ù"'˜$ô %×2Ñ2°4×3TÑ3TÕUØ"'ð 	ð )ô "% U¨JÔ!7ô9Ù!7‘I�D˜#ô ×%Ñ% d§h¡h°cÖ:Ø!7ð 	ñ 9ñ $ó%Ù#�dô ×+Ñ+×8Ñ8¸ÀtÐ8ÕLØ#ð 	ð %ô (×0Ñ0×;Ñ;¸D¿H¹HÄcÈ$ÐPVÓFWÓXˆÔà$*ˆÔ!Û!ˆKØ,0ˆKÕ)ð "ô $2°%¸±(Ó#;ˆ�‰Õ ùò)ùó9ùò%s   §&D&Á+D+Â(D1c                 óš  — | j                   r-d| j                   _        | j                  j                  ||«       ddlm} | j                  D ]}  }t        |t        «      sŒ|j                  j                  s'|j                  sŒ7|j                  j                  dk(  rŒQ|j                  |j                  «       |j                  ||«       Œ y )NTr   )ÚOptionsÚextern)rW   Úpymethdef_requiredr   Úgenerate_function_definitionsr6   r|  r-   r!   r   r$   rM   Úcimport_from_pyxÚ
visibilityÚmark_posr   )r.   r/   Úcoder|  ri  s        r3   r  z/FusedCFuncDefNode.generate_function_definitions–  s‹   € Ø�<Š<Ø.2ˆD�L‰LÔ+Ø×&Ñ&×DÑDÀSÈ$ÔOåØ—J”JˆDÜ˜$¤Õ,Ø—J‘J—O’OØ×-Ó-°d·j±j×6KÑ6KÈxÓ6WØ—‘˜dŸh™hÔ'Ø×2Ñ2°3¸Õ=ñ r4   c                 ój  •— | j                   D ]  }|€Œ|j                  |«       Œ | j                  r| j                  j                  |«       t        ‰| �  |«       | j                  �r| j                  }|j                  |«       | j                  }|j                  |«       |j                  d|j                  «       › d|j                  «       › d�«       |j                  |«       |j                  |«       |j                  |«       | j                  j                  |«       |j                  |«       |j                  |«       | j                  j                  |«       | j                  j                  |«       | j                   D ]'  }|€Œ|j                  |«       |j                  |«       Œ) y )Nz((__pyx_FusedFunctionObject *) z)->__signatures__ = Ú;)r_  Úgenerate_evaluation_coderW   rc  r   Úgenerate_execution_coder   r   r±   rt   Úgenerate_giverefÚgenerate_post_assignment_codeÚ
free_tempsr   Úgenerate_disposal_code)r.   rƒ  r÷   rv  rj  r2   s        €r3   r‡  z)FusedCFuncDefNode.generate_execution_code£  sx  ø€ ð —}”}ˆGØÑ"Ø×0Ñ0°Õ6ð %ð �<Š<Ø×Ñ×8Ñ8¸Ô>ä‰Ñ'¨Ô-à×ÓØ×,Ñ,ˆJØ×/Ñ/°Ô5Ø×6Ñ6ˆJØ×/Ñ/°Ô5à�J‰JØ1°*×2CÑ2CÓ2EÐ1FÐFZÐ[e×[lÑ[lÓ[nÐZoÐopÐqôsð ×'Ñ'¨Ô-Ø×4Ñ4°TÔ:Ø×!Ñ! $Ô'à×&Ñ&×>Ñ>¸tÔDð ×-Ñ-¨dÔ3Ø×!Ñ! $Ô'Ø×Ñ×6Ñ6°tÔ<Ø×Ñ×*Ñ*¨4Ô0à—}”}ˆGØÑ"Ø×.Ñ.¨tÔ4Ø×"Ñ" 4Õ(ñ %r4   c                 óH   — | j                   D ]  }|j                  |«       Œ y r   )r-   Úannotate)r.   rƒ  ri  s      r3   r�  zFusedCFuncDefNode.annotateÉ  s   € Ø—J”JˆDØ�M‰M˜$Õñ r4   )'Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   r   rW   rc  Ú
decoratorsr   Úchild_attrsr   r"   r#   r>   rF   rJ   rK   rT   r™   r£   r¦   rª   r³   rÆ   rÖ   rÜ   rì   rô   rû   rV   rZ  r^  rV  r  r‡  r�  Ú__classcell__)r2   s   @r3   r   r      sÔ   ø„ ñð4 €NØ#ÐØ ÐØ€GØ€NØ€Jà×*Ñ*ò .Oñ O€Kô#ò:.Jò`Z(òx	ò	2ò ò"2ò ò(òòò
8ò<ò!UòF(
òTQDòf?òBNò:ò0wòr#,òJ5òn<ò.>ô$)öL r4   r   )rC   r*  r6   r   r   r   r   r   r	   r
   r   r   r   ÚNodesr   r   r   ÚUtilsr   r   r   r   r  r4   r3   Ú<module>r—     s8   ðÛ Û ÷÷ ÷ GÓ Fß 5Ñ 5Ý ß +ô~ ˜õ ~ r4   