Ë
    üÇ:jîA  ã                   óø  — d dl Z d dlmZmZ d dlZd dlZd dlmZ d dlZ	d dl
Z
d dlmZmZmZmZmZ d dlmZ d dlmZ d„ Z ej*                  d«       G d	„ d
ej,                  «      «       Ze
j0                  e j2                  e
j4                  e j6                  e
j8                  e j:                  iZe
j>                  e j@                  e
jB                  e jD                  e
jF                  e jH                  e
jJ                  e jL                  e
jN                  e jP                  e
jR                  e jT                  e
jV                  e jX                  e
jZ                  e j\                  e
j^                  e j`                  e
jb                  e jd                  e
jf                  e jh                  e
jj                  e jl                  iZ7e
jp                  e jr                  e
jt                  e jv                  e
jx                  e jz                  e
j|                  e j~                  e
j€                  e j‚                  e
j„                  e j†                  iZDd„ ZEejŒ                  d„ «       ZG G d„ de j�                  «      ZIde j”                  fd„ZKd„ ZLy)é    N)ÚdefaultdictÚOrderedDict)ÚSimpleNamespace)ÚtypesÚtargetconfigÚirÚrewritesÚcompiler)Únpydecl)ÚDUFuncc                 óB   — t        | t        j                  t        f«      S ©N)Ú
isinstanceÚnpÚufuncr   )Úfuncs    úo/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/numba/np/ufunc/array_exprs.pyÚ	_is_ufuncr      s   € Ü�dœRŸX™X¤vÐ.Ó/Ð/ó    zafter-inferencec                   óX   ‡ — 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ˆ xZS )ÚRewriteArrayExprszóThe RewriteArrayExprs class is responsible for finding array
    expressions in Numba intermediate representation code, and
    rewriting those expressions to a single operation that will expand
    into something similar to a ufunc call.
    c                 ó|   •— t        t        | �
  |g|¢­i |¤Ž |j                  j                  }d|vr
t
        |d<   y y )NÚ	arrayexpr)Úsuperr   Ú__init__Ú	targetctxÚspecial_opsÚ_lower_array_expr)ÚselfÚstateÚargsÚkwsr   Ú	__class__s        €r   r   zRewriteArrayExprs.__init__   sC   ø€ ÜÔ Ñ/°ÐD¸ÒDÀÒDà—o‘o×1Ñ1ˆØ˜kÑ)Ü'8ˆK˜Ò$ð *r   c                 ó,  — t        |«      dk(  ry|| _        || _        t        «       | _        i | _        |j                  t        j                  «      }|D ]¦  }|j                  j                  }|j                  }t        |t        j                  «      r>t        |j                  |d«      t        j                   «      r| j#                  |||«       Œ}t        |t        j$                  «      sŒ˜|| j
                  |<   Œ¨ t        | j                  «      dkD  S )z±
        Using typing and a basic block, search the basic block for array
        expressions.
        Return True when one or more matches were found, False otherwise.
        r   FN)ÚlenÚ
crnt_blockÚtypemapr   Úarray_assignsÚconst_assignsÚ
find_instsr   ÚAssignÚtargetÚnameÚvaluer   ÚExprÚgetr   ÚArrayÚ_match_array_exprÚConst)	r   Úfunc_irÚblockr'   Ú	calltypesÚassignmentsÚinstrÚtarget_nameÚexprs	            r   ÚmatchzRewriteArrayExprs.match!   sß   € ô ˆy‹>˜QÒØàˆŒØˆŒä(›]ˆÔàˆÔà×&Ñ&¤r§y¡yÓ1ˆØ ò 
	7ˆEØŸ,™,×+Ñ+ˆKØ—;‘;ˆDä˜4¤§¡Ô)Ü˜7Ÿ;™; {°DÓ9¼5¿;¹;ÔGØ×&Ñ& u¨d°KÕ@Ü˜D¤"§(¡(Õ+ð 37�×"Ñ" ;Ò/ð
	7ô �4×%Ñ%Ó&¨Ñ*Ð*r   c                 óö  ‡ — |j                   }‰ j                  }|dv rE|j                  t        j                  v r)t        ˆ fd„|j                  «       D «       «      r|||<   yy|dk(  r’|j                  j                  ‰ j                  v ro‰ j                  |j                  j                     }t        |t        j                  «      r1|j                  }t        |«      r‰ j                  ||«      s|||<   yyyyyy)z‘
        Find whether the given assignment (*instr*) of an expression (*expr*)
        to variable *target_name* is an array expression.
        ©ÚunaryÚbinopc              3   ód   •K  — | ]'  }‰j                   |j                     j                  –— Œ) y ­wr   )r'   r-   Úis_internal)Ú.0Úvarr   s     €r   ú	<genexpr>z6RewriteArrayExprs._match_array_expr.<locals>.<genexpr>Q   s,   øè ø€ ò 0Øð —<‘< §¡Ñ)×5Õ5ñ 0ùs   ƒ-0ÚcallN)Úopr(   Úfnr   Úsupported_array_operatorsÚallÚ	list_varsr   r-   r'   r   r   ÚFunctionÚ
typing_keyr   Ú_has_explicit_output)r   r8   r:   r9   Úexpr_opr(   Ú	func_typeÚfunc_keys   `       r   r2   z#RewriteArrayExprs._match_array_exprB   sè   ø€ ð —'‘'ˆØ×*Ñ*ˆàÐ*Ñ*Ø—‘œ7×<Ñ<Ñ<ô ó 0Ø"Ÿn™nÓ.ô0ô 0à-2�˜kÒ*ð0ð ˜&Ò  t§y¡y§~¡~¸¿¹Ñ'EàŸ™ T§Y¡Y§^¡^Ñ4ˆIÜ˜)¤U§^¡^Ô4Ø$×/Ñ/�Ü˜XÔ&à×4Ñ4°T¸8ÔDà5:˜ kÒ2ð Eð 'ð 5ð (FÐ r   c                 ó�   — t        |j                  «      t        |j                  «      z   }|j                  �y||j                  kD  S )zr
        Return whether the *expr* call to *func* (a ufunc) features an
        explicit output argument.
        T)r%   r!   r"   ÚvarargÚnin)r   r:   r   Únargss       r   rM   z&RewriteArrayExprs._has_explicit_output`   s<   € ô
 �D—I‘I“¤ T§X¡X£Ñ.ˆØ�;‰;Ð"ð Ø�t—x‘xÑÐr   c                 óÒ   — |j                   }|dv r|j                  S |dk(  r-| j                  |j                  j                     j
                  S t        dj                  |«      «      ‚)Nr=   rE   z:Don't know how to find the operator for '{0}' expressions.)rF   rG   r'   r   r-   rL   ÚNotImplementedErrorÚformat©r   Úir_exprÚir_ops      r   Ú_get_array_operatorz%RewriteArrayExprs._get_array_operatorl   sb   € Ø—
