Ë
    üÇ:jÕä ã                   ó   — 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	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZ d dlmZmZ d dlZd dlmZ d dl Z dZ!d Z"e jF                  gZ$i Z%g d¢Z&d	d
gZ'g d¢Z(g d¢Z)g d¢Z*e'e(z   e)z   e*z   ddgz   Z+ed„ «       Z,d„ Z-ed„ «       Z. G d„ de/«      Z0 G d„ de0«      Z1 G d„ de1«      Z2 G d„ de/«      Z3 G d„ de/«      Z4 e5ejl                  jn                  jq                  «       «      ejr                  gz   Z:ejv                  jn                  jq                  «       Z<ejz                  jn                  jq                  «       Z>ej~                  D � cg c]  } | j€                  ‘Œ c} ZAyc c} w )é    N)ÚtypesÚirÚconfigÚcgutilsÚerrors)Úmk_unique_varÚfind_topo_orderÚdprint_func_irÚget_global_func_typÚguardÚrequireÚget_definitionÚfind_callnameÚfind_build_sequenceÚ
find_constÚis_namedtuple_classÚbuild_definitionsÚfind_potential_aliasesÚget_canonical_aliasÚGuardException)Úcompute_cfg_from_blocks)ÚnpydeclÚ	signature)Ú	intrinsicéÿÿÿÿ)ÚemptyÚzerosÚonesÚfullÚrandÚrandn)ÚranfÚrandom_sampleÚsampleÚrandomÚstandard_normal)Ú	chisquareÚweibullÚpowerÚ	geometricÚexponentialÚpoissonÚrayleigh)ÚnormalÚuniformÚbetaÚbinomialÚfÚgammaÚ	lognormalÚlaplaceÚrandintÚ
triangularc                 ó”  ‡‡— t        t        |t        j                  j                  «      «       t        t        |t        j                  j                  «      «       |j
                  rt        j                  nt        j                  Š|j
                  rt        j                  nt        j                  Šˆˆfd„}t        ‰||«      |fS )a  
    Calculate index value "idx" relative to a size "size" value as
    (idx % size), where "size" is known to be positive.
    Note that we use the mod(%) operation here instead of
    (idx < 0 ? idx + size : idx) because we may have situations
    where idx > size due to the way indices are calculated
    during slice/range analysis.

    Both idx and size have to be Integer types.
    size should be from the array size vars that array_analysis
    adds and the bitwidth should match the platform maximum.
    c                 óŽ  •— | j                  ‰«      }| j                  ‰«      }‰j                  r|j                  |d   |«      }n|j                  |d   |«      }‰j                  r|j                  |d   |«      }n|j                  |d   |«      }|j	                  |«      }t
        j                  j                  |d«      }	|j                  d||	«      }
|j                  d||«      }|j                  d||«      }|j                  |||«      }|j                  ||	|j                  ||«      «      }|j                  |
||«      }|S )Nr   é   ú<z>=z<=)Úget_data_typeÚsignedÚsextÚzextÚnegÚllvmliter   ÚConstantÚicmp_signedÚselectÚadd)ÚcontextÚbuilderÚsigÚargsÚll_idx_unified_tyÚll_unified_tyÚidxÚsizeÚneg_sizeÚzeroÚidx_negativeÚpos_oversizeÚneg_oversizeÚpos_resÚneg_resÚmodÚidx_unifiedÚ
unified_tys                   €€úq/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/numba/parfors/array_analysis.pyÚcodegenzwrap_index.<locals>.codegenf   s0  ø€ Ø#×1Ñ1°+Ó>ÐØ×-Ñ-¨jÓ9ˆØ×ÒØ—,‘,˜t A™wÐ(9Ó:‰Cà—,‘,˜t A™wÐ(9Ó:ˆCØ×ÒØ—<‘<  Q¡¨Ó7‰Dà—<‘<  Q¡¨Ó7ˆDØ—;‘;˜tÓ$ˆÜ�{‰{×#Ñ# M°1Ó5ˆð ×*Ñ*¨3°°TÓ:ˆØ×*Ñ*¨4°°dÓ;ˆØ×*Ñ*¨4°°hÓ?ˆØ—.‘. ¨t°SÓ9ˆØ—.‘. ¨t°W·[±[ÀÀdÓ5KÓLˆØ�n‰n˜\¨7°GÓ<ˆØˆ
ó    )	r   Ú
isinstancer   ÚscalarsÚIntegerr=   ÚintpÚuintpr   )Ú	typingctxrL   rM   rY   rV   rW   s       @@rX   Ú
wrap_indexra   Q   s~   ù€ ô ŒJ�sœEŸM™M×1Ñ1Ó2Ô3ÜŒJ�tœUŸ]™]×2Ñ2Ó3Ô4ð  $Ÿ{š{”—’´·±€JØ #§
¢
”%—*’*´·±€Kõô0 �Z  dÓ+¨WÐ4Ð4rZ   c                 ó6   — | dk  r| | k  ry| |z   S | |k\  r|S | S ©Nr   © )rL   rM   s     rX   Úwrap_index_literalre   �   s0   € Ø
ˆQ‚wØ�4�%Š<Øà˜‘:Ðà�$Š;ØˆKàˆJrZ   c                 óL  — t        |«      dkD  rt        j                  |«      f}t        |d   «      dkD  sJ ‚t        d„ |d   dd D «       «      sJ ‚t	        |d   d   t        j
                  «      st        j                  d«      ‚d„ }t        t        j                  g|¢­Ž |fS )zò
    A function that asserts the inputs are of equivalent size,
    and throws runtime error when they are not. The input is
    a vararg that contains an error message, followed by a set
    of objects of either array, tuple or integer.
    r:   r   c              3   ó¬   K  — | ]L  }t        |t        j                  t        j                  t        j                  t        j
                  f«      –— ŒN y ­w©N)r[   r   ÚArrayCompatibleÚ	BaseTupleÚ	SliceTyper]   )Ú.0Úas     rX   ú	<genexpr>zassert_equiv.<locals>.<genexpr>ž   sD   è ø€ ò ð ô 	�1Ü×!Ñ!Ü�O‰OÜ�O‰OÜ�M‰Mð	
÷ 	ñùs   ‚AANz&first argument must be a StringLiteralc           	      óˆ  ‡ ‡‡	‡
— t        |«      dk(  sJ ‚t        j                  ‰|d   «      }|j                  d   }|j                  d   d   j                  Š	ˆˆ fd„Š
ˆˆ ˆ	ˆ
fd„}t        dt        |«      dz
  «      D ]  } |||   ||   ||dz      ||dz      «       Œ! ‰ j                  ‰t        j                  d «      }|S )Nr:   r   c                 ó  •— t        |t        j                  «      r9 ‰j                  |«      ‰‰| «      }t	        j
                  ‰|j                  «      S t        |t        j                  «      rt	        j
                  ‰| «      S | gS rh   )r[   r   ri   Ú
make_arrayr   Úunpack_tupleÚshaperj   )rm   ÚatyÚaryrG   rF   s      €€rX   Úunpack_shapesz4assert_equiv.<locals>.codegen.<locals>.unpack_shapes°   sm   ø€ Ü˜#œu×4Ñ4Ô5Ø-�g×(Ñ(¨Ó-¨g°wÀÓB�Ü×+Ñ+¨G°S·Y±YÓ?Ð?Ü˜C¤§¡Ô1Ü×+Ñ+¨G°QÓ7Ð7à�s�
rZ   c                 óž  •—  ‰| |«      } ‰||«      }t        |«      t        |«      k(  sJ ‚t        ||«      D ]n  \  }}‰j                  d||«      }‰j                  |«      5 \  }	}
|	5  	 d d d «       |
5  ‰j                  j                  ‰t        ‰f«       d d d «       d d d «       Œp y # 1 sw Y   ŒAxY w# 1 sw Y   Œ xY w# 1 sw Y   Œ“xY w)Nz==)ÚlenÚzipÚicmp_unsignedÚif_elseÚ	call_convÚreturn_user_excÚAssertionError)rm   rt   ÚbÚbtyÚashapesÚbshapesÚmÚnÚm_eq_nÚthenÚorelserG   rF   Úmsgrv   s              €€€€rX   Úpairwisez/assert_equiv.<locals>.codegen.<locals>.pairwise¹   sÛ   ø€ Ù# A sÓ+ˆGÙ# A sÓ+ˆGÜ�w“<¤3 w£<Ò/Ð/Ð/Ü˜g wÓ/ò ‘��AØ ×.Ñ.¨t°Q¸Ó:�Ø—_‘_ VÓ,ð ±°°vØñ Ø÷àñ Ø×)Ñ)×9Ñ9Ø#¤^°c°Vô÷÷ð ñ÷ð ú÷ð ú÷ð ús<   Á#CÁ)B+Á+
CÁ5#B7ÂCÂ+B4Â0CÂ7C Â<CÃC	)	rx   r   rr   rI   Úliteral_valueÚrangeÚget_constant_genericr   ÚNoneType)rF   rG   rH   rI   ÚtupÚtup_typer‰   ÚiÚrrˆ   rv   s   ``       @@rX   rY   zassert_equiv.<locals>.codegenª   s½   û€ Ü�4‹y˜AŠ~Ðˆ~Ü×"Ñ" 7¨D°©GÓ4ˆØ—8‘8˜A‘;ˆØ�h‰h�q‰k˜!‰n×*Ñ*ˆõ	÷	ô �qœ#˜h›-¨!Ñ+Ó,ò 	GˆAÙ�S˜‘V˜X a™[¨#¨a°!©e©*°h¸qÀ1¹u±oÕFð	Gà×(Ñ(¨´%·.±.À$ÓGˆØˆrZ   )
rx   r   ÚStarArgTupleÚallr[   ÚStringLiteralr   ÚTypingErrorr   Únone)r`   ÚvalrY   s      rX   Úassert_equivr˜   Ž   s°   € ô ˆ3ƒx�!‚|ô ×!Ñ! #Ó&Ð(ˆäˆs�1‰v‹;˜Š?Ðˆ?äñ ð �Q‘˜˜�ôô ð ð ô �c˜!‘f˜Q‘i¤×!4Ñ!4Ô5Ü× Ñ Ð!IÓJÐJò ôD ”U—Z‘ZÐ& #Ò&¨Ð/Ð/rZ   c                   ó`   — e Zd ZdZd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y)ÚEquivSetzPEquivSet keeps track of equivalence relations between
    a set of objects.
    Nc                 ó>   — |r|ni | _         |r|ni | _        || _        y)zdCreate a new EquivSet object. Optional keyword arguments are for
        internal use only.
        N)Ú
obj_to_indÚ
ind_to_objÚnext_ind)Úselfrœ   r�   rž   s       rX   Ú__init__zEquivSet.__init__Õ   s#   € ñ )3™*¸ˆŒá(2™*¸ˆŒð !ˆ�rZ   c                 ó   — t        «       S )z)Return an empty EquivSet object.
        )rš   ©rŸ   s    rX   r   zEquivSet.emptyã   s   € ô ‹zÐrZ   c                 ó¦   — t        t        j                  | j                  «      t        j                  | j                  «      | j
                  ¬«      S )úReturn a new copy.
        )rœ   r�   Únext_id)rš   ÚcopyÚdeepcopyrœ   r�   rž   r¢   s    rX   ÚclonezEquivSet.cloneè   s8   € ô Ü—}‘} T§_¡_Ó5Ü—}‘} T§_¡_Ó5Ø—M‘Mô
ð 	
rZ   c                 ó8   — dj                  | j                  «      S )NzEquivSet({}))Úformatr�   r¢   s    rX   Ú__repr__zEquivSet.__repr__ñ   s   € Ø×$Ñ$ T§_¡_Ó5Ð5rZ   c                 ó    — | j                   i k(  S )z=Return true if the set is empty, or false otherwise.
        )rœ   r¢   s    rX   Úis_emptyzEquivSet.is_emptyô   s   € ð �‰ "Ñ$Ð$rZ   c                 ó:   — | j                   j                  |d«      S )zkReturn the internal index (greater or equal to 0) of the given
        object, or -1 if not found.
        r   )rœ   Úget)rŸ   Úxs     rX   Ú_get_indzEquivSet._get_indù   s   € ð �‰×"Ñ" 1 bÓ)Ð)rZ   c                 ó†   — || j                   v r| j                   |   }|S | j                  }| xj                  dz  c_        |S )zyReturn the internal index (greater or equal to 0) of the given
        object, or create a new one if not found.
        r:   )rœ   rž   )rŸ   r°   r�   s      rX   Ú_get_or_add_indzEquivSet._get_or_add_indÿ   sC   € ð �—‘ÑØ—‘ Ñ"ˆAð ˆð —‘ˆAØ�MŠM˜QÑ�MØˆrZ   c                 ó¤  ‡ — t        |«      dkD  sJ ‚t        ˆ fd„|D «       «      }t        |«      }t        j                  dk\  rt        d||«       |‰ j                  vrg ‰ j                  |<   t        ||«      D ]Ô  \  }}||k(  r@|‰ j                  |   vsŒ‰ j                  |   j                  |«       |‰ j                  |<   ŒK|‰ j                  v rO‰ j                  |   D ]/  }|‰ j                  |<   ‰ j                  |   j                  |«       Œ1 ‰ j                  |= Œ¨|‰ j                  |<   ‰ j                  |   j                  |«       ŒÖ y)zXBase method that inserts a set of equivalent objects by modifying
        self.
        r:   c              3   ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrh   )r³   ©rl   r°   rŸ   s     €rX   rn   z#EquivSet._insert.<locals>.<genexpr>  s   øè ø€ Ò;°�T×)Ñ)¨!×,Ñ;ùó   ƒé   z_insert:N)
rx   ÚtupleÚminr   ÚDEBUG_ARRAY_OPTÚprintr�   ry   Úappendrœ   )rŸ   ÚobjsÚindsÚindr�   Úobjr°   s   `      rX   Ú_insertzEquivSet._insert
  s6  ø€ ô �4‹y˜1Š}Ðˆ}äÓ;°dÔ;Ó;ˆÜ�$‹iˆä×!Ñ! QÒ&Ü�*˜d DÔ)à�t—‘Ñ&Ø#%ˆD�O‰O˜CÑ ä˜$ “oò 	5‰FˆAˆsØ�CŠxØ˜tŸ™¨sÑ3Ò3Ø—O‘O CÑ(×/Ñ/°Ô4Ø+.�D—O‘O CÒ(à˜Ÿ™Ñ'à!Ÿ_™_¨QÑ/ò 7˜Ø-0˜Ÿ™¨Ñ*ØŸ™¨Ñ,×3Ñ3°AÕ6ð7ð Ÿ™¨Ñ*ð ,/�D—O‘O CÑ(Ø—O‘O CÑ(×/Ñ/°Õ4ñ	5rZ   c                 óÚ   ‡— |D �cg c]  }| j                  |«      ‘Œ }}t        |«      Š‰dk7  rt        ˆfd„|D «       «      S t        |D �cg c]
  }||d   k(  ‘Œ c}«      S c c}w c c}w )zfTry to derive if given objects are equivalent, return true
        if so, or false otherwise.
        r   c              3   ó(   •K  — | ]	  }|‰k(  –— Œ y ­wrh   rd   )rl   r�   rÀ   s     €rX   rn   z$EquivSet.is_equiv.<locals>.<genexpr>1  s   øè ø€ Ò. A�q˜C•xÑ.ùó   ƒr   )r±   Úmaxr“   )rŸ   r¾   r°   r¿   rÀ   s       @rX   Úis_equivzEquivSet.is_equiv*  sj   ø€ ð +/Ö/ Q�—‘˜aÕ Ð/ˆÐ/Ü�$‹iˆØ�"Š9ÜÓ.¨Ô.Ó.Ð.ä¨dÖ3¨˜˜T !™W›Ò3Ó4Ð4ùò 0ùò
 4s   †A#ÁA(c                 ó„   — | j                  |«      }|dk\  r*| j                  |   }|D ]  }t        |t        «      sŒ|c S  y)zvCheck if obj is equivalent to some int constant, and return
        the constant if found, or None otherwise.
        r   N)r±   r�   r[   Úint)rŸ   rÁ   rÀ   r¾   r°   s        rX   Úget_equiv_constzEquivSet.get_equiv_const5  sJ   € ð �m‰m˜CÓ ˆØ�!Š8Ø—?‘? 3Ñ'ˆDØò �Ü˜a¤Õ%Ø’Hðð rZ   c                 ór   — | j                  |«      }|dk\  rt        | j                  |   «      S t        «       S )ú.Return the set of equivalent objects.
        r   )r±   Úsetr�   )rŸ   rÁ   rÀ   s      rX   Úget_equiv_setzEquivSet.get_equiv_setA  s4   € ð �m‰m˜CÓ ˆØ�!Š8Ü�t—‘ sÑ+Ó,Ð,Ü‹uˆrZ   c                 ó$   — | j                  |«      S )z�Insert a set of equivalent objects by modifying self. This
        method can be overloaded to transform object type before insertion.
        )rÂ   )rŸ   r¾   s     rX   Úinsert_equivzEquivSet.insert_equivI  s   € ð �|‰|˜DÓ!Ð!rZ   c                 ó�  ‡ — ‰ j                  «       }‰ j                  |_        |j                  j                  «       D ]†  }t	        ˆ fd„|D «       «      }i }t        ||«      D ]*  \  }}||v r||   j                  |«       Œ|dk\  sŒ%|g||<   Œ, |j                  «       D ]"  }t        |«      dkD  sŒ|j                  |«       Œ$ Œˆ |S )z± Return the intersection of self and the given equiv_set,
        without modifying either of them. The result will also keep
        old equivalence indices unchanged.
        c              3   ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrh   ©r±   r¶   s     €rX   rn   z%EquivSet.intersect.<locals>.<genexpr>X  s   øè ø€ Ò8¨a˜Ÿ™ q×)Ñ8ùr·   r   r:   )	r   rž   r�   Úvaluesr¹   ry   r½   rx   rÂ   )	rŸ   Ú	equiv_setÚnew_setr¾   r¿   r�   r�   r°   Úvs	   `        rX   Ú	intersectzEquivSet.intersectO  sË   ø€ ð
 —*‘*“,ˆØŸ=™=ˆÔà×(Ñ(×/Ñ/Ó1ò 	'ˆDÜÓ8°4Ô8Ó8ˆDØˆJä˜D $›ò (‘��1Ø˜
‘?Ø˜q‘M×(Ñ(¨Õ+Ø˜!“VØ%& C�J˜q’Mð	(ð  ×&Ñ&Ó(ò '�Ü�q“6˜A“:Ø—O‘O AÕ&ñ'ð	'ð ˆrZ   )NNr   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r    r   r¨   r«   r­   r±   r³   rÂ   rÇ   rÊ   rÎ   rÐ   rØ   rd   rZ   rX   rš   rš   Ï   sI   „ ñó!òò

ò6ò%ò
*ò	ò5ò@	5ò
òò"órZ   rš   c                   ó®   ‡ — e Zd ZdZ	 	 	 	 	 	 dˆ fd„	Zd„ Zd„ Zd„ Zd„ Zˆ fd„Z	ˆ fd„Z
d	„ Zˆ fd
„Zˆ fd„Zˆ fd„Zd„ Zd„ Zd„ Zd„ Zˆ fd„Zd„ Zd„ Zˆ xZS )ÚShapeEquivSetad  Just like EquivSet, except that it accepts only numba IR variables
    and constants as objects, guided by their types. Arrays are considered
    equivalent as long as their shapes are equivalent. Scalars are
    equivalent only when they are equal in value. Tuples are equivalent
    when they are of the same size, and their elements are equivalent.
    c                 ó€   •— || _         |r|ni | _        |r|ni | _        |r|ni | _        t        t
        | �  |||«       y)zÕCreate a new ShapeEquivSet object, where typemap is a dictionary
        that maps variable names to their types, and it will not be modified.
        Optional keyword arguments are for internal use only.
        N)ÚtypemapÚdefsÚ
ind_to_varÚind_to_constÚsuperrÞ   r    )	rŸ   rà   rá   râ   rœ   r�   r¥   rã   Ú	__class__s	           €rX   r    zShapeEquivSet.__init__q  sE   ø€ ð ˆŒñ !‘D bˆŒ	ñ )3™*¸ˆŒá,8™L¸bˆÔäŒm˜TÑ+¨J¸
ÀGÕLrZ   c                 ó.   — t        | j                  i «      S )z'Return an empty ShapeEquivSet.
        )rÞ   rà   r¢   s    rX   r   zShapeEquivSet.empty�  s   € ô ˜TŸ\™\¨2Ó.Ð.rZ   c                 óp  — t        | j                  t        j                  | j                  «      t        j                  | j                  «      t        j
                  | j                  «      t        j
                  | j                  «      | j                  t        j
                  | j                  «      ¬«      S )r¤   )rá   râ   rœ   r�   r¥   rã   )
rÞ   rà   r¦   rá   râ   r§   rœ   r�   rž   Úind_toconstr¢   s    rX   r¨   zShapeEquivSet.clone’  sq   € ô Ø�L‰LÜ—‘˜4Ÿ9™9Ó%Ü—y‘y §¡Ó1Ü—}‘} T§_¡_Ó5Ü—}‘} T§_¡_Ó5Ø—M‘MÜŸ™ t×'7Ñ'7Ó8ô
ð 	
rZ   c                 ód   — dj                  | j                  | j                  | j                  «      S )Nz1ShapeEquivSet({}, ind_to_var={}, ind_to_const={}))rª   r�   râ   rã   r¢   s    rX   r«   zShapeEquivSet.__repr__Ÿ  s*   € ØB×IÑIØ�O‰O˜TŸ_™_¨d×.?Ñ.?ó
ð 	
rZ   c                 óH  ‡ ‡‡— t        |t        j                  «      st        |t        «      rÁt        |t        «      r|n|j                  Š‰‰ j
                  vr‰fS ‰ j
                  ‰   }t        |t        j                  t        j                  f«      rVt        |t        j                  «      r|j                  n
t        |«      }|dk(  r‰fS t        ˆfd„t        |«      D «       «      S ‰fS t        |t        j                  «      r3t        |j                  t        «      r|j                  S |j                  fS t        |t        «      rˆ fd„Št        ˆfd„|D «       «      S t        |t        «      r|fS t         j"                  dk\  rt%        dt'        |«      › d�«       y)	zÞReturn a set of names for the given obj, where array and tuples
        are broken down to their individual shapes or elements. This is
        safe because both Numba array shapes and Python tuples are immutable.
        r   c              3   óB   •K  — | ]  }d j                  ‰|«      –— Œ y­w)z{}#{}N)rª   )rl   r�   Únames     €rX   rn   z+ShapeEquivSet._get_names.<locals>.<genexpr>·  s   øè ø€ Ò N¸Q §¡°°a×!8Ñ Nùs   ƒc                 óP   •— ‰j                  | «      }t        |«      dk7  r|d   S |S rc   )Ú
_get_namesrx   )r°   ÚnamesrŸ   s     €rX   Ú	get_namesz+ShapeEquivSet._get_names.<locals>.get_namesÁ  s*   ø€ ØŸ™¨Ó*�Ü�u“: ’?Ø  ™8�OØ�rZ   c              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrh   rd   )rl   r°   rð   s     €rX   rn   z+ShapeEquivSet._get_names.<locals>.<genexpr>Ç  s   øè ø€ Ò3¨!™ 1ŸÑ3ùs   ƒr:   zIgnoring untracked object type z in ShapeEquivSetrd   )r[   r   ÚVarÚstrrì   rà   r   rj   ri   Úndimrx   r¹   r‹   ÚConstÚvaluerÉ   r   r»   r¼   Útype)rŸ   rÁ   Útyprô   rð   rì   s   `   @@rX   rî   zShapeEquivSet._get_names¤  sK  ú€ ô
 �cœ2Ÿ6™6Ô"¤j°´cÔ&:Ü$ S¬#Ô.‘3°C·H±HˆDØ˜4Ÿ<™<Ñ'Ø�w�à—,‘,˜tÑ$ˆCÜ˜#¤§¡´×1FÑ1FÐGÔHä% c¬5×+@Ñ+@ÔAð Ÿšä  ›Xð ð ˜1’9Ø ˜7�Nä Ó NÄ%ÈÃ+Ô NÓNÐNà�w�Ü˜œRŸX™XÔ&Ü˜#Ÿ)™)¤UÔ+Ø—y‘yÐ àŸ	™	�|Ð#Ü˜œUÔ#ôô Ó3¨sÔ3Ó3Ð3Ü˜œSÔ!Ø�6ˆMÜ×!Ñ! QÒ&ÜØ1´$°s³)°Ð<MÐNôPàrZ   c                 óú  •‡— t        |«      dkD  sJ ‚|D �cg c]  }| j                  |«      ‘Œ }}|D �cg c]
  }|dk7  sŒ	|‘Œ }}t        |«      dk  ry|D �cg c]  }t        |«      ‘Œ }}|d   Št        ˆfd„|D «       «      s.t        j                  dk\  rt        dj                  |«      «       yt        ‰«      D ]&  }|D �cg c]  }||   ‘Œ	 }}t        t        | �*  |Ž rŒ& y yc c}w c c}w c c}w c c}w )zWOverload EquivSet.is_equiv to handle Numba IR variables and
        constants.
        r:   rd   Fr   c              3   ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrh   rd   ©rl   r°   rô   s     €rX   rn   z)ShapeEquivSet.is_equiv.<locals>.<genexpr>Ú  s   øè ø€ Ò, �4˜1•9Ñ,ùrÅ   z#is_equiv: Dimension mismatch for {}T)rx   rî   r“   r   r»   r¼   rª   r‹   rä   rÞ   rÇ   )
rŸ   r¾   r°   Ú	obj_namesrï   Úndimsr�   Úobj_namerô   rå   s
           @€rX   rÇ   zShapeEquivSet.is_equivÏ  sÿ   ù€ ô �4‹y˜1Š}Ðˆ}Ø15Ö6¨A�T—_‘_ QÕ'Ð6ˆ	Ð6Ø )Ö5˜1¨Q°"«W’QÐ5ˆ	Ð5Üˆy‹>˜QÒØØ)2Ö3 ”�U•Ð3ˆÐ3Ø�Q‰xˆÜÓ, eÔ,Ô,Ü×%Ñ%¨Ò*ÜÐ;×BÑBÀ4ÓHÔIØÜ�t“ò 	ˆAØ1:Ö; X�X˜a“[Ð;ˆEÐ;Üœ¨Ñ6¸Ò>Ùð	ð ùò 7ùÚ5ùò 4ùò <s   —C)µ
C.Á C.ÁC3ÃC8c                 óp   •— | j                  |«      }t        |«      dk7  ryt        t        | �  |d   «      S )ztIf the given object is equivalent to a constant scalar,
        return the scalar value, or None otherwise.
        r:   Nr   )rî   rx   rä   rÞ   rÊ   ©rŸ   rÁ   rï   rå   s      €rX   rÊ   zShapeEquivSet.get_equiv_constä  s7   ø€ ð —‘ Ó$ˆÜˆu‹:˜Š?ØÜ”] DÑ9¸%À¹(ÓCÐCrZ   c                 óº   — | j                  |«      }t        |«      dk7  ry| j                  |d   «      }| j                  j	                  |g «      }|g k7  r|d   S dS )ztIf the given object is equivalent to some defined variable,
        return the variable, or None otherwise.
        r:   Nr   )rî   rx   r±   râ   r¯   )rŸ   rÁ   rï   rÀ   Úvss        rX   Úget_equiv_varzShapeEquivSet.get_equiv_varí  s]   € ð —‘ Ó$ˆÜˆu‹:˜Š?ØØ�m‰m˜E !™HÓ%ˆØ�_‰_× Ñ   bÓ)ˆØ˜bšˆr�!‰uÐ* dÐ*rZ   c                 óp   •— | j                  |«      }t        |«      dk7  ryt        t        | �  |d   «      S )rÌ   r:   Nr   )rî   rx   rä   rÞ   rÎ   r   s      €rX   rÎ   zShapeEquivSet.get_equiv_setø  s7   ø€ ð —‘ Ó$ˆÜˆu‹:˜Š?ØÜ”] DÑ7¸¸a¹ÓAÐArZ   c                 ó�  •— g }|D ]/  }|| j                   v sŒ|j                  | j                   |   «       Œ1 g }d}t        «       }t        |«      D ]�  }|| j                  v rO| j                  |   D ]=  }|j
                  |vsŒ|j                  |«       |j                  |j
                  «       Œ? || j                  v sŒo|�J ‚| j                  |   }Œƒ t        t        | �+  |«       | j                   |d      }	t        |«      D ]  }|| j                  v sŒ| j                  |= Œ  || j                  |	<   |�|| j                  |	<   yy)zCOverload EquivSet._insert to manage ind_to_var dictionary.
        Nr   )rœ   r½   rÍ   Úsortedrâ   rì   rE   rã   rä   rÞ   rÂ   )rŸ   r¾   r¿   rÁ   ÚvarlistÚconstvalrï   r�   r°   Únew_indrå   s             €rX   rÂ   zShapeEquivSet._insert   sP  ø€ ð ˆØò 	2ˆCØ�d—o‘oÒ%Ø—‘˜DŸO™O¨CÑ0Õ1ð	2ð ˆØˆÜ“ˆÜ˜“ò 	0ˆAØ�D—O‘OÑ#ØŸ™¨Ñ+ò *�AØŸF™F ešOØŸ™ qÔ)ØŸ	™	 !§&¡&Õ)ð*ð �D×%Ñ%Ò%ØÐ'Ð'Ð'Ø×,Ñ,¨QÑ/‘ð	0ô 	Œm˜TÑ*¨4Ô0Ø—/‘/ $ q¡'Ñ*ˆÜ�T“ò 	'ˆAØ�D—O‘OÒ#Ø—O‘O AÑ&ð	'ð $+ˆ�‰˜Ñ ØÐØ)1ˆD×Ñ˜gÒ&ð  rZ   c                 óÎ  •‡— t        |«      dkD  sJ ‚|D �cg c]  }| j                  |«      ‘Œ }}|D �cg c]
  }|dk7  sŒ	|‘Œ }}t        |«      dk  ryt        |D �cg c]  }t        |«      ‘Œ c}g «      }|D �cg c]  }t        |«      ‘Œ }}|d   Št	        ˆfd„|D «       «      sJ dj                  |«      «       ‚g }g }|D ]Å  }t        |t        «      s|f}|D ]«  }	t        |	t        j                  «      rJ|	j                  |vr<|	j                  | j                  v r|j                  d|	«       n|j                  |	«       t        |	t        j                  «      sŒ‚|	j                  |vsŒ‘|j                  |	j                  «       Œ­ ŒÇ |D ]„  }|j                  }
|
|v sŒ|
| j                   vsŒ#|
g| j"                  | j$                  <   | j$                  | j                   |
<   |g| j&                  | j$                  <   | xj$                  dz  c_        Œ† |D ]w  }||v sŒ|| j                   vsŒ|g| j"                  | j$                  <   | j$                  | j                   |<   || j(                  | j$                  <   | xj$                  dz  c_        Œy d}t+        ‰«      D ]*  }|D �cg c]  }||   ‘Œ	 }}t-        t.        | �b  |Ž }|xs |}Œ, |S c c}w c c}w c c}w c c}w c c}w )zºOverload EquivSet.insert_equiv to handle Numba IR variables and
        constants. Input objs are either variable or constant, and at least
        one of them must be variable.
        r:   rd   Nr   c              3   ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrh   rd   rû   s     €rX   rn   z-ShapeEquivSet.insert_equiv.<locals>.<genexpr>)  s   øè ø€ ò 
ØˆD�A�Iñ
ùrÅ   zDimension mismatch for {}F)rx   rî   ÚsumÚlistr“   rª   r[   r¹   r   rò   rì   rá   Úinsertr½   rõ   rö   rœ   r�   rž   râ   rã   r‹   rä   rÞ   rÐ   )rŸ   r¾   r°   rü   rï   rý   r  Ú	constlistrÁ   Úvarrì   ÚconstÚsome_changer�   rþ   Úie_resrô   rå   s                   @€rX   rÐ   zShapeEquivSet.insert_equiv  s¹  ù€ ô
 �4‹y˜1Š}Ðˆ}Ø15Ö6¨A�T—_‘_ QÕ'Ð6ˆ	Ð6Ø )Ö5˜1¨Q°"«W’QÐ5ˆ	Ð5Üˆy‹>˜QÒØÜ iÖ0 ”T˜!•WÒ0°"Ó5ˆØ!*Ö+˜A”�Q•Ð+ˆÐ+Ø�Q‰xˆÜó 
Ø$ô
ô 
ð 	4à&×-Ñ-¨dÓ3ó	4ð 
ð ˆØˆ	Øò 	0ˆCÜ˜c¤5Ô)Ø�f�Øò 0�Ü˜c¤2§6¡6Ô*°C·H±HÀÑ4Gà—x‘x 4§9¡9Ñ,ØŸ™ q¨#Õ.àŸ™ sÔ+Ü˜c¤2§8¡8Õ,°c·i±iÀ9Ò6LØ×$Ñ$ S§Y¡YÕ/ñ0ð	0ð ò 	#ˆCØ—8‘8ˆDØ�uŠ} d¨d¯o©oÒ&=Ø26°�—‘ §¡Ñ.Ø(,¯©�—‘ Ñ%Ø25°�—‘ §¡Ñ.Ø—’ Ñ"–ð	#ð ò 	#ˆEØ˜Š~ u°·±Ò'?Ø27°�—‘ §¡Ñ.Ø)-¯©�—‘ Ñ&Ø38�×!Ñ! $§-¡-Ñ0Ø—’ Ñ"–ð	#ð ˆä�t“ò 	0ˆAØ1:Ö; X�X˜a“[Ð;ˆEÐ;Üœ=¨$Ñ<¸eÐDˆFØ%Ò/¨‰Kð	0ð
 Ðùòc 7ùÚ5ùò 1ùÚ+ùòP <s"   —Kµ
KÁ KÁKÁ<KÊ&K"c                 ó(   — | j                  |«      duS )zEReturn true if the shape of the given variable is available.
        N)Ú	get_shape©rŸ   rì   s     rX   Ú	has_shapezShapeEquivSet.has_shapeU  s   € ð �~‰~˜dÓ#¨4Ð/Ð/rZ   c                 ó.   — t        | j                  |«      S )ztReturn a tuple of variables that corresponds to the shape
        of the given array, or None if not found.
        )r   Ú
_get_shaper  s     rX   r  zShapeEquivSet.get_shapeZ  s   € ô �T—_‘_ dÓ+Ð+rZ   c                 óV  — | j                  |«      }t        |dk7  «       g }|D ]y  }t        || j                  v «       | j                  |   }|g k7  r|j                  |d   «       ŒCt        || j                  v «       | j                  |   }|j                  |«       Œ{ t        |«      S )z„Return a tuple of variables that corresponds to the shape
        of the given array, or raise GuardException if not found.
        rd   r   )Úget_shape_classesr   râ   r½   rã   r¹   )rŸ   rì   r¿   rs   r�   r  s         rX   r  zShapeEquivSet._get_shape`  s¥   € ð ×%Ñ% dÓ+ˆÜ�˜‘