‘
ˆØÐ&Ñ&Ø—:‘:ÐØ�fŠ_Ø—<‘< §¡× 1Ñ 1Ñ2×=Ñ=Ð=Ü!ØH×OÑOØóóð 	r   c                 óÔ   — |j                   }|dk(  r|j                  |j                  fS |dk(  r|j                  «       S |dk(  r|j                  S t        dj                  |«      «      ‚)z{Given a Numba IR expression, return the operands to the expression
        in order they appear in the expression.
        r?   r>   rE   z:Don't know how to find the operands for '{0}' expressions.)rF   ÚlhsÚrhsrJ   r!   rV   rW   rX   s      r   Ú_get_operandszRewriteArrayExprs._get_operandsv   sn   € ð —
‘
ˆØ�GÒØ—;‘; §¡Ð+Ð+Ø�gÒØ×$Ñ$Ó&Ð&Ø�fŠ_Ø—<‘<ÐÜ!ØH×OÑOØóóð 	r   c                 óð   — |j                   }|dk(  r|j                  S | j                  |«      D �cg c](  }| j                  j	                  |j
                  |«      ‘Œ* }}| j                  |«      |fS c c}w )zZTranslate the given expression from Numba IR to an array expression
        tree.
        r   )rF   r:   r_   r)   r0   r-   r[   )r   rY   rZ   Úop_varÚoperands_or_argss        r   Ú_translate_exprz!RewriteArrayExprs._translate_expr…   s   € ð —