ÔØˆØò 	!ˆAÜ�A˜Ÿ™Ð(Ô)Ø—‘ Ñ#ˆBØ�RŠxØ—‘˜R ™UÕ#ä˜˜T×.Ñ.Ð.Ô/Ø×&Ñ& qÑ)�Ø—‘˜RÕ ð	!ô �U‹|ÐrZ   c                 ó¨  ‡ — t        |t        j                  «      r|j                  }|‰ j                  v r‰ j                  |   nd}t        |t
        j                  t
        j                  t
        j                  f«      sg S t        |t
        j                  «      r|j                  dk(  rg S ‰ j                  |«      }t        ˆ fd„|D «       «      }|S )zùInstead of the shape tuple, return tuple of int, where
        each int is the corresponding class index of the size object.
        Unknown shapes are given class index -1. Return empty tuple
        if the input name is a scalar variable.
        Nr   c              3   ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrh   rÓ   )rl   rì   rŸ   s     €rX   rn   z2ShapeEquivSet.get_shape_classes.<locals>.<genexpr>…  s   øè ø€ Ò;¨T�T—]‘] 4×(Ñ;ùr·   )r[   r   rò   rì   rà   r   rj   rk   ri   rô   rî   r¹   )rŸ   rì   rø   rï   r¿   s   `    rX   r  zShapeEquivSet.get_shape_classesr  s¤   ø€ ô �dœBŸF™FÔ#Ø—9‘9ˆDØ$(¨D¯L©LÑ$8ˆd�l‰l˜4Ò ¸dˆä�sÜ—‘¤§¡´%×2GÑ2Gðô ð ˆIä�cœ5×0Ñ0Ô1°c·h±hÀ!²mØˆIØ—‘ Ó%ˆÜÓ;°UÔ;Ó;ˆØˆrZ   c                 ó6  •— t         t        | �  |«      }i }|j                  j	                  «       D ]Ù  \  }}t        |«      dkD  sJ ‚|d   }|| j                  v sJ ‚||j                  v sJ ‚| j                  |   }|j                  |   }|| j                  v sJ ‚||j                  v sJ ‚g }	|j                  |   D �
cg c]  }
|
j                  ‘Œ }}
| j                  |   D ]"  }
|
j                  |v sŒ|	j                  |
«       Œ$ |	||<   ŒÛ ||_        |S c c}
w )z<Overload the intersect method to handle ind_to_var.
        r   )
rä   rÞ   rØ   r�   Úitemsrx   rœ   râ   rì   r½   )rŸ   rÕ   Únewsetrâ   r�   r¾   rÁ   ÚjÚkr  r°   rï   rå   s               €rX   rØ   zShapeEquivSet.intersectˆ  s5  ø€ ô ”} dÑ5°iÓ@ˆØˆ
Ø×(Ñ(×.Ñ.Ó0ò 	$‰GˆAˆtÜ�t“9˜q’=Ð �=Ø�q‘'ˆCØ˜$Ÿ/™/Ñ)Ð)Ð)Ø˜)×.Ñ.Ñ.Ð.Ð.Ø—‘ Ñ$ˆAØ×$Ñ$ SÑ)ˆAØ˜Ÿ™Ñ'Ð'Ð'Ø˜	×,Ñ,Ñ,Ð,Ð,ØˆGØ%.×%9Ñ%9¸!Ñ%<Ö= �Q—V“VÐ=ˆEÐ=Ø—_‘_ QÑ'ò &�Ø—6‘6˜U’?Ø—N‘N 1Õ%ð&ð $ˆJ�qŠMð	$ð 'ˆÔØˆùò >s   Â=Dc                 ór  — t        |t        j                  «      r|j                  }|| j                  v �rn| j                  |xx   dz  cc<   t        | j                  |«      «      }|D �]6  }|| j                  v sŒ|j                  |«       | j                  |   }| j                  |= | j                  |   j                  |«       | j                  |   g k(  r| j                  |= || j                  v sJ ‚| j                  |   D �cg c]  }|j                  ‘Œ }}||v sŒ¸|j                  |«      }| j                  |   |= | j                  |   g k(  sŒì| j                  |= || j                  v s�Œ	| j                  |   D ]  }	| j                  |	= Œ | j                  |= �Œ9 yd| j                  |<   yc c}w )a  Increment the internal count of how many times a variable is being
        defined. Most variables in Numba IR are SSA, i.e., defined only once,
        but not all of them. When a variable is being re-defined, it must
        be removed from the equivalence relation and added to the redefined
        set but only if that redefinition is not known to have the same
        equivalence classes. Those variables redefined are removed from all
        the blocks' equivalence sets later.

        Arrays passed to define() use their whole name but these do not
        appear in the equivalence sets since they are stored there per
        dimension. Calling _get_names() here converts array names to
        dimensional names.

        This function would previously invalidate if there were any multiple
        definitions of a variable.  However, we realized that this behavior
        is overly restrictive.  You need only invalidate on multiple
        definitions if they are not known to be equivalent. So, the
        equivalence insertion functions now return True if some change was
        made (meaning the definition was not equivalent) and False
        otherwise. If no change was made, then define() need not be
        called. For no change to have been made, the variable must
        already be present. If the new definition of the var has the
        case where lhs and rhs are in the same equivalence class then
        again, no change will be made and define() need not be called
        or the variable invalidated.
        r:   N)r[   r   rò   rì   rá   r  rî   rœ   rE   r�   Úremoverâ   Úindex)
rŸ   rì   Ú	redefinedÚname_resÚone_namer�   r°   rï   r!  rÁ   s
             rX   ÚdefinezShapeEquivSet.defineŸ  sŽ  € ô6 �dœBŸF™FÔ#Ø—9‘9ˆDØ�4—9‘9ÒØ�I‰I�d‹O˜qÑ ‹OÜ˜DŸO™O¨DÓ1Ó2ˆHØ$ó 7�ð ˜tŸ™Ò.Ø—M‘MØ ôð Ÿ™¨Ñ1�AØŸ™¨Ð1Ø—O‘O AÑ&×-Ñ-¨hÔ7Ø—‘ qÑ)¨RÒ/Ø ŸO™O¨AÐ.Ø §¡Ñ/Ð/Ð/Ø-1¯_©_¸QÑ-?Ö@¨˜QŸV›VÐ@�EÐ@Ø˜u’}Ø!ŸK™K¨Ó-˜Ø ŸO™O¨AÑ.¨qÐ1ØŸ?™?¨1Ñ-°Ó3Ø $§¡°Ð 2à  D§O¡OÓ3Ø+/¯?©?¸1Ñ+=ò != CØ(,¯©¸Ñ(<ð!=à$(§O¡O°AÒ$6ñ17ð4  ˆD�I‰I�dŠOùò As   ÄF4c                 ód   — |j                  «       D ]  \  }}|dkD  sŒ| j                  ||«       Œ y)z«Union with the given defs dictionary. This is meant to handle
        branch join-point, where a variable may have been defined in more
        than one branches.
        r   N)r  r)  )rŸ   rá   r&  r"  r×   s        rX   Ú
union_defszShapeEquivSet.union_defsÛ  s2   € ð
 —J‘J“Lò 	*‰DˆAˆqØ�1‹uØ—‘˜A˜yÕ)ñ	*rZ   )NNNNr   N)rÙ   rÚ   rÛ   rÜ   r    r   r¨   r«   rî   rÇ   rÊ   r  rÎ   rÂ   rÐ   r  r  r  r  rØ   r)  r+  Ú__classcell__©rå   s   @rX   rÞ   rÞ   h  s|   ø„ ñð ØØØØØõMò8/ò

ò
ò
)ôVô*Dò	+ôBô2ô87òr0ò
,òò$ô,ò.: öx*rZ   rÞ   c                   ó~   ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zd„ Zd„ Zd„ Zdˆ fd„	Z	dˆ fd„	Z
ˆ fd	„Zd
„ Zˆ fd„Zˆ xZS )ÚSymbolicEquivSeta/  Just like ShapeEquivSet, except that it also reasons about variable
    equivalence symbolically by using their arithmetic definitions.
    The goal is to automatically derive the equivalence of array ranges
    (slicing). For instance, a[1:m] and a[0:m-1] shall be considered
    size-equivalence.
    c
                 ó”   •— |r|ni | _         |r|ni | _        |r|ni | _        i | _        i | _        t
        t        | �  ||||||	«       y)zØCreate a new SymbolicEquivSet object, where typemap is a dictionary
        that maps variable names to their types, and it will not be modified.
        Optional keyword arguments are for internal use only.
        N)Údef_byÚref_byÚ
ext_shapesÚrel_mapÚwrap_maprä   r/  r    )rŸ   rà   r1  r2  r3  rá   râ   rœ   r�   r¥   rå   s             €rX   r    zSymbolicEquivSet.__init__î  sY   ø€ ñ& !'‘f¨BˆŒñ
 !'‘f¨BˆŒñ )3™*¸ˆŒð
 ˆŒð ˆŒÜÔ Ñ.Ø�T˜: z°:¸wõ	
rZ   c                 ó,   — t        | j                  «      S )z*Return an empty SymbolicEquivSet.
        )r/  rà   r¢   s    rX   r   zSymbolicEquivSet.empty  s   € ô   §¡Ó-Ð-rZ   c                 ó�   — dj                  | j                  | j                  | j                  | j                  | j
                  «      S )NzHSymbolicEquivSet({}, ind_to_var={}, def_by={}, ref_by={}, ext_shapes={}))rª   r�   râ   r1  r2  r3  r¢   s    rX   r«   zSymbolicEquivSet.__repr__   s9   € ð(ß(.©Ø—‘Ø—‘Ø—‘Ø—‘Ø—‘ó)ð		
rZ   c                 óè  — t        | j                  t        j                  | j                  «      t        j                  | j                  «      t        j                  | j
                  «      t        j                  | j                  «      t        j                  | j                  «      t        j                  | j                  «      t        j                  | j                  «      | j                  ¬«	      S )r¤   )r1  r2  r3  rá   râ   rœ   r�   r¥   )r/  rà   r¦   r1  r2  r3  rá   râ   r§   rœ   r�   rž   r¢   s    rX   r¨   zSymbolicEquivSet.clone,  s�   € ô  Ø�L‰LÜ—9‘9˜TŸ[™[Ó)Ü—9‘9˜TŸ[™[Ó)Ü—y‘y §¡Ó1Ü—‘˜4Ÿ9™9Ó%Ü—y‘y §¡Ó1Ü—}‘} T§_¡_Ó5Ü—}‘} T§_¡_Ó5Ø—M‘Mô

ð 
	
rZ   c                 ó.   — t        | j                  |«      S )zjRetrieve a definition pair for the given variable,
        or return None if it is not available.
        )r   Ú_get_or_set_relr  s     rX   Úget_relzSymbolicEquivSet.get_rel;  s   € ô �T×)Ñ)¨4Ó0Ð0rZ   c                 óà  •‡ ‡‡— t        |t        j                  «      r|j                  }t	        ‰ j
                  j                  |d«      dk(  «       |‰ j                  v r‰ j                  |   S t	        |du«       d„ Šˆˆfd„Št        ||«      }|df}t        |t        j                  «      �rO|j                  dk(  r¦t        ||‰ j                  ¬«      \  }}|dk(  �r_|d	k(  �rYt        ˆ fd
„|j                  D «       «      }d|v ry‰ j                  j                  |g «      }|j!                  |«       t#        |«      dkD  r‰ j%                  |«       |‰ j                  |<   nÚ|j                  dk(  rË‰ j'                  |j(                  |«      }	‰ j'                  |j*                  |«      }
|	�|
€y|j,                  t.        j0                  k(  r
 ‰|	|
«      }ng|j,                  t.        j2                  k(  rJ ‰|	|
«      }n@t        |t        j4                  «      r&t        |j6                  t8        «      r|j6                  }t	        |du«       |‰ j                  |<   t        |t8        «      s t        |t        «      rì|d   |k7  s|d   dk7  rÜt        |t        «      rÌ|\  }}|‰ j:                  vrg ‰ j:                  |<   ‰ j:                  |   j!                  || f«       ‰ j=                  |«      }|dk\  rs‰ j>                  |   }g }|D ]<  }|‰ j:                  v sŒ|‰ j:                  |   D ��cg c]  \  }}|| k(  r|‘Œ c}}z  }Œ> t#        |«      dkD  rt@        tB        ‰ �K  |«       |S c c}}w )z·Retrieve a definition pair for the given variable,
        and if it is not already available, try to look it up
        in the given func_ir, and remember it for future use.
        r   r:   Nc                 óŠ   — t        | t        «      }t        |t        «      }|r|r| |z   S |\  }}|| |z   fS | \  }}|r|||z   fS y rh   ©r[   rÉ   )r°   ÚyÚ
x_is_constÚ
y_is_constr  Úoffsets         rX   Úplusz.SymbolicEquivSet._get_or_set_rel.<locals>.plusN  s_   € Ü'¨¬3Ó/�
Ü'¨¬3Ó/�
ÙÙ!Ø  1™u˜à()™˜˜fØ # Q¨¡ZÐ0Ð0à$%‘M�S˜&Ù!Ø # Q¨¡ZÐ0Ð0à#rZ   c                 ó®   •— t        |t        «      r
 ‰| | «      S t        | t        «      r*t        |t        «      r| d   |d   k(  r ‰| d   |d   «      S y ©Nr   r:   )r[   rÉ   r¹   )r°   r?  ÚminusrC  s     €€rX   rF  z/SymbolicEquivSet._get_or_set_rel.<locals>.minus^  sV   ø€ Ü˜a¤Ô%Ù  A 2›;Ð&ä˜q¤%Ô(Ü" 1¤eÔ,Ø˜!™  !¡šá   1¡ q¨¡tÓ,Ð,àrZ   Úcall©rà   ra   znumba.parfors.array_analysisc              3   ój   •K  — | ]*  }‰j                   j                  |j                  d «      –— Œ, y­w)r   N)rœ   r¯   rì   r¶   s     €rX   rn   z3SymbolicEquivSet._get_or_set_rel.<locals>.<genexpr>u  s+   øè ø€ ò &Ø@A˜DŸO™O×/Ñ/°·±¸×;ñ&ùs   ƒ03r   Úbinop)"r[   r   rò   rì   r   rá   r¯   r1  r   ÚExprÚopr   rà   r¹   rI   r3  r½   rx   rÂ   r:  ÚlhsÚrhsÚfnÚoperatorrE   Úsubrõ   rö   rÉ   r2  r±   r�   rä   r/  )rŸ   rì   Úfunc_irÚexprrö   ÚfnameÚmod_namer%  rï   rM  rN  r  rB  rÀ   r¾   rÁ   r°   r�   rF  rC  rå   s   `                 @@€rX   r:  z SymbolicEquivSet._get_or_set_relA  s  û€ ô
 �dœBŸF™FÔ#Ø—9‘9ˆDÜ�—	‘	—‘˜d AÓ&¨!Ñ+Ô,Ø�4—;‘;ÑØ—;‘;˜tÑ$Ð$ä�G 4Ð'Ô(ò$õ 
 ô " '¨4Ó0ˆDØ˜1�IˆEÜ˜$¤§¡Õ(Ø—7‘7˜fÒ$Ü&3Ø ¨t¯|©|ô'‘O�E˜8ð  Ó-Ø$Ð(FÓFä %ó &ØEIÇYÁYô&ó !˜ð  ™;Ø#'Ø $§¡× 3Ñ 3°E¸2Ó >˜ØŸ™ TÔ*Ü˜u›:¨š>Ø ŸL™L¨Ô/Ø16˜Ÿ™¨Ò.Ø—W‘W Ò'Ø×.Ñ.¨t¯x©x¸ÓA�CØ×.Ñ.¨t¯x©x¸ÓA�Cð �{ c kØ#ØŸ™¤H§L¡LÒ0Ù $ S¨#£™ØŸ™¤H§L¡LÒ0Ù % c¨3£™Ü˜D¤"§(¡(Ô+´
¸4¿:¹:ÄsÔ0KØŸ
™
�Ü�E Ð%Ô&à %ˆD�K‰K˜ÑÜ˜%¤Ô%Ü˜5¤%Ô(Ø˜1‘X Ò%¨¨q©°Qªô ˜e¤UÔ+Ø$)‘M�S˜&Ø 4§;¡;Ñ.Ø+-˜Ÿ™ CÑ(Ø—K‘K Ñ$×+Ñ+¨T°F°7¨OÔ<àŸ-™-¨Ó,�CØ˜a’xØ#Ÿ™¨sÑ3˜Ø "˜Ø#'ò "˜CØ" d§k¡kÒ1Ø %à26·+±+¸cÑ2B÷*"á(.¨¨AØ'(¨V¨G¢|ò %&ó*"ñ !"¡ð"ô ˜u›:¨š>Ü!Ô"2°DÑAÀ%ÔHØˆLùó*"s   Ì-M*
c                 óœ  •— t        |t        j                  «      r|j                  }n|}t        t
        | �  ||«       |�r| j                  j                  |d«      dk(  rët        |t        j                  «      rÐt        | j                  ||«      }t        |t        «      r| j                  ||g«       t        |t        j                  «      r{| j                  |«      }|| j                   vr|g| j                   |<   || j"                  |<   || j$                  v r| j$                  |   j'                  |«       y|g| j$                  |<   yyyy)af  Besides incrementing the definition count of the given variable
        name, it will also retrieve and simplify its definition from func_ir,
        and remember the result for later equivalence comparison. Supported
        operations are:
          1. arithmetic plus and minus with constants
          2. wrap_index (relative to some given size)
        r   r:   TN)r[   r   rò   rì   rä   r/  r)  rá   r¯   r   ÚNumberr   r:  rÉ   rÂ   r³   r�   rœ   râ   r½   )	rŸ   r  r&  rR  rø   rì   rö   rÀ   rå   s	           €rX   r)  zSymbolicEquivSet.define®  s  ø€ ô �cœ2Ÿ6™6Ô"Ø—8‘8‰DàˆDÜÔ Ñ,¨T°9Ô=âØ—	‘	—‘˜d AÓ&¨!Ò+Ü˜3¤§¡Ô-ä˜$×.Ñ.°°gÓ>ˆEä˜%¤Ô%Ø—‘˜d E˜]Ô+Ü˜#œrŸv™vÔ&Ø×*Ñ*¨4Ó0�Ø˜tŸ™Ñ.Ø,0¨6�D—O‘O CÑ(Ø,/�D—O‘O DÑ)Ø˜$Ÿ/™/Ñ)Ø—O‘O CÑ(×/Ñ/°Ô4ð ð -0¨5�D—O‘O CÑ(Øð .ð ,ð rZ   c                 ón  •— t        «       }t        «       }|D ]Q  }| j                  |«      }|dk(  r|j                  |«       Œ+||vsŒ0|j                  |«       |j                  |«       ŒS t        |«      dk  ryt	        |«      }t
        t        | �  |«       | j                  | j                  |d   «         }i }d„ }|D ]Ì  }|| j                  v r~| j                  |   }t        |t        «      r_|\  }	}
 |||
 «      j                  |	«       |	| j                  v r3| j                  |	   D ]!  \  }} |||
|z    «      j                  |«       Œ# || j                  v sŒž| j                  |   D ]  \  }	}
 |||
«      j                  |	«       Œ ŒÎ |j                  «       D ]  }| j                  |«       Œ y)z�Overload _insert method to handle ind changes between relative
        objects.  Returns True if some change is made, false otherwise.
        r   r:   Fr   c                 ó*   — || v r| |   }|S g }|| |<   |S rh   rd   )Údr"  r×   s      rX   Ú
get_or_setz,SymbolicEquivSet._insert.<locals>.get_or_setå  s.   € Ø�A‰vØ�a‘D�ð ˆHð �Ø��!‘ØˆHrZ   T)rÍ   r±   rE   rx   r  rä   r/  rÂ   r�   r1  r[   r¹   r½   r2  rÔ   )rŸ   r¾   ÚindsetÚuniqsrÁ   rÀ   Úoffset_dictr[  rö   rì   rB  r×   r�   rï   rå   s                 €rX   rÂ   zSymbolicEquivSet._insertÏ  s³  ø€ ô “ˆÜ“ˆØò 	 ˆCØ—-‘- Ó$ˆCØ�bŠyØ—	‘	˜#•Ø˜V’mØ—	‘	˜#”Ø—
‘
˜3•ð	 ô ˆu‹:˜Š?ØÜ�U“ˆÜÔ Ñ-¨eÔ4Ø�‰˜tŸ}™}¨U°1©XÓ6Ñ7ˆð ˆò	ð ò 	AˆCØ�d—k‘kÑ!ØŸ™ CÑ(�Ü˜e¤UÔ+Ø%*‘N�T˜6Ù˜{¨V¨GÓ4×;Ñ;¸DÔAØ˜tŸ{™{Ñ*Ø&*§k¡k°$Ñ&7ò M™F˜Q Ù& {°f¸q±j°MÓB×IÑIÈ!ÕLðMà�d—k‘kÒ!Ø&*§k¡k°#Ñ&6ò A‘N�T˜6Ù˜{¨FÓ3×:Ñ:¸4Õ@ñAð	Að !×'Ñ'Ó)ò 	 ˆEØ�L‰L˜Õð	 àrZ   c                 óz   — t        |t        j                  t        j                  f«      sJ ‚|| j                  |<   y)z-remember shapes of SetItem IR nodes.
        N)r[   r   ÚStaticSetItemÚSetItemr3  )rŸ   rÁ   rs   s      rX   Úset_shape_setitemz"SymbolicEquivSet.set_shape_setitemý  s1   € ô ˜#¤× 0Ñ 0´"·*±*Ð=Ô>Ð>Ð>Ø$ˆ�‰˜ÒrZ   c                 ón  •— t        |t        j                  t        j                  f«      r&t	        || j
                  v «       | j
                  |   S t        |t        j                  «      sJ ‚| j                  |j                     }t        |t        j                  «      r|fS t        t        | �7  |«      S )zGOverload _get_shape to retrieve the shape of SetItem IR nodes.
        )r[   r   r`  ra  r   r3  rò   rà   rì   r   rk   rä   r/  r  )rŸ   rÁ   rø   rå   s      €rX   r  zSymbolicEquivSet._get_shape  sŒ   ø€ ô �cœB×,Ñ,¬b¯j©jÐ9Ô:Ü�C˜4Ÿ?™?Ð*Ô+Ø—?‘? 3Ñ'Ð'ä˜c¤2§6¡6Ô*Ð*Ð*Ø—,‘,˜sŸx™xÑ(ˆCä˜#œuŸ™Ô/Ø�v�äÔ-¨tÑ?ÀÓDÐDrZ   )NNNNNNNr   rh   ©NN)rÙ   rÚ   rÛ   rÜ   r    r   r«   r¨   r;  r:  r)  rÂ   rb  r  r,  r-  s   @rX   r/  r/  å  s`   ø„ ñð ØØØØØØØõ+
òZ.ò


ò
ò1õkõZôB,ò\%÷Eð ErZ   r/  c                   ó   — e Zd ZdZd„ Zy)ÚWrapIndexMetaa  
      Array analysis should be able to analyze all the function
      calls that it adds to the IR.  That way, array analysis can
      be run as often as needed and you should get the same
      equivalencies.  One modification to the IR that array analysis
      makes is the insertion of wrap_index calls.  Thus, repeated
      array analysis passes should be able to analyze these wrap_index
      calls.  The difficulty of these calls is that the equivalence
      class of the left-hand side of the assignment is not present in
      the arguments to wrap_index in the right-hand side.  Instead,
      the equivalence class of the wrap_index output is a combination
      of the wrap_index args.  The important thing to
      note is that if the equivalence classes of the slice size
      and the dimension's size are the same for two wrap index
      calls then we can be assured of the answer being the same.
      So, we maintain the wrap_map dict that maps from a tuple
      of equivalence class ids for the slice and dimension size
      to some new equivalence class id for the output size.
      However, when we are analyzing the first such wrap_index
      call we don't have a variable there to associate to the
      size since we're in the process of analyzing the instruction
      that creates that mapping.  So, instead we return an object
      of this special class and analyze_inst will establish the
      connection between a tuple of the parts of this object
      below and the left-hand side variable.
    c                 ó    — || _         || _        y rh   )Ú
slice_sizeÚdim_size)rŸ   rh  ri  s      rX   r    zWrapIndexMeta.__init__/  s   € Ø$ˆŒØ ˆ�rZ   N)rÙ   rÚ   rÛ   rÜ   r    rd   rZ   rX   rf  rf    s   „ ñó6!rZ   rf  c                   ó`  — e Zd ZdZ	 d„ Zd„ Zd„ Zdbd„Zd„ Zd„ Z	d	„ Z
d
„ Zd„ Z G d„ de«      Zd„ Zd„ Zd„ Zd„ Zd„ Z	 dcd„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/d/„ Z0d0„ Z1d1„ Z2d2„ Z3d3„ Z4d4„ Z5d5„ Z6d6„ Z7d7„ Z8d8„ Z9d9„ Z:d:„ Z;d;„ Z<d<„ Z=d=„ Z>d>„ Z?d?„ Z@d@„ ZAdA„ ZBdB„ ZCdC„ ZDdD„ ZEdE„ ZFdF„ ZGdG„ ZHdH„ ZIdI„ ZJdJ„ ZKdK„ ZLdL„ ZMdM„ ZNdN„ ZOdO„ ZPdP„ ZQdQ„ ZRdR„ ZSdS„ ZTdT„ ZUdU„ ZVdV„ ZWdW„ ZXdX„ ZYdY„ ZZdZ„ Z[d[„ Z\ddd\„Z]ddd]„Z^d^„ Z_d_„ Z`d`„ Zada„ Zby)eÚArrayAnalysisr   c                 ó‚   — || _         || _        || _        || _        i | _        i | _        i | _        i | _        i | _        y rh   )	rF   rR  rà   Ú	calltypesÚ
equiv_setsÚarray_attr_callsÚobject_attrsÚprependsÚpruned_predecessors)rŸ   rF   rR  rà   rm  s        rX   r    zArrayAnalysis.__init__>  sF   € ØˆŒØˆŒØˆŒØ"ˆŒð ˆŒà "ˆÔàˆÔàˆŒà#%ˆÕ rZ   c                 ó    — | j                   |   S )zAReturn the equiv_set object of an block given its label.
        )rn  )rŸ   Úblock_labels     rX   rÎ   zArrayAnalysis.get_equiv_setO  s   € ð �‰˜{Ñ+Ð+rZ   c                 óŠ   — t        «       }|D ]4  }| j                  D ]#  }| j                  |   }|j                  ||«       Œ% Œ6 y)zõTake a set of variables in redefineds and go through all
        the currently existing equivalence sets (created in topo order)
        and remove that variable from all of them since it is multiply
        defined within the function.
        N)rÍ   rn  r)  )rŸ   Ú
redefinedsÚunusedr‘   ÚeslabelÚess         rX   Úremove_redefinedszArrayAnalysis.remove_redefinedsT  sI   € ô “ˆØò 	%ˆAØŸ?™?ò %�Ø—_‘_ WÑ-�Ø—	‘	˜!˜VÕ$ñ%ñ	%rZ   Nc                 óF  — |€| j                   j                  }t        | j                   j                  «      | j                   _        |€t	        | j
                  «      }n|}t        || j                   j                  | j
                  | j                   «      \  | _        | _	        t        j                  }t        xj                  dz  c_        t        j                  dk\  rt        d|«       t        | j                   d|«       t        j                  dk\  rCt        dt!        | j
                  j#                  «       «      «       t        d| j$                  «       t'        |«      }t)        ||¬«      }| j+                  ||||«       t        j                  dk\  rS| j-                  «        t        dt!        | j
                  j#                  «       «      «       t        d	| j$                  «       t        | j                   d
|«       t        j                  dk\  rt        d|«       yy)z�run array shape analysis on the given IR blocks, resulting in
        modified IR and finalized EquivSet for each block.
        Nr:   zStarting ArrayAnalysis:zbefore array analysiszArrayAnalysis variable types: zArrayAnalysis call types: )Úcfgz#ArrayAnalysis post variable types: zArrayAnalysis post call types: zafter array analysiszEnding ArrayAnalysis:)rR  Úblocksr   Ú_definitionsr/  rà   r   Ú	arg_namesÚ	alias_mapÚarg_aliasesrk  Úaa_countr   r»   r¼   r
   r  r  rm  r   r	   Ú_run_on_blocksÚdump)rŸ   r}  rÕ   Úinit_equiv_setÚaa_count_saver|  Ú
topo_orders          rX   ÚrunzArrayAnalysis.run`  s¥  € ð ˆ>Ø—\‘\×(Ñ(ˆFä$5°d·l±l×6IÑ6IÓ$Jˆ�‰Ô!àÐÜ-¨d¯l©lÓ;‰Nà&ˆNä+AØØ�L‰L×"Ñ"Ø�L‰LØ�L‰Ló	,
Ñ(ˆŒ˜Ô(ô &×.Ñ.ˆÜ×Ò !Ñ#ÕÜ×!Ñ! QÒ&ÜÐ+¨]Ô;Ü�t—|‘|Ð%<¸fÔEä×!Ñ! QÒ&ÜØ0´&¸¿¹×9KÑ9KÓ9MÓ2Nôô Ð.°·±Ô?ä% fÓ-ˆÜ$ V°Ô5ˆ
à×Ñ˜J¨°°^ÔDä×!Ñ! QÒ&Ø�I‰IŒKÜØ5Ü�t—|‘|×)Ñ)Ó+Ó,ôô Ð3°T·^±^ÔDä�t—|‘|Ð%;¸VÔDÜ×!Ñ! QÒ&ÜÐ)¨=Õ9ð 'rZ   c                 óÀ   — |D ]Y  }t         j                  dk\  rt        d|«       ||   }|j                  }| j	                  |||||«      }| j                  ||«       Œ[ y )Nr¸   zProcessing block:)r   r»   r¼   ÚscopeÚ_determine_transformÚ_combine_to_new_block)	rŸ   r‡  r}  r|  r…  ÚlabelÚblockrŠ  Úpending_transformss	            rX   rƒ  zArrayAnalysis._run_on_blocks’  sm   € Øò 	BˆEÜ×%Ñ%¨Ò*ÜÐ)¨5Ô1Ø˜5‘MˆEØ—K‘KˆEØ!%×!:Ñ!:Ø�U˜E 5¨.ó"Ðð ×&Ñ& uÐ.@ÕAñ	BrZ   c                 ó®   — g }|D ]G  \  }}}|D ]  }|j                  |«       Œ |j                  |«       |D ]  }|j                  |«       Œ ŒI ||_        y)zWCombine the new instructions from previous pass into a new block
        body.
        N)r½   Úbody)rŸ   rŽ  r�  Únew_bodyÚinstÚpreÚpostÚinstrs           rX   rŒ  z#ArrayAnalysis._combine_to_new_block�  si   € ð ˆØ1ò 	'‰OˆD�#�tØò '�Ø—‘ Õ&ð'à�O‰O˜DÔ!Øò '�Ø—‘ Õ&ñ'ð		'ð ˆ�
rZ   c           	      óâ  — d}|j                  |«      }|| j                  v r| j                  |   }ng }t        j                  dk\  rt	        d|«       |D �]  \  }	}
t        j                  dk\  rt	        d|	|
«       |	|v rŒ,|	| j
                  v sŒ;| j
                  |	   j                  «       }t        j                  dk\  rt	        d|«       |	|f| j                  v rH| j                  |	|f   }|D ]2  }t        «       }| j                  |||||«       | j                  |«       Œ4 |€|}ŒÔ|j                  |«      }t        «       }|j                  |j                  |«       | j                  |«       �Œ |€|}|| j
                  |<   g }|j                  D ]W  }t        «       }| j                  |||||«      \  }}t        |«      dkD  r| j                  |«       |j!                  |||f«       ŒY |S )zGDetermine the transformation for each instruction in the block
        Nr¸   zpreds:zp, q:zp in equiv_setsr   )Úpredecessorsrr  r   r»   r¼   rn  r¨   rq  rÍ   Ú_analyze_instrz  rØ   r+  rá   r‘  rx   r½   )rŸ   r|  rŽ  r�  rŠ  r…  rÕ   ÚpredsÚprunedÚpÚqÚfrom_setÚinstrsr“  r&  r�  r”  r•  s                     rX   r‹  z"ArrayAnalysis._determine_transformª  s  € ð ˆ	à× Ñ  Ó'ˆà�D×,Ñ,Ñ,Ø×-Ñ-¨eÑ4‰FàˆFô ×!Ñ! QÒ&Ü�(˜EÔ"Øó 	6‰FˆQ�Ü×%Ñ%¨Ò*Ü�g˜q !Ô$Ø�F‰{ØØ�D—O‘OÒ#ØŸ?™?¨1Ñ-×3Ñ3Ó5�Ü×)Ñ)¨QÒ.ÜÐ+¨XÔ6Ø�u�: §¡Ñ.Ø!Ÿ]™]¨A¨u¨:Ñ6�FØ &ò :˜Ü$'£E˜	Ø×*Ñ*Ø! 5¨(°D¸)ôð ×.Ñ.¨yÕ9ð:ð Ð$Ø (‘Ià )× 3Ñ 3°HÓ =�IÜ #£�IØ×(Ñ(¨¯©¸	ÔBð ×*Ñ*¨9Ö5ð;	6ð@ ÐØ&ˆIØ!*ˆ�‰˜Ñð  ÐØ—J‘Jò 
	9ˆDÜ›ˆIØ×*Ñ*Ø�u˜i¨¨yó‰IˆC�ô
 �9‹~ Ò!Ø×&Ñ& yÔ1à×%Ñ% t¨S°$Ð&7Õ8ð
	9ð "Ð!rZ   c                 ó0   — t        d| j                  «       y)z@dump per-block equivalence sets for debugging purposes.
        zArray Analysis: N)r¼   rn  r¢   s    rX   r„  zArrayAnalysis.dumpî  s   € ô 	Ð  $§/¡/Õ2rZ   c                 óÎ   — || j                   |j                  <   |g| j                  j                  |j                  <   t	        «       }|j                  ||| j                  |«       y rh   )rà   rì   rR  r~  rÍ   r)  )rŸ   rÕ   r  rø   rö   rv  s         rX   Ú_definezArrayAnalysis._defineó  sM   € Ø!$ˆ�‰�S—X‘XÑØ/4¨gˆ�‰×!Ñ! #§(¡(Ñ+Ü“Uˆ
Ø×Ñ˜˜j¨$¯,©,¸Õ<rZ   c                   ó   — e Zd Zd„ Zy)úArrayAnalysis.AnalyzeResultc                 ó   — || _         y rh   )Úkwargs)rŸ   r¦  s     rX   r    z$ArrayAnalysis.AnalyzeResult.__init__ú  s	   € Ø ˆD�KrZ   N)rÙ   rÚ   rÛ   r    rd   rZ   rX   ÚAnalyzeResultr¤  ù  s   „ ó	!rZ   r§  c           
      óx  ‡ ‡‡‡‡‡&‡'— g }g }t         j                  dk\  rt        d‰«       t        ‰t        j
                  «      �r@‰j                  }‰ j                  |j                     }	d }
t        |	t        j                  «      r|	j                  dk(  rd}
�n¬t        ‰j                  t        j                  «      rÞ‰ j                  ‰‰‰j                  |«      }|�rgt        t        |t         j"                  «      «       d|j$                  v r|j$                  d   }
d|j$                  v r|j'                  |j$                  d   «       d|j$                  v r|j'                  |j$                  d   «       d|j$                  v �rÀ|j$                  d   ‰_        �nªt        ‰j                  t        j(                  t        j*                  f«      r‰j                  }
�nht        ‰j                  t        j,                  «      rP‰j                  j                  }t        |t.        «      rt1        d	„ |D «       «      r|}
�nt        |t2        «      rø|f}
nôt        ‰j                  t        j4                  «      rÐt        |	t        j6                  j8                  «      r1t        |	j:                  t        j<                  «      r‰j                  }
n{t        |	t        j6                  j>                  «      rWt1        |	j                  D �cg c],  }t        |t        j<                  t        j@                  f«      ‘Œ. c}«      r‰j                  }
t        |
t        j*                  «      rft        |
j                  t.        «      r+|
jB                  Š't/        ˆ'fd
„|
j                  D «       «      }
nèt        |
j                  t2        «      r|
f}
nÊd }
nÇt        |
t        j(                  «      r5t        ‰ j                  |
j                     t        j<                  «      r|
f}
nxt        |
tD        «      rh	 ‰jG                  ||‰ jH                  |	«       ‰jK                  |j                  «      }|dk7  r%|‰jL                  |
jN                  |
jP                  f<   ||fS t        |	t        j                  «      r¸|
�Wt        |
t        j(                  «      r=t        ‰ j                  |
j                     t        j6                  jR                  «      r�nK|
�=t        |
t.        «      s-t        |
t        j(                  «      �r‰jU                  |
«      �s‰ jW                  ‰||	j                  |
|«      }
nìt        |	t        j8                  «      rE|
rÐt        |	j:                  t        j<                  «      r¬‰ jW                  ‰|tY        |	«      |
|«      }
n�t        |	t        j6                  j>                  «      rit1        |	j                  D �cg c],  }t        |t        j<                  t        j@                  f«      ‘Œ. c}«      r‰ jW                  ‰|tY        |	«      |
|«      }
	 d}|