‘
ˆØ�KÒØ—<‘<Ðà*.×*<Ñ*<¸WÓ*EöGØ &ð !×.Ñ.×2Ñ2°6·;±;ÀÕGð GÐð Gà×'Ñ'¨Ó0Ð2BÐBÐBùòGs   ±-A3c                 ór  — i }t        «       }t        t        «      }| j                  j	                  «       D �]ú  }|j
                  }g }| j                  |«      |f}t        j                  d|j                  || j                  |j                  j                     ¬«      }t        j                  ||j                  |j                  «      }	|	||<   |	| j                  |j                  j                  <   | j                  |«      D �]*  }
|
j                  }|
j                  r¹|| j                  v r«| j                  |   }|j
                  }|j!                  «       }|D ]  }
||
j                  xx   dz  cc<   Œ |j#                  | j%                  |«      «       |j                  j                  sŒª|j'                  |j                  j                  «       d||<   ŒÕ|| j(                  v r |j#                  | j(                  |   «       �Œ||
j                  xx   dz  cc<   |j#                  |
«       �Œ- �Œý |||fS )ztIterate over the matches, trying to find which instructions should
        be rewritten, deleted, or moved.
        r   )rF   Úlocr:   Útyé   N)Úsetr   Úintr(   Úvaluesr.   r[   r   r/   re   r'   r,   r-   r+   r_   Úis_temprJ   Úappendrc   Úaddr)   )r   Úreplace_mapÚ	dead_varsÚ	used_varsr8   r:   Úarr_inpsÚarr_exprÚnew_exprÚ	new_instrÚoperandÚoperand_nameÚchild_assignÚ
child_exprÚchild_operandss                  r   Ú_handle_matchesz!RewriteArrayExprs._handle_matches�   së  € ð ˆÜ“Eˆ	Ü¤Ó$ˆ	Ø×'Ñ'×.Ñ.Ó0ó 	-ˆEØ—;‘;ˆDØˆHØ×/Ñ/°Ó5°xÐ?ˆHÜ—w‘w +Ø#'§8¡8Ø$,Ø"&§,¡,¨u¯|©|×/@Ñ/@Ñ"AôCˆHô Ÿ	™	 (¨E¯L©L¸%¿)¹)ÓDˆIØ!*ˆK˜ÑØ4=ˆD×Ñ˜uŸ|™|×0Ñ0Ñ1Ø×-Ñ-¨dÓ3ó -�Ø&Ÿ|™|�Ø—?’? |°t×7IÑ7IÑ'IØ#'×#5Ñ#5°lÑ#C�LØ!-×!3Ñ!3�JØ%/×%9Ñ%9Ó%;�NØ#1ò 5˜Ø! '§,¡,Ó/°1Ñ4Ô/ð5à—O‘O D×$8Ñ$8¸Ó$DÔEØ#×*Ñ*×2Ó2Ø!Ÿ™ l×&9Ñ&9×&>Ñ&>Ô?Ø48˜ LÒ1Ø! T×%7Ñ%7Ñ7Ø—O‘O D×$6Ñ$6°|Ñ$DÖEà˜gŸl™lÓ+¨qÑ0Ó+Ø—O‘O GÖ,ò!-ð	-ð8 ˜I yÐ0Ð0r   c                 ó,   — ||   }||v r
||   }||v rŒ
|S )z¯Find the final replacement instruction for a given initial
        instruction by chasing instructions in a map from instructions
        to replacement instructions.
        © )r   Úreplacement_mapr8   Úreplacements       r   Ú_get_final_replacementz(RewriteArrayExprs._get_final_replacementµ   s0   € ð
 & eÑ,ˆØ˜_Ñ,Ø)¨+Ñ6ˆKð ˜_Ò,àÐr   c                 ó`  — | j                  «       \  }}}| j                  j                  «       }|j                  «        i }| j                  j                  D �]+  }t        |t        j                  «      r¢||v rŒ| j                  ||«      }|sŒ7|j                  |«       |j                  j                  «       D ]H  }|j                  }	|	|v r |j                  |j                  |	«      «       ||	   dkD  sŒ<||	xx   dz  cc<   ŒJ Œ®|j                  |«       ŒÀt        |t        j                  «      rA|j                  }
||
   dkD  r||
xx   dz  cc<   |||
<   �Œ|
|vs�Œ|j                  |«       �Œ|j                  |«       �Œ. |r&|j                  «       D ]  }|j!                  |«       Œ |S )z}When we've found array expressions in a basic block, rewrite that
        block, returning a new, transformed block.
        r   rg   )rz   r&   ÚcopyÚclearÚbodyr   r   r+   r   rl   r.   rJ   r-   ÚpopÚDelrj   Úinsert_before_terminator)r   rn   ro   rp   ÚresultÚ
delete_mapr8   r~   rC   Úvar_nameÚinstr_values              r   ÚapplyzRewriteArrayExprs.apply¿   s‹  € ð -1×,@Ñ,@Ó,BÑ)ˆ�Y 	ð —‘×%Ñ%Ó'ˆØ�‰ŒØˆ
Ø—_‘_×)Ñ)ó 	%ˆEÜ˜%¤§¡Ô+Ø˜KÑ'Ø"&×"=Ñ"=Ø# Uó#,�Kâ"ØŸ™ kÔ2Ø#.×#4Ñ#4×#>Ñ#>Ó#@ò 9˜CØ'*§x¡x˜HØ'¨:Ñ5Ø &§¡¨j¯n©n¸XÓ.FÔ GØ(¨Ñ2°QÓ6Ø )¨(Ó 3°qÑ 8Ô 3ñ9ð —M‘M %Õ(Ü˜E¤2§6¡6Ô*Ø#Ÿk™k�Ø˜[Ñ)¨AÒ-Ø˜kÓ*¨aÑ/Ó*Ø.3�J˜{Ó+Ø ¨	Ó1Ø—M‘M %Ö(à—‘˜eÖ$ð1	%ñ2 Ø#×*Ñ*Ó,ò 7�Ø×/Ñ/°Õ6ð7àˆr   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r;   r2   rM   r[   r_   rc   rz   r   r‹   Ú__classcell__©r#   s   @r   r   r      s=   ø„ ñô
9ò+òB;ò<
 òòò	Cò#1òJö(r   r   c                 óÖ  — t        | t        «      �r~| \  }}g }i }|D ]2  }t        |«      \  }}|j                  |«       |j	                  |«       Œ4 |t
        j                  v r¥t        |«      dk(  rg|t        v r*t        j                  |d   t        |   «       |d   «      |fS |t        v �r¯t        j                  |d   t        |   «       g|d   g«      |fS |t        v sJ ‚t        j                  t        |   «       |d   «      |fS t        |«      �rGdj!                  t#        t%        |«      «      j'                  dd«      «      }t        j(                  |t        j*                  «       «      }	|||<   t        j,                  |	|g «      }
|
|fS t        | t.        j0                  «      rwt        j(                  | j2                  t        j*                  «       | j4                  j6                  | j4                  j8                  r| j4                  j8                  nd¬«      i fS t        | t.        j:                  «      r!t        j<                  | j>                  «      i fS tA        d| ›d	�«      ‚)
z[Build a Python expression AST from an array expression built by
    RewriteArrayExprs.
    é   r   rg   z__ufunc_or_dufunc_{0}ú-Ú_)ÚlinenoÚ
col_offsetz.Don't know how to translate array expression 'ú')!r   ÚtupleÚ_arr_expr_to_astrl   Úupdater   rH   r%   Ú_binopsÚastÚBinOpÚ_cmpopsÚCompareÚ	_unaryopsÚUnaryOpr   rW   ÚhexÚhashÚreplaceÚNameÚLoadÚCallr   ÚVarr-   re   ÚlineÚcolr3   ÚConstantr.   rV   )r:   rF   Úarr_expr_argsÚast_argsÚenvÚargÚast_argÚ	child_envÚfn_nameÚfn_ast_nameÚast_calls              r   rš   rš   
  s  € ô �$œÕØ ÑˆˆMØˆØˆØ ò 	"ˆCÜ!1°#Ó!6ÑˆG�YØ�O‰O˜GÔ$Ø�J‰J�yÕ!ð	"ð ”×2Ñ2Ñ2Ü�8‹} Ò!Øœ‘=ÜŸ9™9Ø  ™¤W¨R¡[£]°H¸Q±KóAØBEðFð Fàœ’=ÜŸ;™;Ø  ™¤g¨b¡k£m _°xÀ±{°móEØFIðJð Jð œY‘Ð&�Ü—{‘{¤9¨R¡=£?°H¸Q±KÓ@À#ÐEÐEÜ�r�]Ø-×4Ñ4Ü”D˜“H“×%Ñ% c¨3Ó/ó1ˆGäŸ(™( 7¬C¯H©H«JÓ7ˆKØˆC�‰LÜ—x‘x ¨X°rÓ:ˆHØ˜S�=Ð Ü	�Dœ"Ÿ&™&Ô	!Ü�x‰x˜Ÿ	™	¤3§8¡8£:Ø#Ÿx™xŸ}™}Ø37·8±8·<²< 4§8¡8§<¢<ÀQôHàIKðLð 	Lô 
�Dœ"Ÿ(™(Ô	#Ü�|‰|˜DŸJ™JÓ'¨Ð+Ð+Ý
Ú?CÐEóGð Gr   c              #   óÒ  K  — t        «       }| D ]�  }|j                  }|j                  j                  ||j                  ¬«      j                  }|j                  dd«      j                  dd«      }||v rt        |›d�«      ‚||f||<   ||_        Œƒ t        |«      }	 |–— |j                  «       D ]  \  }}||_        Œ y# |j                  «       D ]  \  }}||_        Œ w xY w­w)za
    Legalize names in the variable list for use as a Python function's
    parameter names.
    )re   ú$r•   ú.z not uniqueN)	r   r-   ÚscopeÚredefinere   r¥   ÚAssertionErrorÚlistrj   )Úvar_listÚvar_maprC   Úold_nameÚnew_nameÚparam_namess         r   Ú_legalize_parameter_namesrÂ   2  sò   è ø€ ô ‹m€GØò ˆØ—8‘8ˆØ—9‘9×%Ñ% h°C·G±GÐ%Ó<×AÑAˆØ×#Ñ# C¨Ó-×5Ñ5°c¸3Ó?ˆà�wÑÜ  H <¨{Ð!;Ó<Ð<Ø ˜Mˆ�ÑØˆ�ðô �w“-€Kð ØÒð %Ÿ^™^Ó-ò 	 ‰MˆC�ØˆC�Hñ	 ø˜WŸ^™^Ó-ò 	 ‰MˆC�ØˆC�Hñ	 üs   ‚BC'ÂC Â# C'Ã!C$Ã$C'c                   óP   ‡ — e Zd Zdej                  dej                  fˆ fd„Zˆ xZS )Ú_EraseInvalidLineRangesÚnodeÚreturnc                 ó’   •— t         ‰| �  |«      }t        |d«      r*t        |dd «      �|j                  |j
                  kD  r|`|`|S )Nr–   Ú
end_lineno)r   Úgeneric_visitÚhasattrÚgetattrr–   rÈ   )r   rÅ   r#   s     €r   rÉ   z%_EraseInvalidLineRanges.generic_visitM  sJ   ø€ Ü‰wÑ$ TÓ*ˆÜ�4˜Ô"Ü�t˜\¨4Ó0Ð<Ø—;‘; §¡Ò0Ø˜Ø˜Øˆr   )rŒ   r�   rŽ   r�   ÚASTrÉ   r�   r‘   s   @r   rÄ   rÄ   L  s#   ø„ ð #§'¡'ð ¨c¯g©g÷ ñ r   rÄ   Úastreec                 óŠ   — t        j                  | «       t        «       j                  | «       t        j                  | «       y)z)Inplace fixes invalid lineno ranges.
    N)r�   Úfix_missing_locationsrÄ   Úvisit)rÍ   s    r   Ú_fix_invalid_lineno_rangesrÑ   W  s1   € ô ×Ñ˜fÔ%äÓ×#Ñ# FÔ+ä×Ñ˜fÕ%r   c                 ó”  ‡ ‡‡‡— dt        t        |«      «      j                  dd«      z  }|j                  j                  }|j                  «       }t        t        |«      d„ ¬«      }|D �cg c]  }|j                  ‘Œ }}t        |«      5 }|D �	cg c]  }	t        j                  |	d«      ‘Œ }
}	t        j                  dj                  |«      |d«      }t        |d	«      rt        |j                   «      d
k(  sJ ‚|j                   d   }|
|j"                  _        t%        |j&                  «      \  |j                   d   _        }t+        |«       ddd«       t-        |d«      }t/        |«       ||   }‰ j0                  }‰ j2                  Š |j4                  ˆ fd„|D «       Ž }g }|j"                  D ]o  }t7        |t8        j:                  «      r|j<                  }t7        |t8        j>                  «      r|jA                  |jB                  «       Œ_|jA                  |«       Œq  |jD                  jB                  |Ž ŠtG        jH                  «       jK                  «       }|€tM        jN                  «       n|jQ                  «       }d|_)        |jU                  ‰|‰|d¬«      Šddl+m,}  G ˆˆˆfd„d|jZ                  «      }t]        t        |«      d
|¬«      }|j^                  |j`                  z   |_1        |D �cg c]  }‰ je                  |«      ‘Œ }}|jg                  |‰||||«      S c c}w c c}	w # 1 sw Y   �ŒèxY wc c}w )z:Lower an array expression built by RewriteArrayExprs.
    z__numba_array_expr_%sr”   r•   c                 ó   — | j                   S r   )r-   )rC   s    r   ú<lambda>z#_lower_array_expr.<locals>.<lambda>j  s
   € ÀÇÁ€ r   )ÚkeyNzdef {0}(): returnÚexecrƒ   rg   r   c              3   ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr   )Útypeof)rB   r-   Úlowerers     €r   rD   z$_lower_array_expr.<locals>.<genexpr>†  s   øè ø€ ÒE°4˜'Ÿ.™.¨×.ÑEùs   ƒÚnumpyF)ÚflagsÚcaching)Únpyimplc                   ó   •— e Zd Zˆ ˆˆfd„Zy)ú%_lower_array_expr.<locals>.ExprKernelc           
      ój  •— t        || j                  j                  ‰
j                  «      }|D ���cg c]  \  }}}| j                  |||«      ‘Œ }}}}| j                  j                  ‰‰	j                  ‰
|«      }| j                  |‰
j                  | j                  j                  «      S c c}}}w r   )ÚzipÚ	outer_sigr!   ÚcastÚcontextÚcall_internalÚfndescÚreturn_type)r   r!   Úarg_zipÚvalÚintyÚouttyÚ	cast_argsr‡   ÚbuilderÚcresÚ	inner_sigs           €€€r   Úgeneratez._lower_array_expr.<locals>.ExprKernel.generate�  s¢   ø€ Ü˜$ §¡× 3Ñ 3°Y·^±^ÓDˆGà18÷:ð :Ù-˜S $¨ð Ÿ™ 3¨¨eÕ4ð :ˆIò :à—\‘\×/Ñ/Ø˜Ÿ™ i°ó<ˆFà—9‘9˜V Y×%:Ñ%:Ø!Ÿ^™^×7Ñ7ó9ð 9ùô	:s   ³B.N)rŒ   r�   rŽ   rð   )rí   rî   rï   s   €€€r   Ú
ExprKernelrß   œ  s   ø„ ÷	9r   rñ   )rS   ÚnoutrŒ   )4r£   r¤   r¥   re   ÚfilenamerJ   Úsortedrh   r-   rÂ   r�   r°   ÚparserW   rÊ   r%   rƒ   r!   rš   r:   r.   rÑ   ÚcompilerÖ   rä   rí   rf   r   r   ÚOptionalÚtyper1   rl   Údtyperç   r   ÚConfigStackÚtop_or_noner
   ÚFlagsr�   Úerror_modelÚcompile_subroutineÚnumba.nprÝ   Ú_Kernelr   rS   rò   rT   ÚloadvarÚnumpy_ufunc_kernel)rÙ   r:   Ú	expr_nameÚexpr_filenameÚexpr_var_listÚexpr_var_uniquerC   Ú	expr_argsÚexpr_paramsÚ