�‰j[                  ||
«      }|r‰jG                  ||‰ jH                  |	«       ||fS t        ‰t        j\                  t        j^                  f«      �rt        ‰t        j^                  «      r‰j`                  n‰jb                  }te        ‰ jf                  ‰‰‰j                  |«      }|sg g fS |d   �6t        ‰t        j\                  t        j^                  f«      sJ ‚|d   ‰_0        |d   }|j$                  d   }d|j$                  v r|j$                  d   }‰ji                  ‰j                  «      }|dk(  r‰jk                  ‰|«       |g fS |��‰ j                  ‰j                  j                     }t        t        |t        j                  «      «       |j                  }||g}‰j                  j                  ‰j                  j                  g}‰ jm                  ‰‰‰jB                  ||«      }t        d|j$                  v «       t        d|j$                  v «       |j$                  d   }
|j$                  d   }tY        |
«      }||k\  sJ ‚‰jk                  ‰|
«       ||z   g fS |g fS t        ‰t        jn                  «      �rˆ&ˆˆˆˆˆ fd„}‰jp                  Š&te        tr        ‰ jH                  ‰&«      }|�s#‰ju                  ‰&«      }g }|D ]‰  }t        |tv        «      rf|‰ j                  v rXte        tr        ‰ jH                  |d¬«      }t        |t        j(                  «      r|j                  }|sŒg|jy                  |«       Œy|jy                  |«       Œ‹ t{        t}        d„ |«      «      } t{        |«      j                  | «      }!tY        |!«      dk(  rt�        |!«      d   }n5tY        | «      dk(  r'te        tr        ‰ jH                  t�        | «      d   «      }t        |t        j                  «      r|j‚                  dk(  r ||«       ||fS t        |t        j                  «      rÁ|j‚                  dk(  r²te        tr        ‰ jH                  |j„                  «      }"|"��*|"j                  t†        u �rtY        |jˆ                  «      dk(  rÿte        tr        ‰ jH                  |jˆ                  d   «      }#|#�Õt        |#t        j                  «      r»|#j‚                  dk(  r¬ ||#«       ||fS t        |t        j*                  «      r|j                  }t        |t2        «      st        |t†        «      rZ|r‰jŠ                  n‰jŒ                  }$|$‰ jŽ                  v r"‰ jŽ                  |$   jy                  ‰«       ||fS ‰g‰ jŽ                  |$<   ||fS t‘        ‰«      t’        v r*t’        t‘        ‰«         }% |%‰‰‰ j                  ‰ «      \  }}||fS c c}w c c}w )Nr¸   zanalyze_inst:r   rd   rs   r”  r•  rN  c              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wrh   r>  )rl   r×   s     rX   rn   z.ArrayAnalysis._analyze_inst.<locals>.<genexpr>  s   è ø€ ÒC°q¤
¨1¬c× 2ÑCùs   ‚c              3   óJ   •K  — | ]  }t        j                  |‰«      –— Œ y ­wrh   )r   rõ   )rl   r°   Úlocs     €rX   rn   z.ArrayAnalysis._analyze_inst.<locals>.<genexpr>2  s   øè ø€ Ò!H°q¤"§(¡(¨1¨c×"2Ñ!Hùs   ƒ #r   Tr:   c                 óÒ  •— d }| j                   t        j                  k(  r‰j                  }‰j                  }d}n7| j                   t        j
                  k(  r‰j                  }‰j                  }d}‰j                  | j                  j                     }‰j                  | j                  j                     }|��,t        |t        j                  «      rt        |t        j                  «      s4t        |t        j                  «      rÝt        |t        j                  «      rÂ‰j                  }| j                  | j                  f}‰j                  ‰|‰
|«      }|j!                  t#        j$                  t#        j&                  |«      ‰	|«      «       |‰j(                  ‰|f<   t#        j$                  t#        j&                  d|z
  |«      ‰	|«      g‰j(                  ‰f<   y y y y )Nr:   r   )rO  rP  ÚeqÚtruebrÚfalsebrÚnerà   rM  rì   rN  r[   r   r]   rj   r«  Ú_make_assert_equivr½   r   ÚAssignrõ   rq  )Úcond_defÚbrÚotherbrÚcond_valÚlhs_typÚrhs_typr«  rI   ÚassertsÚcond_varrÕ   r“  r�  rŠ  rŸ   s            €€€€€€rX   Úhandle_call_binopz6ArrayAnalysis._analyze_inst.<locals>.handle_call_binop¬  s|  ø€ Ø�Ø—;‘;¤(§+¡+Ò-ØŸ™�BØ"Ÿl™l�GØ ‘HØ—[‘[¤H§K¡KÒ/ØŸ™�BØ"Ÿk™k�GØ �HØŸ,™, x§|¡|×'8Ñ'8Ñ9�ØŸ,™, x§|¡|×'8Ñ'8Ñ9�Ø‘>ä" 7¬E¯M©MÔ:Ü& w´·±Ô>ô # 7¬E¯O©OÔ<Ü& w´·±Ô@ð Ÿ(™(�CØ$ŸL™L¨(¯,©,Ð7�DØ"×5Ñ5Ø˜s I¨tó�Gð —N‘NÜŸ	™	¤"§(¡(¨8°SÓ"9¸8ÀSÓIôð 29�D—M‘M 5¨" +Ñ.äŸ	™	¤"§(¡(¨1¨x©<¸Ó"=¸xÈÓMð7�D—M‘M 5¨'Ð"2Ò3ð Að =ð "rZ   )Úlhs_onlyc                 ó"   — t        | t        «      S rh   )r[   ró   )r°   s    rX   ú<lambda>z-ArrayAnalysis._analyze_inst.<locals>.<lambda>à  s   € ¬z¸!¼SÓ/A€ rZ   rJ  rG  )Jr   r»   r¼   r[   r   r²  Útargetrà   rì   r   ri   rô   rö   rK  Ú_analyze_exprr   rk  r§  r¦  Úextendrò   rõ   ÚGlobalr¹   r“   rÉ   ÚArgÚ
containersÚUniTupleÚdtyper]   ÚTupleÚIntegerLiteralr«  rf  r)  rR  r±   r5  rh  ri  rj   r  Ú_gen_shape_callrx   rÐ   r`  ra  r%  Ú	index_varr   Ú_index_to_shaper  rb  Ú_broadcast_assert_shapesÚBranchÚcondr   rÎ   ró   r½   rÍ   ÚfilterÚ
differencer  rL  ÚfuncÚboolrI   r¯  r®  rr  r÷   Úarray_analysis_extensions)(rŸ   r�  rŠ  rÕ   r“  r&  r”  r•  rM  rø   rs   ÚresultÚgvaluer°   Úlhs_indÚneeds_definer%  Útarget_shapeÚvalue_shapeÚ
target_typÚtarget_ndimÚshapesrï   Úbroadcast_resultr¹  r„   r»  r³  Úequivsrá   rì   Úvar_defÚdefvarsÚ	defconstsÚ	glbl_boolÚ	conditionÚ	pruned_brr2   rº  r«  s(   `````                                 @@rX   r™  zArrayAnalysis._analyze_instý  sÈ	  þ€ ØˆØˆÜ×!Ñ! QÒ&Ü�/ 4Ô(Ü�dœBŸI™IÕ&Ø—+‘+ˆCØ—,‘,˜sŸx™xÑ(ˆCØˆEÜ˜#œu×4Ñ4Ô5¸#¿(¹(Àaº-Ø’Ü˜DŸJ™J¬¯©Ô0Ø×+Ñ+¨E°9¸d¿j¹jÈ#ÓN�ÚÜœJ v¬}×/JÑ/JÓKÔLØ &§-¡-Ñ/Ø &§¡¨gÑ 6˜Ø §¡Ñ-ØŸ
™
 6§=¡=°Ñ#7Ô8Ø §¡Ñ.ØŸ™ F§M¡M°&Ñ$9Ô:Ø §¡Ò-Ø%+§]¡]°5Ñ%9˜ž
Ü˜DŸJ™J¬¯©´·±Ð(:Ô;ØŸ
™
’Ü˜DŸJ™J¬¯	©	Ô2ØŸ™×)Ñ)�ô ˜v¤uÔ-ÜÑC¸FÔCÔCØ"’EÜ ¬Ô,Ø#˜I‘EÜ˜DŸJ™J¬¯©Ô/ä˜s¤E×$4Ñ$4×$=Ñ$=Ô>Ü" 3§9¡9¬e¯m©mÔ<à ŸJ™J‘Eä˜s¤E×$4Ñ$4×$:Ñ$:Ô;Üà!$§¡ö,àô (¨Ü"Ÿ]™]¬E×,@Ñ,@ÐAõCò ,ô ð
 !ŸJ™J�Eä˜%¤§¡Ô*Ü˜eŸk™k¬5Ô1ØŸ)™)�CÜ!Ó!H¸E¿K¹KÔ!HÓH‘EÜ §¡¬SÔ1Ø"˜H‘Eà ‘EÜ˜E¤2§6¡6Ô*¬zØ—‘˜UŸZ™ZÑ(¬%¯-©-ô0ð ˜‘Ü˜E¤=Ô1ðð × Ñ   i°·±¸sÔCØ#×,Ñ,¨S¯X©XÓ6�Ø˜b’=ð  ð ×&Ñ&Ø×)Ñ)¨5¯>©>Ð:ñð ˜D�yÐ ä˜#œu×4Ñ4Ô5àÐ%Ü" 5¬"¯&©&Ô1Ü"ØŸ™ U§Z¡ZÑ0´%×2BÑ2B×2LÑ2Lôñ à�MÜ! %¬Ô/ä" 5¬"¯&©&Õ1Ø )× 3Ñ 3°EÕ :ð !×0Ñ0Ø! 3¨¯©°%¸ó‘Eô ˜C¤§¡Ô0ÙœZ¨¯	©	´5·=±=ÔAØ ×0Ñ0Ø! 3¬¨C«°%¸ó‘Eô ˜3¤× 0Ñ 0× 6Ñ 6Ô7Üà ŸY™Yö(àô $ AÜŸ™¬×(<Ñ(<Ð=õ?ò (ô ð
 ×,Ñ,Ø˜s¤C¨£H¨e°Tó�ðð  ˆLØÐ Ø(×5Ñ5°c¸5ÓA�ÙØ× Ñ   i°·±¸sÔCðH �DˆyÐôG ˜œr×/Ñ/´·±Ð<Õ=ä(¨¬r¯z©zÔ:�—
’
ÀÇÁð ô Ø×$Ñ$ e¨Y¸¿¹ÀUóˆFñ Ø˜2�v�Ø�a‰yÐ$Ü! $¬×)9Ñ)9¼2¿:¹:Ð(FÔGÐGÐGØ# A™Y�”
Ø˜A‘YˆFØ!Ÿ=™=¨Ñ1ˆLØ˜Ÿ™Ñ%Ø—m‘m EÑ*�Ø#×-Ñ-¨d¯j©jÓ9ˆKØ˜bÒ Ø×+Ñ+¨D°,Ô?Ø˜B�w�ØÑ(Ø!Ÿ\™\¨$¯+©+×*:Ñ*:Ñ;�
Üœ
 :¬u×/DÑ/DÓEÔFØ(Ÿo™o�Ø&¨Ð4�ØŸ™×)Ñ)¨4¯:©:¯?©?Ð;�Ø#'×#@Ñ#@Ø˜9 d§h¡h°¸ó$Ð ô ˜Ð#3×#:Ñ#:Ð:Ô;Ü˜Ð!1×!8Ñ!8Ð8Ô9Ø(×/Ñ/°Ñ8�Ø*×1Ñ1°%Ñ8�Ü˜“J�à" aÒ'Ð'Ð'Ø×+Ñ+¨D°%Ô8Ø˜W‘} bÐ(Ð(à˜B�w�Ü˜œbŸi™iÕ(÷!ñ !ðF —y‘yˆHÜœ^¨T¯\©\¸8ÓDˆHÚà"×0Ñ0°Ó:�Ø�Ø"ò 
*�DÜ! $¬Ô,°¸¿¹Ñ1EÜ"'Ü*¨D¯L©L¸$Èô#˜ô & g¬r¯v©vÔ6Ø&-§l¡l˜GÚ"Ø ŸK™K¨Õ0àŸ™ DÕ)ð
*ô œfÑ%AÀ4ÓHÓI�Ü ›I×0Ñ0°Ó9�	Ü�y“> QÒ&Ü# I›¨qÑ1‘HÜ˜“\ QÒ&Ü$Ü&¨¯©´d¸7³mÀAÑ6Fó �Hô ˜(¤B§G¡GÔ,°·±ÀÒ1GÙ! (Ô+ð8 �DˆyÐô7 ˜H¤b§g¡gÔ.°8·;±;À&Ò3Hä!¤.°$·,±,ÀÇÁÓN�	ØÑ(¨Y¯_©_ÄÒ-DÜ˜8Ÿ=™=Ó)¨QÒ.Ü$)¬.¸$¿,¹,Ø*2¯-©-¸Ñ*:ó%<˜	à%Ð1Ü& y´"·'±'Ô:Ø )§¡°Ò 7Ù-¨iÔ8ð" �DˆyÐô ˜h¬¯©Ô1Ø'Ÿ~™~�HÜ˜h¬Ô,´
¸8ÄTÔ0Já08 §¢¸d¿k¹k�IØ  D×$<Ñ$<Ñ<Ø×0Ñ0°Ñ;×BÑBÀ5ÔIð �DˆyÐð @E¸g˜×0Ñ0°Ñ;ð �DˆyÐô �$‹ZÔ4Ñ4ä)¬$¨t«*Ñ5ˆAÙ˜$ 	¨4¯<©<¸Ó>‰IˆC�à�DˆyÐùò{,ùò|(s   Ì1p2×51p7c                 óŽ   — dj                  |j                  «      }	 t        | |«      }t	        |||||«      S # t        $ r Y y w xY w)Nz_analyze_op_{})rª   rL  ÚgetattrÚAttributeErrorr   )rŸ   rŠ  rÕ   rS  rM  rT  rO  s          rX   rÀ  zArrayAnalysis._analyze_expr  sP   € Ø ×'Ñ'¨¯©Ó0ˆð	Ü˜˜uÓ%ˆBô �R˜ 	¨4°Ó5Ð5øô ò 	Ùð	ús   �8 ¸	AÁAc                 óÚ  — |j                   dk(  rO| j                  |j                  j                  «      r*| j	                  |||j
                  |j                  gi «      S |j                   dk(  r1|j                  |j                  «      }t        j                  |¬«      S |j                   dv rE| j                  |j                  j                  «      r t        j                  |j                  ¬«      S | j                  |j                  «      rßt        |j                  j                  | j                  «      }||j                   f| j                  v r/t        j                  | j                  ||j                   f   ¬«      S | j                  |j                     }g }| j                  |||j                  d |«      }|| j                  ||j                   f<   t        j                  ||¬«      S y )NÚTrs   ©rs   )ÚrealÚimag)rs   r•  )ÚattrÚ_isarrayrö   rì   Ú _analyze_op_call_numpy_transposer«  r  rk  r§  r   r€  rp  rà   rÉ  rô   )	rŸ   rŠ  rÕ   rS  rM  rs   Úcanonical_valuerø   r•  s	            rX   Ú_analyze_op_getattrz!ArrayAnalysis._analyze_op_getattr  sš  € à�9‰9˜Ò §¡¨d¯j©j¯o©oÔ >Ø×8Ñ8Ø�y $§(¡(¨T¯Z©Z¨L¸"óð ð �Y‰Y˜'Ò!Ø×'Ñ'¨¯
©
Ó3ˆEÜ ×.Ñ.°UÐ.Ó;Ð;Ø�Y‰YÐ*Ñ*¨t¯}©}¸T¿Z¹Z¿_¹_Ô/Mô !×.Ñ.°T·Z±ZÐ.Ó@Ð@Ø�]‰]˜3Ÿ8™8Ô$Ü1Ø—
‘
—‘ §¡óˆOð   §¡Ð+¨t×/@Ñ/@Ñ@Ü$×2Ñ2Ø×+Ñ+¨_¸d¿i¹iÐ,HÑIð 3ó ð ð —l‘l 3§8¡8Ñ,�Ø�Ø×,Ñ,Ø˜s C§H¡H¨d°Dó�ð CH�×!Ñ! ?°D·I±IÐ">Ñ?Ü$×2Ñ2¸ÀTÐ2ÓJÐJàrZ   c                 óB   — t         j                  |j                  ¬«      S ©Nrê  )rk  r§  rö   ©rŸ   rŠ  rÕ   rS  rM  s        rX   Ú_analyze_op_castzArrayAnalysis._analyze_op_cast/  s   € Ü×*Ñ*°·±Ð*Ó<Ð<rZ   c                 ó$  — |j                   }| j                  |j                     }t        |t        j
                  «      rQt        t        |«      |j                  k(  «       t        |j                  |«      «       t        j                  |¬«      S y ró  )rö   rà   rì   r[   r   rj   r   rx   Úcountr  rk  r§  )rŸ   rŠ  rÕ   rS  rM  r  rø   s          rX   Ú_analyze_op_exhaust_iterz&ArrayAnalysis._analyze_op_exhaust_iter2  sj   € Ø�j‰jˆØ�l‰l˜3Ÿ8™8Ñ$ˆÜ�cœ5Ÿ?™?Ô+Ü”C˜“H §
¡
Ñ*Ô+Ü�I×'Ñ'¨Ó,Ô-Ü ×.Ñ.°SÐ.Ó9Ð9ØrZ   c                 ó  — t        j                  |t        |«      |«      }t        j                  ||«      }t	        j
                  |«      }	|j                  t        j                  |||¬«      «       | j                  |||	|«       ||	fS )N©rö   r¿  r«  )	r   rò   r   rõ   r   rÈ  r½   r²  r¢  )
rŸ   Úarg_valr«  rŠ  ÚstmtsrÕ   rì   Ústatic_literal_slice_part_varÚstatic_literal_slice_part_valÚstatic_literal_slice_part_typs
             rX   Úgen_literal_slice_partz$ArrayAnalysis.gen_literal_slice_part;  s‡   € ô )+¯©¨u´mÀDÓ6IÈ3Ó(OÐ%Ü(*¯©°¸#Ó(>Ð%Ü(-×(<Ñ(<¸WÓ(EÐ%à�‰Ü�I‰IØ3Ø4Øôô	
ð 	�‰ØØ)Ø)Ø)ô		
ð -Ð.KÐKÐKrZ   c                 ó>   — | j                  ||z
  ||||d¬«      ^}}|S )NÚstatic_slice_size)rì   )r   )	rŸ   Úlhs_relÚrhs_relr«  rŠ  rü  rÕ   Úthe_varÚ_s	            rX   Úgen_static_slice_sizez#ArrayAnalysis.gen_static_slice_sizeX  s;   € ð ×1Ñ1Ø�gÑØØØØØ$ð 2ó 
ˆˆ�!ð ˆrZ   c
                 óš  — t        |t        «      rJ ‚t        j                  |t	        d«      |«      }
t        j
                  j                  t        j                  |||¬«      }t        j                  }t        |||«      | j                  |<   |j                  t        j                  ||
|¬«      «       | j                  |	|
||«       |
|fS )NÚexplicit_neg©r«  rú  )r[   rÉ   r   rò   r   rK  rJ  rP  rE   r   r^   r   rm  r½   r²  r¢  )rŸ   ÚargÚarg_relÚarg_typÚsize_typr«  rŠ  Údsizerü  rÕ   Úexplicit_neg_varÚexplicit_neg_valÚexplicit_neg_typs                rX   Úgen_explicit_negzArrayAnalysis.gen_explicit_nege  sº   € ô ˜h¬Ô,Ð,Ð,äŸ6™6 %¬°~Ó)FÈÓLÐÜŸ7™7Ÿ=™=¬¯©°u¸cÀs˜=ÓKÐô !Ÿ:™:ÐÜ+4Ø˜h¨ó,
ˆ�‰Ð'Ñ(ð 	�‰Ü�I‰IÐ,Ð5EÈ3ÔOô	
ð 	�‰ØÐ'Ð)9Ð;Kô	
ð  Ð!1Ð1Ð1rZ   c                 óî  — d}t        |t        «      �r[|dk(  rd}�nRt        |t        «      r­d}t        ||«      }||k7  �r.t        j                  dk\  rt        d«       d}| j                  |||	|
|«      \  }}|dk(  s|dk(  sJ ‚|dk(  r||j                  d   f|_        n|j                  d   |f|_        |j                  |   }|}|j                  |«      }n•|dk  r�d}t        j                  dk\  rt        d«       | j                  ||||||	||
|«	      \  }}|dk(  r||j                  d   f|_        n|j                  d   |f|_        |j                  |   }|}|j                  |«      }||||||fS )NFr   Tr¸   z.Replacing slice to hard-code known slice size.r:   z,Replacing slice due to known negative index.)
r[   rÉ   re   r   r»   r¼   r   rI   r;  r  )rŸ   rM  r·  r  Ú	dsize_relÚreplacement_sliceÚslice_indexÚneed_replacementr«  rŠ  rü  rÕ   r  r  ÚknownÚwilÚliteral_varÚliteral_typr  r  s                       rX   Úupdate_replacement_slicez&ArrayAnalysis.update_replacement_slice„  sß  € ð$ ˆÜ�gœsÕ#ð ˜!Š|à’Ü˜I¤sÔ+Ø�ä(¨°)Ó<�ð ˜'“>Ü×-Ñ-°Ò2ÜÐNÔOà'+Ð$Ø/3×/JÑ/JØ˜S %¨°	ó0Ñ,�K ð '¨!Ò+¨{¸aÒ/?Ð?Ð?Ø" aÒ'à'Ø-×2Ñ2°1Ñ5ð2Ð)Õ.ð .×2Ñ2°1Ñ5Ø'ð2Ð)Ô.ð
 ,×0Ñ0°Ñ=�CØ)�GØ'×/Ñ/°Ó4‘GØ˜1’à#'Ð Ü×)Ñ)¨QÒ.ÜÐHÔIØ59×5JÑ5JØØØØØØØØØó
6Ñ2Ð Ð"2ð  !Ò#à(Ø)×.Ñ.¨qÑ1ð.Ð%Õ*ð *×.Ñ.¨qÑ1Ø(ð.Ð%Ô*ð
 (×,Ñ,¨[Ñ9�Ø*�Ø#×+Ñ+¨CÓ0�àØØØØØð
ð 	
rZ   c                 ó¸  ‡ ‡‡‡‡-‡.‡/— |j                   Š-t        ‰ j                  |«      }t        ‰ j                  |‰ j                  ¬«      \  }}t        |dk(  xr |dv «       t        t        |j                  «      dk(  «       |j                  d   }	|j                  d   }
‰ j                  ‰j                     }‰ j                  |	j                     }‰ j                  |
j                     }t        j                  dk\  r#t        d|› d‰› d	|› d
|	› d|
› d|› d|› d|› �«       t        j                  |«      }d}t        |t        j                   «      rÑt#        j$                  ‰t'        d«      ‰-«      }t#        j(                  d‰-«      }|j+                  t#        j,                  ||‰-¬«      «       ‰ j/                  ‰|t        j0                  d«      |«       |}	t        j0                  d«      }|	|j                  d   f|_        d}t        j                  dk\  rt        d«       t        |t        j                   «      r:‰}
|}|j                  d   |
f|_        d}t        j                  dk\  rt        d«       ‰j3                  |	«      }‰j3                  |
«      }‰j3                  ‰«      }t        j                  dk\  rt        d|d|d|«       ‰ j5                  |	||||d|‰-‰|‰|‰«      \  }	}}}}}‰ j5                  |
||||d|‰-‰|‰|‰«      \  }
}}}}}t        j                  dk\  rt        d|«       t        d|«       |sd}nät#        j$                  ‰t'        d«      ‰-«      }t        j6                  t        j6                  f}‰ j                  |j8                  j                     j;                  ‰ j<                  |i «      }|‰ j>                  |<   |j+                  t#        j,                  ||‰-¬«      «       ‰ j                  |j                     ‰ j                  |j                  <   t        j                  dk\  rt        dd|d|«       |r8|r6t        j                  dk\  rt        d«       ‰ jA                  ||‰-‰|‰«      |fS |dk(  r1t        |tB        «      r!‰jE                  ‰|d   «      r|d   dk(  r‰dfS t        j6                  }|}t#        j$                  ‰t'        d«      ‰-«      }t"        jF                  jI                  tJ        jL                  |
|	‰-¬«      }tO        |||«      ‰ j>                  |<   ‰ j/                  ‰|||«       ‰j3                  |«      }t        j                  dk\  rt        d|tQ        |«      «       t#        j$                  ‰t'        d «      ‰-«      Š/t#        jR                  d!tT        ‰-¬«      }tW        tT        «      } ‰ j<                  jY                  | ||fi «      Š.‰ j/                  ‰‰/| |«       ˆˆˆ-ˆˆ ˆ.ˆ/fd"„}! |!|	||«      \  }"}#}$ |!|
||«      \  }%}&}'|j+                  t#        j,                  ||‰-¬«      «       |j+                  t#        j,                  |‰/‰-¬«      «       |$�'|j+                  t#        j,                  |$|"‰-¬«      «       |'�'|j+                  t#        j,                  |'|%‰-¬«      «       t#        j$                  ‰t'        d#«      ‰-«      }(t"        jF                  jI                  tJ        jL                  |%|"‰-¬«      })tO        ||&|#«      ‰ j>                  |)<   ‰ j/                  ‰|(||)«       |j+                  t#        j,                  |)|(‰-¬«      «       t        |tB        «      rÕt        j                  dk\  rt        d$‰jZ                  «       d}*‰jZ                  j]                  «       D ]-  \  }+},|+d   |d   k(  sŒ‰jE                  |+d   |d   «      sŒ+|,}* n |*�Mt        j                  dk\  rt        d%|*«       ‰j_                  ||*d   «       ‰j_                  |(|*d   «       |(|fS ||(f‰jZ                  |<   |(|fS )&a¹  Reason about the size of a slice represented by the "index"
        variable, and return a variable that has this size data, or
        raise GuardException if it cannot reason about it.

        The computation takes care of negative values used in the slice
        with respect to the given dimensional size ("dsize").

        Extra statements required to produce the result are appended
        to parent function's stmts list.
        rH  ÚsliceÚbuiltinsr¸   r   r:   zslice_size index=z dsize=z index_def=z lhs=z rhs=z
 size_typ=z	 lhs_typ=z	 rhs_typ=FrO   rú  Tz$Replacing slice because lhs is None.r  r  r  z
lhs_known:z
rhs_known:Nr  zafter rewriting negativesz'lhs and rhs known so return static sizerh  r
  Úsize_relÚwrapra   c                 ó
  •— |s|t        j                  ‰	t        d«      ‰«      }t        j                  }t         j
                  j                  ‰| ‰gi ‰«      }‰
j                  ‰|||«       ‰‰
j                  |<   |||fS | |d fS )Nr  )	r   rò   r   r   r^   rK  rG  r¢  rm  )r—   Úval_typr  r  Úvar_typÚ	new_valuer  rÕ   r«  rŠ  rŸ   rH   Úwrap_vars         €€€€€€€rX   Úgen_wrap_if_not_knownz7ArrayAnalysis.slice_size.<locals>.gen_wrap_if_not_known¢  s~   ø€ ÙÜ—f‘f˜U¤M°%Ó$8¸#Ó>�ÜŸ*™*�ÜŸG™GŸL™L¨°C¸°<ÀÀSÓI�	ð —‘˜Y¨¨W°iÔ@Ø,/�—‘˜yÑ)Ø˜W iÐ0Ð0à˜W dÐ+Ð+rZ   Úpost_wrap_slice_sizezsize_rel is tuplezestablishing equivalence to)0r«  r   rR  r   rà   r   rx   rI   rì   r   r»   r¼   r¦   r§   r[   r   r�   r   rò   r   rõ   r½   r²  r¢  rÈ  r;  r  r^   rÑ  Úget_call_typerF   rm  r  r¹   rÇ   rK  rJ  rP  rQ  r   r÷   rÂ  ra   r   Úresolve_function_typer4  r  rÐ   )0rŸ   r%  r  rÕ   rŠ  rü  Ú	index_defrT  rU  rM  rN  r  r·  r¸  r  r  Úzero_varrO   r  r  r  Ú	lhs_knownÚ	rhs_knownÚreplacement_slice_varÚnew_arg_typsÚrs_calltypeÚ	slice_typÚorig_slice_typÚsize_varÚsize_valr!  Úwrap_defÚfntyr(  Úvar1Úvar1_typÚvalue1Úvar2Úvar2_typÚvalue2Úpost_wrap_size_varÚpost_wrap_size_valÚrel_map_entryÚrmeÚ	rme_tupler«  rH   r'  s0   ` ```                                        @@@rX   rh  zArrayAnalysis.slice_sizeá  sù  þ€ ð �i‰iˆä" 4§<¡<°Ó7ˆ	Ü'Ø�L‰L˜)¨T¯\©\ô
‰ˆˆxô 	�˜Ñ Ò= X°*Ð%=Ô>Ü”�I—N‘NÓ# qÑ(Ô)Ø�n‰n˜QÑˆØ�n‰n˜QÑˆØ—<‘< §
¡
Ñ+ˆØ—,‘,˜sŸx™xÑ(ˆØ—,‘,˜sŸx™xÑ(ˆä×!Ñ! QÒ&ÜÐ% e W¨G°E°7ð ;Ø(˜k¨¨s¨e°5¸¸ð >Ø&˜Z y°°	¸À7À)ðMô Nô !ŸM™M¨)Ó4ÐØ Ðô �gœuŸ~™~Ô.Ü—v‘v˜e¤]°6Ó%:¸CÓ@ˆHÜ—8‘8˜A˜sÓ#ˆDØ�L‰LœŸ™¨°hÀCÔHÔIØ�L‰L˜ H¬e×.BÑ.BÀ1Ó.EÀtÔLØˆCÜ×*Ñ*¨1Ó-ˆGØ&)Ð+<×+AÑ+AÀ!Ñ+DÐ%EÐÔ"Ø#ÐÜ×%Ñ%¨Ò*ÜÐ<Ô=ô �gœuŸ~™~Ô.ØˆCØˆGØ&7×&<Ñ&<¸QÑ&?ÀÐ%EÐÔ"Ø#ÐÜ×%Ñ%¨Ò*ÜÐ<Ô=à×#Ñ# CÓ(ˆØ×#Ñ# CÓ(ˆØ×%Ñ% eÓ,ˆ	Ü×!Ñ! QÒ&ÜØ˜7 I¨w¸ÀYôð ×)Ñ)ØØØØØØØØØØØØØó
ñ	
ØØØØØØð. ×)Ñ)ØØØØØØØØØØØØØó
ñ	
ØØØØØØô  ×!Ñ! QÒ&Ü�, 	Ô*Ü�, 	Ô*ñ  Ø$(Ñ!ô %'§F¡FØ”}Ð%8Ó9¸3ó%Ð!ô "ŸJ™J¬¯
©
Ð3ˆLØŸ,™, y§~¡~×':Ñ':Ñ;×IÑIØ—‘˜l¨BóˆKð 1<ˆD�N‰NÐ,Ñ-Ø�L‰LÜ—	‘	Ø+Ø0Øôôð 8<·|±|ÀEÇJÁJÑ7OˆD�L‰LÐ.×3Ñ3Ñ4ä×!Ñ! QÒ&ÜØ+ØØØØôñ ™Ü×%Ñ%¨Ò*ÜÐ?Ô@à×*Ñ*Ø˜W c¨5°%¸óð &ð	ð ð �qŠLÜ˜7¤EÔ*Ø×"Ñ" 5¨'°!©*Ô5Ø˜‘
˜a’à˜$�;Ðä—J‘Jˆ	Ø"ˆä—6‘6˜%¤¨|Ó!<¸cÓBˆÜ—7‘7—=‘=¤§¡¨s°C¸S�=ÓAˆÜ#,¨Y¸ÀÓ#Iˆ�‰�xÑ Ø�‰�Y ¨)°XÔ>Ø×$Ñ$ XÓ.ˆÜ×!Ñ! QÒ&Ü�*˜h¬¨X«Ô7ä—6‘6˜%¤¨vÓ!6¸Ó<ˆÜ—9‘9˜\¬:¸3Ô?ˆÜ"¤:Ó.ˆØ�l‰l×0Ñ0Ø�> 8Ð,¨bó
ˆð 	�‰�Y ¨$°Ô9÷	,ò 	,ñ "7°s¸GÀYÓ!OÑˆˆh˜Ù!6°s¸GÀYÓ!OÑˆˆh˜à�‰”R—Y‘Y X°hÀCÔHÔIØ�‰”R—Y‘Y X°hÀCÔHÔIØÐØ�L‰LœŸ™¨¸À#ÔFÔGØÐØ�L‰LœŸ™¨¸À#ÔFÔGäŸV™VØ”=Ð!7Ó8¸#ó
Ðô  ŸW™WŸ]™]¬8¯<©<Ø+/Ø+/Ø/2ð +ó 4Ðô .7Ø�x ó.
ˆ�‰Ð)Ñ*ð 	�‰ØÐ)¨9Ð6Hô	
ð 	�‰Ü�I‰IØ(Ð1CÈôô	
ô �h¤Ô&Ü×%Ñ%¨Ò*ÜÐ)¨9×+<Ñ+<Ô=Ø ˆMØ"+×"3Ñ"3×"9Ñ"9Ó";ò ‘��YØ�q‘6˜X a™[Ó(¨Y×-?Ñ-?Ø˜‘F˜H Q™Kõ.ð %.�MÙðð Ð(ô ×)Ñ)¨QÒ.ÜÐ7¸ÔGØ×&Ñ& x°¸qÑ1AÔBØ×&Ñ&Ð'9¸=ÈÑ;KÔLð "Ð#8Ð8Ð8ð 08Ð9KÐ.L�	×!Ñ! (Ñ+à!Ð#8Ð8Ð8rZ   c                 ó\  ‡ ‡‡‡— ‰ j                   |j                     }t        t        |t        j
                  «      «       ‰ j                   |j                     }‰j                  |«      }‰j                  |«      }t        |t        j                  «      r|f}	|f}
n^t        t        |t        j                  «      «       t        ‰ j                  |«      \  }
}t        |dk(  «       t        ˆ fd„|
D «       «      }	t        t        |«      t        |	«      cxk(  xr t        |«      k(  nc «       g Šˆˆˆ ˆfd„}g }g }d}t        |	|||
«      D ]L  \  }}}} ||||«      \  }}|j                  |«       |�d}|j                  |«       Œ<|j                  |«       ŒN |r¼t        |«      dkD  r¨t        j                   ‰t#        d«      |d	   j$                  «      }t        j&                  j)                  ||d	   j$                  «      }‰j                  t        j*                  |||d	   j$                  ¬
«      «       |‰ j                   |j                  <   n|d	   }nd}t        |«      }t        t-        d„ |D «       «       «       t        d„ |D «       «      }|t.        j1                  |‰¬«      fS )a„  For indexing like var[index] (either write or read), see if
        the index corresponds to a range/slice shape.
        Returns a 2-tuple where the first item is either None or a ir.Var
        to be used to replace the index variable in the outer getitem or
        setitem instruction.  The second item is also a tuple returning
        the shape and prepending instructions.
        Úbuild_tuplec              3   óP   •K  — | ]  }‰j                   |j                     –— Œ y ­wrh   )rà   rì   r¶   s     €rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>þ  s   øè ø€ Ò?°a˜TŸ\™\¨!¯&©&Õ1Ñ?ùs   ƒ#&c                 ó°   •— t        | t        j                  «      r‰j                  ||‰‰‰«      S t        | t        j                  «      ryt        d«       y )Nrd  F)r[   r   rk   rh  rW  r   )rø   r%  r  rÕ   rŠ  rŸ   rü  s      €€€€rX   Úto_shapez/ArrayAnalysis._index_to_shape.<locals>.to_shape  sB   ø€ Ü˜#œuŸ™Ô/Ø—‘ u¨e°YÀÀuÓMÐMÜ˜C¤§¡Ô.Ø!ô ˜•rZ   FNTr:   Úreplacement_build_tupler   rú  c              3   ó$   K  — | ]  }|d u –— Œ
 y ­wrh   rd   ©rl   r°   s     rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>?  s   è ø€ Ò1 a˜˜Tœ	Ñ1ùs   ‚c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wrh   rd   rK  s     rX   rn   z0ArrayAnalysis._index_to_shape.<locals>.<genexpr>@  s   è ø€ Ò8˜A¨!©-”aÑ8ùs   ‚Š©rs   r”  )rà   rì   r   r[   r   ri   r  rk   rj   r   rR  r¹   rx   ry   r½   r   rò   r   r«  rK  rE  r²  r“   rk  r§  )rŸ   rŠ  rÕ   r  Úind_varrø   Úind_typÚ	ind_shapeÚ	var_shapeÚseq_typsÚseqrL  rH  Ú
shape_listÚindex_var_listÚreplace_indexrM   r  Úorig_indÚ
shape_partÚindex_var_partÚreplacement_build_tuple_varÚnew_build_tuplers   rü  s   ```                     @rX   rË  zArrayAnalysis._index_to_shapeê  ss  û€ ð �l‰l˜3Ÿ8™8Ñ$ˆÜ”
˜3¤× 5Ñ 5Ó6Ô7Ø—,‘,˜wŸ|™|Ñ,ˆØ×(Ñ(¨Ó1ˆ	Ø×(Ñ(¨Ó-ˆ	Ü�gœuŸ™Ô/Ø�zˆHØ�*‰Cä”J˜w¬¯©Ó8Ô9Ü)¨$¯,©,¸Ó@‰GˆC�Ü�B˜-Ñ'Ô(ÜÓ?¸3Ô?Ó?ˆHÜ”�I“¤# h£-ÖA´3°y³>ÔAÔBØˆ÷	ð ˆ
ØˆØˆÜ,/°Ø09Ø09Ø03ó-5ò 	0Ñ(ˆS�$˜˜xñ
 *2°#°t¸UÓ)CÑ&ˆJ˜Ø×Ñ˜jÔ)ð
 Ð)à $�Ø×%Ñ% nÕ5à×%Ñ% hÕ/ð!	0ñ( ä�>Ó" QÒ&ä.0¯f©fØÜ!Ð";Ó<Ø˜a‘L×$Ñ$ó/Ð+ô #%§'¡'×"5Ñ"5Ø" I¨a¡L×$4Ñ$4ó#�ð —‘Ü—I‘IØ-Ø:Ø% a™L×,Ñ,ôôð BI�—‘Ð8×=Ñ=Ò>à.<¸QÑ.?Ñ+à*.Ð'ä�jÓ!ˆÜ”CÑ1¨5Ô1Ó1Ð1Ô2ÜÑ8 Ô8Ó8ˆØ+Ü×+Ñ+°%¸UÐ+ÓCðEð 	ErZ   c                 óz   — | j                  |||j                  |j                  «      }|d   �
|d   |_        |d   S rE  )rË  rö   r%  )rŸ   rŠ  rÕ   rS  rM  rÔ  s         rX   Ú_analyze_op_getitemz!ArrayAnalysis._analyze_op_getitemD  s?   € Ø×%Ñ% e¨Y¸¿
¹
ÀDÇJÁJÓOˆØ�!‰9Ð Ø ™ˆDŒJØ�a‰yÐrZ   c                 óh  — |j                   }| j                  |j                     }t        |t        j
                  «      s<| j                  |||j                   |j                  «      }|d   �
|d   |_        |d   S |j                  |«      }t        |j                  t        «      rDt        |j                  t        |«      k  «       t        j                  ||j                     ¬«      S t        |j                  t        «      r#t        j                  ||j                     ¬«      S t        d«       y )Nr   r:   rê  F)rö   rà   rì   r[   r   rj   rË  rÊ  r  r%  rÉ   r   rx   rk  r§  r  )	rŸ   rŠ  rÕ   rS  rM  r  rø   rÔ  rs   s	            rX   Ú_analyze_op_static_getitemz(ArrayAnalysis._analyze_op_static_getitemJ  sï   € Ø�j‰jˆØ�l‰l˜3Ÿ8™8Ñ$ˆÜ˜#œuŸ™Ô/Ø×)Ñ)Ø�y $§*¡*¨d¯n©nóˆFð �a‰yÐ$Ø!'¨¡�”Ø˜!‘9ÐØ×$Ñ$ SÓ)ˆÜ�d—j‘j¤#Ô&Ü�D—J‘J¤ U£Ñ+Ô,Ü ×.Ñ.°U¸4¿:¹:Ñ5FÐ.ÓGÐGÜ˜Ÿ
™
¤EÔ*Ü ×.Ñ.°U¸4¿:¹:Ñ5FÐ.ÓGÐGÜ��rZ   c                 óþ   — t        |j                  t        v «       | j                  |j                  j
                  «      s|j                  t        j                  k(  r t        j                  |j                  ¬«      S y ró  )