param_namer®   Ú
ast_moduleÚast_fnÚ	namespaceÚcode_objÚimplrä   râ   Úinner_sig_argsÚargtyrÛ   rÝ   rñ   r   r-   r!   rí   rî   rï   s   `                         @@@r   r   r   b  sä  û€ ð (¬3¬t°D«z«?×+BÑ+BÀ3ÈÓ+LÑM€IØ—H‘H×%Ñ%€MØ—N‘NÓ$€Mô œS Ó/Ñ5IÔJ€Oð &5Ö5˜c�—“Ð5€IÐ5ô 
# ?Ó	3ð /°{à&1ö3Ø"ô —G‘G˜J¨Õ-ð 3ˆð 3ô —Y‘YÐ2×9Ñ9¸)ÓDØ,¨fó6ˆ
ä�z 6Ô*¬s°:·?±?Ó/CÀqÒ/HÐHÐHØ—‘ Ñ#ˆØ#ˆ�‰ÔÜ*:¸4¿9¹9Ó*EÑ'ˆ�‰�A‰Ô˜iÜ" :Ô.÷/ô �z =°&Ó9€HÜˆ�9ÔØ�YÑ€Dð �o‰o€GØ�o‰o€GØ�—‘ÓE¸9ÔEÐF€IØ€NØ—‘ò )ˆÜ�eœUŸ^™^Ô,Ø—J‘JˆEÜ�eœUŸ[™[Ô)Ø×!Ñ! %§+¡+Õ.à×!Ñ! %Õ(ð)ð ,�	×%Ñ%×+Ñ+¨^Ð<€Iä×$Ñ$Ó&×2Ñ2Ó4€EØ % ŒH�N‰NÔ°5·:±:³<€Eð  €EÔØ×%Ñ% g¨t°YÀeØ.3ð &ó 5€Dõ !÷9ð 9�W—_‘_ô 9ô ¤ I£°QÀÔK€EØ—)‘)˜eŸj™jÑ(€E„Kà.7Ö8 dˆG�O‰O˜DÕ!Ð8€DÐ8Ø×%Ñ%Ø�˜) T¨5°*ó>ð >ùò} 6ùò3÷/ñ /üòt 9s+   Á-L.ÂL8ÂL3Â/B#L8Ë>MÌ3L8Ì8M)Mr�   Úcollectionsr   r   Ú
contextlibÚsysr   r   rÚ   r   ÚoperatorÚ
numba.corer   r   r	   r
   Únumba.core.typingr   Únumba.np.ufunc.dufuncr   r   Úregister_rewriteÚRewriter   ÚposÚUAddÚnegÚUSubÚinvertÚInvertr¡   rm   ÚAddÚsubÚSubÚmulÚMultÚtruedivÚDivÚmodÚModÚor_ÚBitOrÚrshiftÚRShiftÚxorÚBitXorÚlshiftÚLShiftÚand_ÚBitAndÚpowÚPowÚfloordivÚFloorDivrœ   ÚeqÚEqÚneÚNotEqÚltÚLtÚleÚLtEÚgtÚGtÚgeÚGtErŸ   rš   ÚcontextmanagerrÂ   ÚNodeTransformerrÄ   rÌ   rÑ   r   r|   r   r   ú<module>rE     s×  ðÛ 
ß 0Û Û 
Ý !ã Û ç BÕ BÝ %Ý (ò0ð €×ÑÐ,Ó-ôS˜×(Ñ(ó Só .ðSðn ‡L�L�#—(‘(Ø‡L�L�#—(‘(Ø‡O�O�S—Z‘Zð€	ð ‡L�L�#—'‘'Ø‡L�L�#—'‘'Ø‡L�L�#—(‘(Ø×Ñ�c—g‘gØ‡L�L�#—'‘'Ø‡L�L�#—)‘)Ø‡O�O�S—Z‘ZØ‡L�L�#—*‘*Ø‡O�O�S—Z‘ZØ‡M�M�3—:‘:Ø‡L�L�#—'‘'Ø×Ñ�s—|‘|ð€ð" ‡K�K�—‘Ø‡K�K�—‘Ø‡K�K�—‘Ø‡K�K�—‘Ø‡K�K�—‘Ø‡K�K�—‘ð€ò%GðP ×Ññ ó ð ô2˜c×1Ñ1ô ð& s§w¡wó &óJ>r   