r   rO  ÚUNARY_MAP_OPrî  rö   rì   rP  rE   rk  r§  rô  s        rX   Ú_analyze_op_unaryzArrayAnalysis._analyze_op_unary\  sS   € Ü�—‘œ<Ð'Ô(ð �=‰=˜Ÿ™Ÿ™Ô)¨T¯W©W¼¿¹Ò-DÜ ×.Ñ.°T·Z±ZÐ.Ó@Ð@ØrZ   c                 ó¶   — t        |j                  t        v «       | j                  |||j                  |j
                  |j                  g|j                  «      S rh   )r   rO  ÚBINARY_MAP_OPÚ_analyze_broadcastr«  rM  rN  rô  s        rX   Ú_analyze_op_binopzArrayAnalysis._analyze_op_binopd  sF   € Ü�—‘œ=Ð(Ô)Ø×&Ñ&Ø�9˜dŸh™h¨¯©°4·8±8Ð(<¸d¿g¹gó
ð 	
rZ   c                 ó¶   — t        |j                  t        v «       | j                  |||j                  |j
                  |j                  g|j                  «      S rh   )r   rO  ÚINPLACE_BINARY_MAP_OPre  r«  rM  rN  rô  s        rX   Ú_analyze_op_inplace_binopz'ArrayAnalysis._analyze_op_inplace_binopj  sG   € Ü�—‘Ô0Ð0Ô1Ø×&Ñ&Ø�9˜dŸh™h¨¯©°4·8±8Ð(<¸d¿g¹gó
ð 	
rZ   c                 ó\   — | j                  |||j                  |j                  «       d «      S rh   )re  r«  Ú	list_varsrô  s        rX   Ú_analyze_op_arrayexprz#ArrayAnalysis._analyze_op_arrayexprp  s+   € Ø×&Ñ&Ø�9˜dŸh™h¨¯©Ó(8¸$ó
ð 	
rZ   c           	      óÚ  — |j                   D ]w  }t        |t        j                  «      sŒt        | j                  |j
                     t        j                  «      sŒP| j                  |j
                     j                  dkD  sŒw y  g }|j                   D ]2  }t        t        | j                  |«      }|�|j                  |«       Œ2 nv t        |D �cg c]"  }t        j                  ||j                  «      ‘Œ$ c}«      }t         j#                  |t        j                  t        |«      |j                  «      ¬«      S t         j#                  t        |j                   «      ¬«      S c c}w )Nr:   ©rs   rN  rê  )r  r[   r   rò   rà   rì   r   ri   rô   r   r   rR  r½   r¹   rõ   r«  rk  r§  )	rŸ   rŠ  rÕ   rS  rM  r°   Úconstsr  Úouts	            rX   Ú_analyze_op_build_tuplez%ArrayAnalysis._analyze_op_build_tupleu  s  € ð
 —‘ò 	ˆAä˜1œbŸf™fÕ%Ü˜tŸ|™|¨A¯F©FÑ3´U×5JÑ5JÕKØ—L‘L §¡Ñ(×-Ñ-°Ó1áð	ð ˆØ—:‘:ò 	ˆCÜ”j $§,¡,°Ó4ˆAØˆ}Ø—‘˜aÕ áð	ô ¸Ö?°1œŸ™ ! T§X¡XÕ.Ò?Ó@ˆCÜ ×.Ñ.ØÜ—H‘HœU 6›]¨D¯H©HÓ5ð /ó ð ô
 ×*Ñ*´°t·z±zÓ1BÐ*ÓCÐCùò @s   Ã'E(c           
      óœ  — ddl m} |j                  }t        | j                  |«      }t        |t        j                  t        j                  f«      r>t        |j                  «      r)t        j                  t        |j                  «      ¬«      S t        |t        j                  t        j                  f«      r_t        |j                  |«      rI|j                  }| j                  |||j                  |j                   |t#        |j$                  «      «      S t'        | j                  || j(                  ¬«      \  }	}
d}t        |
t        j*                  «      rFt        | j(                  |
j,                     t.        j0                  «      r|
g|j                  z   }d}
d}n|j                  }dj3                  |
|	«      j5                  d	d
«      }	|	t6        v r| j9                  |||j                   |d «      S 	 t;        | |	«      }t?        ||||j                   |t#        |j$                  «      ¬«      }|r
|dd  |_        |S # t<        $ r Y y w xY w)Nr   )ÚStencilFuncrê  rH  FÚnumpyTz_analyze_op_call_{}_{}ú.r  )rŠ  rÕ   r«  rI   Úkwsr:   ) Únumba.stencils.stencilrs  rÑ  r   rR  r[   r   rÂ  ÚFreeVarr   rö   rk  r§  r¹   rI   Ú_analyze_stencilr«  Údictrv  r   rà   rò   rì   r   ri   rª   ÚreplaceÚUFUNC_MAP_OPre  ræ  rç  r   )rŸ   rŠ  rÕ   rS  rM  rs  ÚcalleeÚ
callee_defrI   rT  rU  Úadded_mod_namerO  rÔ  s                 rX   Ú_analyze_op_callzArrayAnalysis._analyze_op_call’  sý  € Ý6à—‘ˆÜ# D§L¡L°&Ó9ˆ
ÜØœŸ™¤B§J¡JÐ/ô
ä! *×"2Ñ"2Ô3Ü ×.Ñ.´U¸4¿9¹9Ó5EÐ.ÓFÐFÜ�j¤2§9¡9¬b¯j©jÐ"9Ô:¼zØ×Ñ˜kô@
ð —9‘9ˆDØ×(Ñ(ØØØ× Ñ Ø—‘ØÜ�T—X‘X“óð ô (Ø�L‰L˜$¨¯©ô
‰ˆˆxð ˆä�h¤§¡Ô'¬JØ�L‰L˜Ÿ™Ñ'¬×)>Ñ)>ô-
ð �: §	¡	Ñ)ˆDØˆHà!‰Nà—9‘9ˆDØ(×/Ñ/°¸%Ó@×HÑHØ�ó
ˆð ”LÑ Ø×*Ñ*¨5°)Ø+/¯8©8°T¸4óAð AðÜ˜T 5Ó)�ô ØØØ#Ø—H‘HØÜ˜Ÿ™“NôˆFñ Ø   ˜H�”	ØˆMøô! "ò Ùðús   Ç7H? È?	IÉ
Ic                 ó  — t        t        |«      dk(  «       |d   }| j                  |j                     }t        t	        |t
        j                  «      «       |j                  |«      }t        j                  |d   |d   ¬«      S )Nr:   r   rn  )
r   rx   rà   rì   r[   r   ri   r  rk  r§  )	rŸ   rŠ  rÕ   r«  rI   rv  r  rø   rs   s	            rX   Ú_analyze_op_call_builtins_lenz+ArrayAnalysis._analyze_op_call_builtins_lenÑ  sp   € ä”�D“	˜Q‘ÔØ�1‰gˆØ�l‰l˜3Ÿ8™8Ñ$ˆÜ”
˜3¤× 5Ñ 5Ó6Ô7Ø×$Ñ$ SÓ)ˆÜ×*Ñ*°°q±¸uÀQ¹xÐ*ÓHÐHrZ   c                 ó(   —  |j                   |dd  Ž  y ©Nr:   )rÐ   ©rŸ   rŠ  rÕ   r«  rI   rv  s         rX   Ú:_analyze_op_call_numba_parfors_array_analysis_assert_equivzHArrayAnalysis._analyze_op_call_numba_parfors_array_analysis_assert_equivÚ  s   € ð 	ˆ	×Ñ  Q R Ñ)ØrZ   c                 óÎ  — t        t        |«      dk(  «       |d   j                  }|d   j                  }|j                  |«      }|j                  |«      }	||	f|j                  v r_|j                  ||	f   }
t        |
|j
                  v «       |j
                  |
   }t        |g k7  «       t        j                  |d   f¬«      S t        j                  t        ||	«      ¬«      S )zX Analyze wrap_index calls added by a previous run of
            Array Analysis
        r¸   r   r:   rê  )	r   rx   rì   r³   r5  râ   rk  r§  rf  )rŸ   rŠ  rÕ   r«  rI   rv  rh  ri  Úslice_eqÚdim_eqÚwrap_indr  s               rX   Ú8_analyze_op_call_numba_parfors_array_analysis_wrap_indexzFArrayAnalysis._analyze_op_call_numba_parfors_array_analysis_wrap_indexà  så   € ô 	”�D“	˜Q‘Ôà˜!‘W—\‘\ˆ
à˜‘7—<‘<ˆà×,Ñ,¨ZÓ8ˆØ×*Ñ*¨8Ó4ˆð �fÐ ×!3Ñ!3Ñ3Ø ×)Ñ)¨8°VÐ*<Ñ=ˆHÜ�H 	× 4Ñ 4Ð4Ô5Ø×%Ñ% hÑ/ˆBÜ�B˜"‘HÔä ×.Ñ.°b¸±e°XÐ.Ó>Ð>ô
 !×.Ñ.Ü# H¨fÓ5ð /ó ð rZ   c                 óž   — d }t        |«      dkD  r|d   }n	d|v r|d   }|rt        j                  |¬«      S t        j                  d|¬«      ‚)Nr   rs   rê  z'Must specify a shape for array creationr
  )rx   rk  r§  r   ÚUnsupportedRewriteError)rŸ   rŠ  rÕ   r«  rI   rv  Ú	shape_vars          rX   Ú_analyze_numpy_create_arrayz)ArrayAnalysis._analyze_numpy_create_arrayÿ  s[   € Øˆ	Üˆt‹9�qŠ=Ø˜Q™‰IØ˜‰^Ø˜G™ˆIÙÜ ×.Ñ.°YÐ.Ó?Ð?Ü×,Ñ,Ø5Øô
ð 	
rZ   c                 ó,   — | j                  |||||«      S rh   ©r�  r…  s         rX   Ú_analyze_op_call_numpy_emptyz*ArrayAnalysis._analyze_op_call_numpy_empty	  ó    € Ø×/Ñ/Ø�9˜c 4¨ó
ð 	
rZ   c                 ó,   — | j                  |||||«      S rh   r‘  r…  s         rX   Ú7_analyze_op_call_numba_np_unsafe_ndarray_empty_inferredzEArrayAnalysis._analyze_op_call_numba_np_unsafe_ndarray_empty_inferred	  s"   € ð ×/Ñ/Ø�9˜c 4¨ó
ð 	
rZ   c                 ó,   — | j                  |||||«      S rh   r‘  r…  s         rX   Ú_analyze_op_call_numpy_zerosz*ArrayAnalysis._analyze_op_call_numpy_zeros	  r“  rZ   c                 ó,   — | j                  |||||«      S rh   r‘  r…  s         rX   Ú_analyze_op_call_numpy_onesz)ArrayAnalysis._analyze_op_call_numpy_ones	  r“  rZ   c                 ó´   — t        |«      dkD  r|d   }n!d|v r|d   }nt        j                  d|¬«      ‚d|v r|d   }n|}t        j	                  ||f¬«      S )Nr   ÚNz,Expect one argument (or 'N') to eye functionr
  ÚMrê  )rx   r   r�  rk  r§  )rŸ   rŠ  rÕ   r«  rI   rv  r›  rœ  s           rX   Ú_analyze_op_call_numpy_eyez(ArrayAnalysis._analyze_op_call_numpy_eye"	  sn   € Üˆt‹9�qŠ=Ø�Q‘‰AØ�C‰ZØ�C‘‰Aä×0Ñ0Ø>Øôð ð �#‰:Ø�C‘‰AàˆAÜ×*Ñ*°!°Q°Ð*Ó8Ð8rZ   c                 ó\   — t        |«      dkD  sJ ‚|d   }t        j                  ||f¬«      S ©Nr   rê  ©rx   rk  r§  )rŸ   rŠ  rÕ   r«  rI   rv  r›  s          rX   Ú_analyze_op_call_numpy_identityz-ArrayAnalysis._analyze_op_call_numpy_identity2	  s5   € ô �4‹y˜1Š}Ðˆ}Ø�‰GˆÜ×*Ñ*°!°Q°Ð*Ó8Ð8rZ   c                 ó  — t        |«      dkD  sJ ‚|d   }t        |t        j                  «      sJ ‚| j                  |j
                     }t        |t        j                  «      r£|j                  dk(  rZd|v r|d   }|j                  |d«      sy |j                  |«      \  }	}
|j                  |	|
«      rt        j                  |	f¬«      S y |j                  dk(  r+|j                  |«      \  }	t        j                  |	|	f¬«      S y )Nr   r¸   r"  rê  r:   )rx   r[   r   rò   rà   rì   r   ri   rô   rÇ   r  rk  r§  )rŸ   rŠ  rÕ   r«  rI   rv  rm   Úatypr"  rƒ   r„   s              rX   Ú_analyze_op_call_numpy_diagz)ArrayAnalysis._analyze_op_call_numpy_diag9	  sú   € ô �4‹y˜1Š}Ðˆ}Ø�‰GˆÜ˜!œRŸV™VÔ$Ð$Ð$Ø�|‰|˜AŸF™FÑ#ˆÜ�dœE×1Ñ1Ô2Ø�y‰y˜AŠ~Ø˜#‘:Ø˜C™�AØ$×-Ñ-¨a°Ô3Ø#Ø"×-Ñ-¨aÓ0‘��AØ×%Ñ% a¨Ô+Ü(×6Ñ6¸a¸TÐ6ÓBÐBð ð —‘˜a’Ø ×+Ñ+¨AÓ.‘�Ü$×2Ñ2¸!¸Q¸Ð2Ó@Ð@ØrZ   c                 óB  — t        |«      dkD  sJ ‚|d   }| j                  |j                     }t        |t        j
                  «      rt        j                  d¬«      S t        |t        j                  «      r'|j                  |«      rt        j                  |¬«      S y )Nr   )r:   rê  )
rx   rà   rì   r[   r   r]   rk  r§  ri   r  )rŸ   rŠ  rÕ   rI   rv  r  rø   s          rX   Ú_analyze_numpy_array_likez'ArrayAnalysis._analyze_numpy_array_likeN	  sˆ   € Ü�4‹y˜1Š}Ðˆ}Ø�1‰gˆØ�l‰l˜3Ÿ8™8Ñ$ˆÜ�cœ5Ÿ=™=Ô)Ü ×.Ñ.°TÐ.Ó:Ð:Ü˜œU×2Ñ2Ô3¸	×8KÑ8KØô9
ô !×.Ñ.°SÐ.Ó9Ð9ØrZ   c                 óP  — t        |«      dk(  sJ ‚|d   }| j                  |j                     }t        |t        j
                  «      sJ ‚|j                  dk(  rM|j                  |«      r<|j                  dk(  rt        j                  ||¬«      S t        j                  |¬«      S y )Nr:   r   ÚCrn  rê  )rx   rà   rì   r[   r   ri   rô   r  Úlayoutrk  r§  )rŸ   rŠ  rÕ   r«  rI   rv  r  rø   s           rX   Ú_analyze_op_call_numpy_ravelz*ArrayAnalysis._analyze_op_call_numpy_ravelZ	  s–   € Ü�4‹y˜AŠ~Ðˆ~Ø�1‰gˆØ�l‰l˜3Ÿ8™8Ñ$ˆÜ˜#œu×4Ñ4Ô5Ð5Ð5à�8‰8�qŠ=˜Y×0Ñ0°Ô5Ø�z‰z˜SÒ ô %×2Ñ2¸À#Ð2ÓFÐFä$×2Ñ2¸Ð2Ó=Ð=àrZ   c                 ó*   — | j                  ||||«      S rh   ©r¦  r…  s         rX   Ú_analyze_op_call_numpy_copyz)ArrayAnalysis._analyze_op_call_numpy_copyj	  s   € Ø×-Ñ-¨e°YÀÀcÓJÐJrZ   c                 ó*   — | j                  ||||«      S rh   r¬  r…  s         rX   Ú!_analyze_op_call_numpy_empty_likez/ArrayAnalysis._analyze_op_call_numpy_empty_likem	  ó   € ð ×-Ñ-¨e°YÀÀcÓJÐJrZ   c                 ó*   — | j                  ||||«      S rh   r¬  r…  s         rX   Ú!_analyze_op_call_numpy_zeros_likez/ArrayAnalysis._analyze_op_call_numpy_zeros_liker	  r°  rZ   c                 ó*   — | j                  ||||«      S rh   r¬  r…  s         rX   Ú _analyze_op_call_numpy_ones_likez.ArrayAnalysis._analyze_op_call_numpy_ones_likew	  r°  rZ   c                 ó*   — | j                  ||||«      S rh   r¬  r…  s         rX   Ú _analyze_op_call_numpy_full_likez.ArrayAnalysis._analyze_op_call_numpy_full_like|	  r°  rZ   c                 ó*   — | j                  ||||«      S rh   r¬  r…  s         rX   Ú%_analyze_op_call_numpy_asfortranarrayz3ArrayAnalysis._analyze_op_call_numpy_asfortranarray�	  r°  rZ   c                 ó   — t        |«      }|dkD  sJ ‚|dk(  rO| j                  |d   j                     }t        |t        j
                  «      rt        j                  |d   ¬«      S g }d}	t        dt        |«      «      D ]w  }
||
   }t        t        | j                  |«      }t        |t        j                  «      sŒ>|j                  dk  sŒN|	dk(  r|
}	ŒVd}t        j                   ||j"                  ¬«      ‚ |	dk\  �r­|d   j"                  }t        j$                  |t'        d«      |«      }t        j(                  | j                  |j                  <   t        j*                  t        j,                  j/                  |d   d	|«      ||«      }|j1                  |«       t        dt        |«      «      D ]ð  }
|
|	k(  rŒ	t        j$                  |t'        d«      |«      }t        j(                  | j                  |j                  <   t        j,                  j3                  t4        j6                  |||
   |«      }t        j*                  |||«      }t9        t        j(                  t        j(                  t        j(                  «      | j:                  |<   |j1                  |«       |}Œò |||	<   t        j                  t=        |dd  «      |¬
«      S )Nr:   r¸   rê  r   r   z7The reshape API may only include one negative argument.r
  Úcalc_size_varrM   rM  )rx   rà   rì   r[   r   rj   rk  r§  r‹   r   r   rR  r   rõ   rö   r   r�  r«  rò   r   r^   r²  rK  ræ  r½   rJ  rP  Úfloordivr   rm  r¹   )rŸ   rŠ  rÕ   r«  rI   rv  r„   rø   rü  Úneg_one_indexÚ	arg_indexÚreshape_argÚreshape_arg_defrˆ   rº  Úinit_calc_varÚdiv_calc_size_varÚ	new_binopÚdiv_calcs                      rX   Ú_analyze_op_call_numpy_reshapez,ArrayAnalysis._analyze_op_call_numpy_reshape†	  sd  € Ü�‹IˆØ�1ŠuˆˆuØ�Š6Ø—,‘,˜t A™wŸ|™|Ñ,ˆCÜ˜#œuŸ™Ô/Ü$×2Ñ2¸¸a¹Ð2ÓAÐAð ˆØˆÜ˜q¤# d£)Ó,ò 	ˆIØ˜y™/ˆKÜ#¤N°D·L±LÀ+ÓNˆOÜ˜/¬2¯8©8Õ4Ø"×(Ñ(¨1Ó,Ø$¨Ò*Ø(1™ð ,˜ä$×<Ñ<Ø [§_¡_ôð ð	ð ˜AÓð �q‘'—+‘+ˆCäŸF™F 5¬-¸Ó*HÈ#ÓNˆMÜ/4¯z©zˆD�L‰L˜×+Ñ+Ñ,äŸI™IÜ—‘—‘  Q¡¨°Ó5°}ÀcóˆMð �L‰L˜Ô'ô # 1¤c¨$£iÓ0ò 2�	à Ò-ØÜ$&§F¡FØœ=¨Ó9¸3ó%Ð!ô 8=·z±z�—‘Ð.×3Ñ3Ñ4ô ŸG™GŸM™MÜ×%Ñ% }°d¸9±oÀsó�	ô Ÿ9™9 YÐ0AÀ3ÓG�Ü,5Ü—J‘J¤§
¡
¬E¯J©Jó-�—‘˜yÑ)ð —‘˜XÔ&Ø 1‘ð%2ð* #0ˆD�Ñä×*Ñ*´°t¸A¸B°x³ÀeÐ*ÓLÐLrZ   c                 ó&  — |d   }| j                   |j                     }t        |t        j                  «      sJ d«       ‚|j                  |«      }t        |«      dk(  r(t        j                  t        t        |«      «      ¬«      S |dd  D �	cg c]  }	t        t        | j                  |	«      ‘Œ }
}	t        |
d   t        «      rt        |
d   «      }
d |
v ry |
D �cg c]  }||   ‘Œ	 }}t        j                  t        |«      ¬«      S c c}	w c c}w )Nr   zInvalid np.transpose argumentr:   rê  )rà   rì   r[   r   ri   r  rx   rk  r§  r¹   Úreversedr   r   rR  r  )rŸ   rŠ  rÕ   r«  rI   rv  Úin_arrrø   rs   rm   Úaxesr�   Úrets                rX   rï  z.ArrayAnalysis._analyze_op_call_numpy_transposeÐ	  s  € ð �a‘ˆØ�l‰l˜6Ÿ;™;Ñ'ˆÜØ”×&Ñ&ô
ð 	+à*ó	+ð 
ð ×$Ñ$ VÓ,ˆÜˆt‹9˜Š>Ü ×.Ñ.´U¼8ÀE»?Ó5KÐ.ÓLÐLØ<@ÀÀ¸HÖE°q””j $§,¡,°Õ2ÐEˆÐEÜ�d˜1‘gœuÔ%Ü˜˜Q™“=ˆDØ�4‰<ØØ!%Ö&˜Aˆu�Q‹xÐ&ˆÐ&Ü×*Ñ*´°s³Ð*Ó<Ð<ùò Fùò
 's   Â"D	ÃDc                 ó^   — t        |«      dkD  rt        j                  t        |«      ¬«      S y rŸ  )rx   rk  r§  r¹   r…  s         rX   Ú"_analyze_op_call_numpy_random_randz0ArrayAnalysis._analyze_op_call_numpy_random_randã	  s*   € ô ˆt‹9�qŠ=Ü ×.Ñ.´U¸4³[Ð.ÓAÐAØrZ   c                 ó,   — | j                  |||||«      S rh   )rË  r…  s         rX   Ú#_analyze_op_call_numpy_random_randnz1ArrayAnalysis._analyze_op_call_numpy_random_randnê	  s"   € ð ×6Ñ6Ø�9˜c 4¨ó
ð 	
rZ   c                 óŒ   — d|v rt         j                  |d   ¬«      S t        |«      |kD  rt         j                  ||   ¬«      S y )NrM   rê  )rk  r§  rx   )rŸ   ÚposrŠ  rÕ   rI   rv  s         rX   Ú"_analyze_op_numpy_random_with_sizez0ArrayAnalysis._analyze_op_numpy_random_with_sizeñ	  sI   € ð �S‰=Ü ×.Ñ.°S¸±[Ð.ÓAÐAÜˆt‹9�sŠ?Ü ×.Ñ.°T¸#±YÐ.Ó?Ð?ØrZ   c                 ó,   — | j                  d||||«      S rc   ©rÐ  r…  s         rX   Ú"_analyze_op_call_numpy_random_ranfz0ArrayAnalysis._analyze_op_call_numpy_random_ranfú	  ó"   € ð ×6Ñ6Øˆu�i  só
ð 	
rZ   c                 ó,   — | j                  d||||«      S rc   rÒ  r…  s         rX   Ú+_analyze_op_call_numpy_random_random_samplez9ArrayAnalysis._analyze_op_call_numpy_random_random_sample
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rc   rÒ  r…  s         rX   Ú$_analyze_op_call_numpy_random_samplez2ArrayAnalysis._analyze_op_call_numpy_random_sample
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rc   rÒ  r…  s         rX   Ú$_analyze_op_call_numpy_random_randomz2ArrayAnalysis._analyze_op_call_numpy_random_random
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rc   rÒ  r…  s         rX   Ú-_analyze_op_call_numpy_random_standard_normalz;ArrayAnalysis._analyze_op_call_numpy_random_standard_normal
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú'_analyze_op_call_numpy_random_chisquarez5ArrayAnalysis._analyze_op_call_numpy_random_chisquare
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú%_analyze_op_call_numpy_random_weibullz3ArrayAnalysis._analyze_op_call_numpy_random_weibull$
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú#_analyze_op_call_numpy_random_powerz1ArrayAnalysis._analyze_op_call_numpy_random_power+
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú'_analyze_op_call_numpy_random_geometricz5ArrayAnalysis._analyze_op_call_numpy_random_geometric2
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú)_analyze_op_call_numpy_random_exponentialz7ArrayAnalysis._analyze_op_call_numpy_random_exponential9
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú%_analyze_op_call_numpy_random_poissonz3ArrayAnalysis._analyze_op_call_numpy_random_poisson@
  rÔ  rZ   c                 ó,   — | j                  d||||«      S r„  rÒ  r…  s         rX   Ú&_analyze_op_call_numpy_random_rayleighz4ArrayAnalysis._analyze_op_call_numpy_random_rayleighG
  rÔ  rZ   c                 ó,   — | j                  d||||«      S ©Nr¸   rÒ  r…  s         rX   Ú$_analyze_op_call_numpy_random_normalz2ArrayAnalysis._analyze_op_call_numpy_random_normalN
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú%_analyze_op_call_numpy_random_uniformz3ArrayAnalysis._analyze_op_call_numpy_random_uniformU
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú"_analyze_op_call_numpy_random_betaz0ArrayAnalysis._analyze_op_call_numpy_random_beta\
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú&_analyze_op_call_numpy_random_binomialz4ArrayAnalysis._analyze_op_call_numpy_random_binomialc
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú_analyze_op_call_numpy_random_fz-ArrayAnalysis._analyze_op_call_numpy_random_fj
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú#_analyze_op_call_numpy_random_gammaz1ArrayAnalysis._analyze_op_call_numpy_random_gammaq
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú'_analyze_op_call_numpy_random_lognormalz5ArrayAnalysis._analyze_op_call_numpy_random_lognormalx
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú%_analyze_op_call_numpy_random_laplacez3ArrayAnalysis._analyze_op_call_numpy_random_laplace
  rÔ  rZ   c                 ó,   — | j                  d||||«      S rì  rÒ  r…  s         rX   Ú%_analyze_op_call_numpy_random_randintz3ArrayAnalysis._analyze_op_call_numpy_random_randint†
  rÔ  rZ   c                 ó,   — | j                  d||||«      S )Né   rÒ  r…  s         rX   Ú(_analyze_op_call_numpy_random_triangularz6ArrayAnalysis._analyze_op_call_numpy_random_triangular�
  rÔ  rZ   c           	      ó,  — t        |«      dkD  sJ ‚|d   j                  }t        | j                  |d   «      \  }}t        |«      }t	        |dkD  «       d}	d|v r3t        |d   t        «      r|d   }	nAt        | j                  |d   «      }	n't        |«      dkD  rt        | j                  |d   «      }	t	        t        |	t        «      «       t	        |dk(  «       |D �
cg c]  }
|j                  |
«      ‘Œ }}
|	dk  rt        |d   «      |	z   }	t	        d|	cxk  xr t        |d   «      k  nc «       g }g }|dk(  r�|d   }|j                  |d   «      }|j                  d«       t        t        |«      «      D ]<  }||	k(  r |j                  ||   «      }|r|r||z  nd }Œ(| j                  ||d   «      }Œ> |j                  «       n�t        t        |d   «      «      D ]v  }||	k(  r$| j                  ||D �cg c]  }||   ‘Œ	 c}«      }n:|D �cg c]  }||   ‘Œ	 }}|j                  | j                  ||||«      «       |d   }|j                  |«       Œx t        j!                  t#        |«      t%        |g «      ¬«      S c c}
w c c}w c c}w ©Nr   Úaxisr:   rE  rM  )rx   r«  r   rR  r   r[   rÉ   r   r  rÊ   Úpopr‹   Ú	_sum_sizer½   Ú_call_assert_equivrk  r§  r¹   r  )rŸ   rŠ  rÕ   r«  rI   rv  rS  rL  r„   r  r°   rÜ  r¹  Ú	new_shapers   r�   rƒ   rM   Úsizess                      rX   Ú"_analyze_op_call_numpy_concatenatez0ArrayAnalysis._analyze_op_call_numpy_concatenate”
  s„  € ô �4‹y˜1Š}Ðˆ}Ø�1‰g�k‰kˆÜ% d§l¡l°D¸±GÓ<‰ˆˆRÜ�‹HˆÜ��A‘ŒØˆØ�S‰=Ü˜#˜f™+¤sÔ+Ø˜6‘{‘ä! $§,¡,°°F±Ó<‘Ü�‹Y˜Š]Ü˜dŸl™l¨D°©GÓ4ˆDÜ”
˜4¤Ó%Ô&Ü��mÑ#Ô$Ø36Ö7¨a�)×&Ñ& qÕ)Ð7ˆÐ7Ø�!Š8Ü�v˜a‘y“> DÑ(ˆDÜ��TÖ*œC  q¡	›NÔ*Ô+ØˆØˆ	Ø�Š6Ø˜1‘IˆEà×)Ñ)¨&°©)Ó4ˆAØ�I‰I�aŒLÜœ3˜u›:Ó&ò @�Ø˜’9Ø!×1Ñ1°%¸±(Ó;�AÙ%&©1˜1˜qš5°4‘DàŸ>™>¨)°V¸A±YÓ?‘Dð@ð ×Ñ˜TÕ"äœ3˜v a™y›>Ó*ò '�Ø˜’9ØŸ>™>Ø!¸&Ö#A° E¨!£HÒ#Aó‘Dð 4:Ö:¨%˜U 1›XÐ:�EÐ:Ø—N‘NØ×/Ñ/°°s¸IÀuÓMôð ! ™8�DØ× Ñ  Õ&ð'ô ×*Ñ*Ü˜	Ó"Ü�G˜RÓ ð +ó 
ð 	
ùò? 8ùò, $Bùò ;s   Ã JÇ<JÈJc                 ó"  — t        |«      dkD  sJ ‚|d   j                  }t        | j                  |d   «      \  }}t        |«      }t	        |dkD  «       d}	d|v r3t        |d   t        «      r|d   }	nAt        | j                  |d   «      }	n't        |«      dkD  rt        | j                  |d   «      }	t	        t        |	t        «      «       t	        |dk(  «       |D �
cg c]  }
|j                  |
«      ‘Œ }}
| j                  ||||«      }|d   }|	dk  rt        |«      |	z   dz   }	t	        d|	cxk  xr t        |«      k  nc «       t        |d|	 «      |gz   t        ||	d  «      z   }t        j                  t        |«      |¬«      S c c}
w r  )rx   r«  r   rR  r   r[   rÉ   r   r  r  r  rk  r§  r¹   )rŸ   rŠ  rÕ   r«  rI   rv  rS  rL  r„   r  r°   rÜ  r¹  rs   r  s                  rX   Ú_analyze_op_call_numpy_stackz*ArrayAnalysis._analyze_op_call_numpy_stackÊ
  sq  € Ü�4‹y˜1Š}Ðˆ}Ø�1‰g�k‰kˆÜ% d§l¡l°D¸±GÓ<‰ˆˆRÜ�‹HˆÜ��A‘ŒØˆØ�S‰=Ü˜#˜f™+¤sÔ+Ø˜6‘{‘ä! $§,¡,°°F±Ó<‘Ü�‹Y˜Š]Ü˜dŸl™l¨D°©GÓ4ˆDÜ”
˜4¤Ó%Ô&ä��mÑ#Ô$Ø36Ö7¨a�)×&Ñ& qÕ)Ð7ˆÐ7Ø×)Ñ)¨%°°iÀÓEˆØ�q‘	ˆØ�!Š8Ü�u“: Ñ$ qÑ(ˆDÜ��TÖ'œS ›ZÔ'Ô(Ü˜˜q ˜Ó'¨1¨#Ñ-´°U¸4¸5°\Ó0BÑBˆ	Ü×*Ñ*´°yÓ1AÀwÐ*ÓOÐOùò 8s   Ã Fc                 ó†  — t        |«      dk(  sJ ‚t        | j                  |d   «      \  }}t        |«      }t        |dkD  «       | j                  |d   j
                     }	t        t        |	t        j                  «      «       |	j                  dk  r| j                  |||||«      S d|d<   | j                  |||||«      S ©Nr:   r   r¸   r  )rx   r   rR  r   rà   rì   r[   r   ri   rô   r  r	  ©
rŸ   rŠ  rÕ   r«  rI   rv  rS  rL  r„   rø   s
             rX   Ú_analyze_op_call_numpy_vstackz+ArrayAnalysis._analyze_op_call_numpy_vstackä
  s»   € Ü�4‹y˜AŠ~Ðˆ~Ü% d§l¡l°D¸±GÓ<‰ˆˆRÜ�‹HˆÜ��A‘ŒØ�l‰l˜3˜q™6Ÿ;™;Ñ'ˆÜ”
˜3¤× 5Ñ 5Ó6Ô7Ø�8‰8�aŠ<Ø×4Ñ4Ø�y # t¨Sóð ð ˆC�‰KØ×:Ñ:Ø�y # t¨Sóð rZ   c                 óh  — t        |«      dk(  sJ ‚t        | j                  |d   «      \  }}t        |«      }t        |dkD  «       | j                  |d   j
                     }	t        t        |	t        j                  «      «       |	j                  dk  rd|d<   nd|d<   | j                  |||||«      S r  )rx   r   rR  r   rà   rì   r[   r   ri   rô   r	  r  s
             rX   Ú_analyze_op_call_numpy_hstackz+ArrayAnalysis._analyze_op_call_numpy_hstackõ
  s¤   € Ü�4‹y˜AŠ~Ðˆ~Ü% d§l¡l°D¸±GÓ<‰ˆˆRÜ�‹HˆÜ��A‘ŒØ�l‰l˜3˜q™6Ÿ;™;Ñ'ˆÜ”
˜3¤× 5Ñ 5Ó6Ô7Ø�8‰8�aŠ<ØˆC�ŠKàˆC�‰KØ×6Ñ6Ø�9˜c 4¨ó
ð 	
rZ   c                 ó`  — t        |«      dk(  sJ ‚t        | j                  |d   «      \  }}t        |«      }t        |dkD  «       | j                  |d   j
                     }	t        t        |	t        j                  «      «       |	j                  dk(  rYd|d<   | j                  |||||«      }
t        |
«       t        dgt        |
j                  d   «      z   «      |
j                  d<   |
S |	j                  dk(  rd|d<   | j                  |||||«      S d|d<   | j                  |||||«      S )Nr:   r   r  rs   r¸   )rx   r   rR  r   rà   rì   r[   r   ri   rô   r  r¹   r  r¦  r	  )rŸ   rŠ  rÕ   r«  rI   rv  rS  rL  r„   rø   rÔ  s              rX   Ú_analyze_op_call_numpy_dstackz+ArrayAnalysis._analyze_op_call_numpy_dstack  s)  € Ü�4‹y˜AŠ~Ðˆ~Ü% d§l¡l°D¸±GÓ<‰ˆˆRÜ�‹HˆÜ��A‘ŒØ�l‰l˜3˜q™6Ÿ;™;Ñ'ˆÜ”
˜3¤× 5Ñ 5Ó6Ô7Ø�8‰8�qŠ=ØˆC�‰KØ×6Ñ6Ø�y # t¨SóˆFô �FŒOÜ%*¨A¨3´°f·m±mÀGÑ6LÓ1MÑ+MÓ%NˆF�M‰M˜'Ñ"ØˆMØ�X‰X˜Š]ØˆC�‰KØ×4Ñ4Ø�y # t¨Sóð ð ˆC�‰KØ×:Ñ:Ø�y # t¨Sóð rZ   c                  ó   — y rh   rd   r…  s         rX   Ú_analyze_op_call_numpy_cumsumz+ArrayAnalysis._analyze_op_call_numpy_cumsum  ó   € àrZ   c                  ó   — y rh   rd   r…  s         rX   Ú_analyze_op_call_numpy_cumprodz,ArrayAnalysis._analyze_op_call_numpy_cumprod"  r  rZ   c                 ór   — t        |«      }d}|dkD  r|d   }n	d|v r|d   }t        j                  |f¬«      S )Né2   r¸   Únumrê  r   )rŸ   rŠ  rÕ   r«  rI   rv  r„   r  s           rX   Ú_analyze_op_call_numpy_linspacez-ArrayAnalysis._analyze_op_call_numpy_linspace&  sH   € ô �‹IˆØˆØˆqŠ5Ø�q‘'‰CØ�c‰\Ø�e‘*ˆCÜ×*Ñ*°#°Ð*Ó8Ð8rZ   c           
      ó  — t        |«      }|dk\  sJ ‚|d   j                  }t        t        |D �cg c]  }| j	                  |j
                  «      ‘Œ c}«      «       |D �cg c]  }| j                  |j
                     ‘Œ }}|D �	cg c]  }	|	j                  ‘Œ }
}	t        t        d„ |
D «       «      «       |
d   dk(  r	|
d   dk(  ry |D �cg c]  }|j                  |«      ‘Œ }}|
d   dk(  rQ| j                  ||||d   d   |d   d   g«      }t        j                  t        |d   dd |d   dd  z   «      |¬«      S |
d   dk(  rH| j                  ||||d   d   |d   d   g«      }t        j                  t        |d   dd «      |¬«      S |
d   dk(  rO|
d   dk(  rG| j                  ||||d   d   |d   d   g«      }t        j                  |d   d   |d   d   f|¬«      S |
d   dkD  r	 y c c}w c c}w c c}	w c c}w )Nr¸   r   c              3   ó&   K  — | ]	  }|d kD  –— Œ y­w)r   Nrd   rK  s     rX   rn   z;ArrayAnalysis._analyze_op_call_numpy_dot.<locals>.<genexpr>8  s   è ø€ Ò(˜a�A˜•EÑ(ùs   ‚r:   éþÿÿÿr   rM  )rx   r«  r   r“   rî  rì   rà   rô   r  r  rk  r§  r¹   )rŸ   rŠ  rÕ   r«  rI   rv  r„   r°   ÚtypsÚtyÚdimsrÜ  r¹  s                rX   Ú_analyze_op_call_numpy_dotz(ArrayAnalysis._analyze_op_call_numpy_dot1  sG  € Ü�‹IˆØ�AŠvˆˆvØ�1‰g�k‰kˆÜ”°DÖ9¨q�T—]‘] 1§6¡6Õ*Ò9Ó:Ô;Ø.2Ö3¨�—‘˜QŸV™VÓ$Ð3ˆÐ3Ø"&Ö'˜B�—“Ð'ˆÐ'Ü”Ñ( 4Ô(Ó(Ô)Ø�‰7�aŠ<˜D ™G qšLØØ37Ö8¨a�)×&Ñ& qÕ)Ð8ˆÐ8Ø�‰7�aŠ<Ø×-Ñ-Ø�s˜I¨¨q©	°!©°f¸Q±iÀ±mÐ'DóˆGô !×.Ñ.Ü˜F 1™I a¨˜O¨f°Q©i¸¸¨nÑ<Ó=Øð /ó ð ð �‰7�aŠ<Ø×-Ñ-Ø�s˜I¨¨q©	°"©°v¸a±yÀ±|Ð'DóˆGô !×.Ñ.Ü˜F 1™I a¨˜OÓ,Øð /ó ð ð �‰7�aŠ<˜D ™G qšLØ×-Ñ-Ø�s˜I¨¨q©	°!©°f¸Q±iÀ±lÐ'CóˆGô !×.Ñ.Ø˜a‘y ‘| V¨A¡Y¨q¡\Ð2Øð /ó ð ð �‰7�QŠ;ØØùòC :ùÚ3ùÚ'ùò 9s   °"G0Á! G5ÂG:ÃG?c                 óJ  — |j                   j                  dd«      }|j                  j                  }t	        |t
        «      r|f}g }	t        |«      dkD  rt        |«      t        |«      k(  sJ ‚t        ||«      D ]O  \  }
}| j                  |j                     }t	        |t        j                  «      sŒ:|
|vsŒ?|	j                  |«       ŒQ t        |	«      }t        |dkD  «       | j                  ||||	«      }|j                  |	d   «      }t         j#                  ||¬«      S )NÚstandard_indexingrd   r   rM  )Úoptionsr¯   Ú	kernel_irr  r[   ró   rx   ry   rà   rì   r   ri   r½   r   r  r  rk  r§  )rŸ   rŠ  rÕ   Ústencil_funcr«  rI   rv  Ústd_idx_arrsÚkernel_arg_namesÚrel_idx_arrsr  r  rø   r„   r¹  rs   s                   rX   ry  zArrayAnalysis._analyze_stencilX  s  € ð $×+Ñ+×/Ñ/Ð0CÀRÓHˆØ'×1Ñ1×;Ñ;ÐÜ�l¤CÔ(Ø(˜?ˆLØˆÜ�4‹y˜1Š}¤ T£¬cÐ2BÓ.CÒ!CÐCÐCÜÐ,¨dÓ3ò 	)‰HˆC�Ø—,‘,˜sŸx™xÑ(ˆCÜ˜#œu×4Ñ4Õ5Ø�|Ò#à×#Ñ# CÕ(ð	)ô �ÓˆÜ��A‘ŒØ×)Ñ)¨%°°iÀÓNˆØ×#Ñ# L°¡OÓ4ˆÜ×*Ñ*°¸GÐ*ÓDÐDrZ   c                 ó€   — t        t        |«      dk\  «       t        j                  |j	                  |d   «      ¬«      S )Nr:   r   rê  )r   rx   rk  r§  r  r…  s         rX   Ú!_analyze_op_call_numpy_linalg_invz/ArrayAnalysis._analyze_op_call_numpy_linalg_invm  s7   € ô 	”�D“	˜Q‘ÔÜ×*Ñ*°×1EÑ1EÀdÈ1ÁgÓ1NÐ*ÓOÐOrZ   c           
      óö  ‡ — t        t        ˆ fd„|«      «      }t        |«      dk(  rû|j                  dk(  rì‰ j                  |d   j
                     }‰ j                  |d   j
                     }|j                  dk(  r(t        j                  |j                  |d   «      ¬«      S |j                  dk(  r(t        j                  |j                  |d   «      ¬«      S 	 |D �	cg c]  }	|j                  |	«      ‘Œ }
}	d|
v ryt        |
d«      }t        j                  |¬«      S t        t        ˆ fd	„|«      «      }t        t        |«      dkD  «       |D �	cg c]  }	|	j
                  ‘Œ }}	|D �	cg c]%  }	‰ j                  |	j
                     j                  ‘Œ' }}	t        |«      }t        |dkD  «       	 |D �	cg c]  }	|j                  |	«      ‘Œ }
}	g }d|
v ryg }t!        |
«      D ]g  \  }}|€O||   }‰ j                  |j
                     }‰ j#                  |||j                  d|«      }|j%                  |«       ŒW|j%                  |«       Œi |}
‰ j'                  ||||
|«      }|r2d|j(                  v r|j(                  d   }ng }||z   |j(                  d<   |S c c}	w # t        $ r Y yw xY wc c}	w c c}	w c c}	w # t        $ r/ t        j                  |d   ‰ j                  ||||«      ¬
«      cY S w xY w)z¶Infer shape equivalence of arguments based on Numpy broadcast rules
        and return shape of output
        https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
        c                 ó:   •— ‰j                  | j                  «      S rh   )Ú_istuplerì   ©rm   rŸ   s    €rX   r¾  z2ArrayAnalysis._analyze_broadcast.<locals>.<lambda>x  ó   ø€  T§]¡]°1·6±6Ó%:€ rZ   r¸   rE   r   r:   rê  Nrd   c                 ó:   •— ‰j                  | j                  «      S rh   )rî  rì   r1  s    €rX   r¾  z2ArrayAnalysis._analyze_broadcast.<locals>.<lambda>”  r2  rZ   rM  r”  )r  rÏ  rx   rÙ   rà   rì   r÷  rk  r§  r  r  r   r   rô   rÆ   r  Ú	enumeraterÉ  r½   rÌ  r¦  )rŸ   rŠ  rÕ   r«  rI   rO  ÚtupsÚtup0typÚtup1typr°   rÜ  Úconcat_shapesÚarrsrï   r"  Úmax_dimr”  Ú
new_shapesr�   Úsr  rø   rs   rÔ  Úprev_pres   `                        rX   re  z ArrayAnalysis._analyze_broadcasts  s  ø€ ô
 ”FÓ:¸DÓAÓBˆäˆt‹9˜Š>˜bŸk™k¨UÒ2ð —l‘l 4¨¡7§<¡<Ñ0ˆGØ—l‘l 4¨¡7§<¡<Ñ0ˆGØ�}‰} Ò!Ü$×2Ñ2Ø#×-Ñ-¨d°1©gÓ6ð 3ó ð ð �}‰} Ò!Ü$×2Ñ2Ø#×-Ñ-¨d°1©gÓ6ð 3ó ð ð	Ø:>Ö?°Q˜)×-Ñ-¨aÕ0Ð?�Ð?Ø˜6‘>ØÜ # F¨B£�Ü$×2Ñ2Ø'ð 3ó ð ô ”FÓ:¸DÓAÓBˆÜ”�D“	˜A‘ÔØ!%Ö&˜A�—“Ð&ˆÐ&Ø37Ö8¨a�—‘˜QŸV™VÑ$×)Ó)Ð8ˆÐ8Ü�d“)ˆÜ�˜!‘Ôð	Ø6:Ö;°�i×)Ñ)¨!Õ,Ð;ˆFÐ;ð ˆØ�6‰>ð ˆJÜ! &Ó)ò 	)‘��1Ø�9Ø˜q™'�CØŸ,™, s§x¡xÑ0�CØ ×0Ñ0Ø! 3¨¯©°$¸ó�Eð ×%Ñ% eÕ,à×%Ñ% aÕ(ð	)ð  ˆFà×.Ñ.Ø�9˜c 6¨5ó
ˆñ ð ˜Ÿ™Ñ%Ø!Ÿ=™=¨Ñ/‘à�Ø#&¨¡>ˆF�M‰M˜%Ñ Øˆùòi @øô "ò Ùðüò 'ùÚ8ùò <øÜò 	Ü ×.Ñ.Ø˜1‘gØ×+Ñ+¨E°3¸	À4ÓHð /ó ò ð	úsZ   ÃJ" Ã"JÃ:J" Ä!J" ÅJ1Å/*J6Æ5K  Æ9J;ÇK  ÊJ" Ê"	J.Ê-J.Ê;K  Ë 5K8Ë7K8c           
      ó–  — g }g }t        |D �cg c]  }t        |«      ‘Œ c}«      }	d}
t        |	«      D ]Ü  }g }g }t        ||«      D ]c  \  }}|t        |«      k  sŒ|t        |«      dz
  |z
     }|j	                  |«      }|dk(  r|}
ŒB|j                  |«       |j                  |«       Œe |g k(  r&|
€J ‚|j                  |
«       |j                  d«       |j                  | j                  |||||¬«      «       |j                  |d   «       ŒÞ t        j                  t        t        |«      «      t        |g «      ¬«      S c c}w )z„Produce assert_equiv for sizes in each dimension, taking into
        account of dimension coercion and constant size of 1.
        Nr:   Ú1©rï   r   rM  )rÆ   rx   r‹   ry   rÊ   r½   r  rk  r§  r¹   rÆ  r  )rŸ   rŠ  rÕ   r«  rÜ  rï   r¹  r  rs   r:  Úconst_size_oner�   r  Ú
size_namesrì   rM   Ú
const_sizes                    rX   rÌ  z&ArrayAnalysis._broadcast_assert_shapes¿  s^  € ð ˆØˆ	Ü¨vÖ6 e”s˜5•zÒ6Ó7ˆØˆÜ�w“ò 	'ˆAØˆEØˆJÜ" 5¨&Ó1ò 0‘��eØ”s˜5“z“>Ø ¤ U£¨a¡°!Ñ!3Ñ4�DØ!*×!:Ñ!:¸4Ó!@�JØ! Q’Ø)-™àŸ™ TÔ*Ø"×)Ñ)¨$Õ/ð0ð ˜Š{Ø%Ð1Ð1Ð1Ø—‘˜^Ô,Ø×!Ñ! #Ô&Ø�N‰NØ×'Ñ'Ø˜3 	¨5¸
ð (ó ôð
 ×Ñ˜U 1™XÕ&ð+	'ô, ×*Ñ*Üœ Ó+Ó,Ü�G˜RÓ ð +ó 
ð 	
ùò1 7s   ŽEc                 ól   — | j                  |||||¬«      }t        |«      dkD  r |j                  |Ž  |S )Nr@  r:   )r±  rx   rÐ   )rŸ   rŠ  r«  rÕ   rI   rï   Úinstss          rX   r  z ArrayAnalysis._call_assert_equivâ  sD   € Ø×'Ñ'Ø�3˜	 4¨uð (ó 
ˆô ˆt‹9�qŠ=Ø"ˆI×"Ñ" DÑ)ØˆrZ   c           
      óh  — t         j                  dk\  rt        d||«       |€|D �cg c]  }|j                  ‘Œ }}g }g }t	        ||«      D ]™  \  }	}t         j                  dk\  rt        d|	|«       d}
|D ]H  }t         j                  dk\  rt        d||j                  ||«      «       |j                  ||«      sŒFd}
 n |
rŒx|j                  |«       |j                  |	«       Œ› t        |«      dk  r t         j                  dk\  rt        d«       g S dj                  d	j                  |«      |«      }t        j                  ||«      }t        j                  |«      }t        j                  |t        d
«      |«      }|| j                   |j                  <   t#        |g|D �cg c]  }| j                   |j                     ‘Œ c}z   «      }t        j$                  j'                  |«      }t        j                  |t        d«      |«      }t        j(                  dt*        |¬«      }t-        t*        «      }| j.                  j1                  ||fi «      }| j3                  ||||«       t        j                  |t        d«      |«      }t        j4                  j7                  ||g|z   i |¬«      }| j3                  ||t        j8                  |«       || j:                  |<   t        j<                  |||¬«      t        j<                  |||¬«      t        j<                  |||¬«      gS c c}w c c}w )Nr¸   zmake_assert_equiv:zname, x:Fzis equiv to?Tz@Will not insert assert_equiv as args are known to be equivalent.zSizes of {} do not match on {}z, rˆ   Úassertr˜   r
  rÉ  rú  )r   r»   r¼   rì   ry   rÇ   r½   rx   rª   Újoinr   rõ   r   r”   rò   r   rà   r¹   r’   Ú
from_typesrÂ  r˜   r   rF   r+  r¢  rK  rG  r–   rm  r²  )rŸ   rŠ  r«  rÕ   Ú_argsrï   r°   rI   r  rì   Úseenr?  rˆ   Úmsg_valÚmsg_typÚmsg_varÚargtypsÚtup_typÚ
assert_varÚ
assert_defr8  rH   r  rö   s                           rX   r±  z ArrayAnalysis._make_assert_equivê  sÉ  € ä×!Ñ! QÒ&ÜÐ&¨¨uÔ5Øˆ=Ø%*Ö+ �Q—V“VÐ+ˆEÐ+ØˆØˆ	Ü˜5 %Ó(ò 	'‰GˆD�!Ü×%Ñ%¨Ò*Ü�j $¨Ô*ØˆDØò �Ü×)Ñ)¨QÒ.Ü˜.¨!¨Y×-?Ñ-?ÀÀ1Ó-EÔFØ×%Ñ% a¨Õ+Ø�DÙðò Ø—‘˜A”Ø× Ñ  Õ&ð	'ô ˆt‹9�qŠ=Ü×%Ñ%¨Ò*Üð"ôð ˆIà.×5Ñ5Ø�I‰I�iÓ  #ó
ˆô —(‘(˜3 Ó$ˆÜ×%Ñ% cÓ*ˆÜ—&‘&˜¤¨eÓ 4°cÓ:ˆØ%,ˆ�‰�W—\‘\Ñ"Ü˜˜	À4Ö$H¸a T§\¡\°!·&±&Ó%9Ò$HÑHÓIˆô ×$Ñ$×/Ñ/°Ó8ˆô —V‘V˜E¤=°Ó#:¸CÓ@ˆ
Ü—Y‘Y˜~¬|ÀÔEˆ
Ü"¤<Ó0ˆØ�l‰l×0Ñ0°¸°zÀ2ÓFˆØ�‰�Y 
¨D°*Ô=ô �f‰f�UœM¨%Ó0°#Ó6ˆÜ—‘—‘˜Z¨'¨°TÑ)9¸2À3�ÓGˆØ�‰�Y ¤U§Z¡Z°Ô7Ø #ˆ�‰�uÑô �I‰I˜G¨G¸Ô=Ü�I‰I˜J¨z¸sÔCÜ�I‰I˜E¨#°3Ô7ð
ð 	
ùòg ,ùòB %Is   §L*Æ& L/
c           
      óò  — t        |t        j                  «      r|j                  |«      }t        |t        j                  «      r|}d }d }nÇt        |t        j                  «      r|}d }d }n¦t        j
                  j                  |d|j                  «      }t        j                  |j                  t        dj                  |j                  «      «      |j                  «      }t        j                  j                  t        j                  |«      }g }	d}
|rt!        |«      }||k  r|||z
  d  }t#        |«      D �]d  }d}|�rl||   �rft        ||   t        j                  «      rO| j$                  ||   j                     }t        |t        j&                  t        j(                  f«      �r||   }d}nút        ||   t*        «      r$t        j,                  ||   |j                  «      }n||   }t        |t        j,                  «      sJ ‚t        j                  |j                  t        dj                  |j                  |«      «      |j                  «      }|j/                  t        j0                  |||j                  «      «       | j3                  ||t        j                  |«       d}|sÝt        j                  |j                  t        dj                  |j                  |«      «      |j                  «      }t        j
                  j5                  ||d |j                  «      }d}
d | j6                  |<   |j/                  t        j0                  |||j                  «      «       | j3                  ||t        j                  |«       |	j/                  «       �Œg |
rG|rE|j9                  dt        j0                  |||j                  «      «       | j3                  |||«       t;        |	«      S )Nrs   z{}_shapeFTz	{}_size{}r   )r[   r   rò   r  rÃ  rK  ræ  r«  rŠ  r   rª   rì   r   rÄ  rÅ  r^   rx   r‹   rà   rW  rk   rÉ   rõ   r½   r²  r¢  Ústatic_getitemrm  r  r¹   )rŸ   rÕ   r  rý   rs   r•  Úattr_varÚshape_attr_callÚshape_attr_typÚ	size_varsÚuse_attr_varÚnshapesr�   Úskiprø   r5  r6  Úgetitems                     rX   rÉ  zArrayAnalysis._gen_shape_call(  s  € ä�eœRŸV™VÔ$Ø×'Ñ'¨Ó.ˆEô �eœRŸV™VÔ$ØˆHØ"ˆOØ‰EÜ˜œrŸv™vÔ&ØˆHØ"ˆOØ‰Eä Ÿg™gŸo™o¨c°7¸C¿G¹GÓDˆOÜ—v‘vØ—	‘	œ=¨×):Ñ):¸3¿8¹8Ó)DÓEÀsÇwÁwóˆHô #×-Ñ-×6Ñ6´u·z±zÀ5ÓIˆNØˆ	ØˆáÜ˜%“jˆGØ�wŠØ˜w¨™Ð1Ð2�Ü�u“ó "	'ˆAØˆDÚ˜˜q›Ü˜e A™h¬¯©Ô/ØŸ,™, u¨Q¡x§}¡}Ñ5�CÜ! #¬¯©´e·o±oÐ'FÕGØ#(¨¡8˜Ø#™ä! %¨¡(¬CÔ0Ü#%§8¡8¨E°!©H°c·g±gÓ#>™à#(¨¡8˜Ü% h´·±Ô9Ð9Ð9Ü!Ÿv™vØŸ	™	Ü% k×&8Ñ&8¸¿¹À1Ó&EÓFØŸ™ó �Hð
 —K‘K¤§	¡	¨(°H¸c¿g¹gÓ FÔGØ—L‘L ¨H´e·j±jÀ(ÔKØ�DÙäŸ6™6Ø—I‘IÜ! +×"4Ñ"4°S·X±X¸qÓ"AÓBØ—G‘Gó�ô
 Ÿ'™'×0Ñ0°¸1¸dÀCÇGÁGÓL�Ø#�Ø*.�—‘˜wÑ'Ø—‘œBŸI™I g¨x¸¿¹ÓAÔBØ—‘˜Y¨´%·*±*¸gÔFØ×Ñ˜XÖ&ðE"	'ñF ™Oà�K‰K˜œ2Ÿ9™9 _°hÀÇÁÓHÔIØ�L‰L˜ H¨n¸oÔNÜ�YÓÐrZ   c                 óŠ   — | j                   |   }t        |t        j                  j                  «      xr |j
                  dkD  S rc   )rà   r[   r   ÚnpytypesÚArrayrô   ©rŸ   Úvarnamerø   s      rX   rî  zArrayAnalysis._isarrayl  s4   € Ø�l‰l˜7Ñ#ˆÜ˜#œuŸ~™~×3Ñ3Ó4ÒE¸¿¹ÀA¹ÐErZ   c                 óT   — | j                   |   }t        |t        j                  «      S rh   )rà   r[   r   rj   r`  s      rX   r0  zArrayAnalysis._istuplep  s!   € Ø�l‰l˜7Ñ#ˆÜ˜#œuŸ™Ó/Ð/rZ   c                 óL   — d}|D ]  }|j                  |«      }|€ y||z  }Œ |S )zzReturn the sum of the given list of sizes if they are all equivalent
        to some constant, or None otherwise.
        r   N)rÊ   )rŸ   rÕ   r  r<  rM   r„   s         rX   r  zArrayAnalysis._sum_sizet  s@   € ð ˆØò 	ˆDØ×)Ñ)¨$Ó/ˆAØˆyÙà�Q‘‘ð	ð ˆrZ   rd  )Ústatic_literal_slice_partrh   )crÙ   rÚ   rÛ   r‚  r    rÎ   rz  rˆ  rƒ  rŒ  r‹  r„  r¢  Úobjectr§  r™  rÀ  rñ  rõ  rø  r   r  r  r  rh  rË  r]  r_  rb  rf  ri  rl  rq  r€  r‚  r†  r‹  r�  r’  r•  r—  r™  r�  r¡  r¤  r¦  rª  r­  r¯  r²  r´  r¶  r¸  rÄ  rï  rË  rÍ  rÐ  rÓ  rÖ  rØ  rÚ  rÜ  rÞ  rà  râ  rä  ræ  rè  rê  rí  rï  rñ  ró  rõ  r÷  rù  rû  rý  r   r	  r  r  r  r  r  r  r  r#  ry  r-  re  rÌ  r  r±  rÉ  rî  r0  r  rd   rZ   rX   rk  rk  4  s  „ Ø€Hðò&ò",ò

%ó0:òd	BòòB"òH3ò
=ô!˜ô !òHòT6òò@=òð  )óLò:ò2ò>[
òzG9òRXEòtòò$ò
ò
ò
ò
Dò:=ò~Iòòò>
ò
ò

ò
ò

ò
9ò 9òò*
òò KòKò
Kò
Kò
Kò
Kò
HMòT=ò&ò
òò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò
ò4
òlPò4ò"
òò4òò	9ò%òNEò*PòJòX!
óFó<
ò|B òHFò0órZ   rk  )Brt  rP  Ú
numba.corer   r   r   r   r   Únumba.core.ir_utilsr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   Únumba.core.analysisr   Únumba.core.typingr   r   r¦   Únumba.core.extendingr   rA   ÚUNKNOWN_CLASSÚCONST_CLASSÚufuncÚ	MAP_TYPESrÓ  Úarray_creationÚrandom_int_argsÚrandom_1arg_sizeÚrandom_2arg_sizelastÚrandom_3arg_sizelastÚrandom_callsra   re   r˜   re  rš   rÞ   r/  rf  rk  r  ÚNumpyRulesUnaryArrayOperatorÚ_op_mapÚkeysrÏ  ra  ÚNumpyRulesArrayOperatorrd  ÚNumpyRulesInplaceArrayOperatorrh  Úsupported_ufuncsrÙ   r|  )r2   s   0rX   ú<module>r{     s¶  ðó Û ß 9Õ 9÷÷ ÷ ÷ ñ õ" 8ß 0Û Ý *Û à€Ø€Ø�[‰[ˆM€	àÐ ò 4€à˜7Ð#€òÐ òÐ ò	Ð ð Øñàñð ñð �,Ðñ	 ð ð ñ,5ó ð,5ò^
ð ñ=0ó ð=0ô@Vˆvô Vôrz*�Hô z*ôzkE�}ô kEô\	!�Fô !ôBK!�Fô K!ñ\B �G×8Ñ8×@Ñ@×EÑEÓGÓHØ‡L�LðLñ €ð ×/Ñ/×7Ñ7×<Ñ<Ó>€Ø×>Ñ>×FÑF×KÑKÓMÐ Ø$+×$<Ñ$<Ö=˜q�—
“
Ò=�ùÒ=s   Å$E;