Ë
    L²j`Ñ  ã                  óX  — d dl mZ d dlZd dlZd dlZd dlmZmZmZm	Z	 erd dl
mZmZ d dlZd dlmZmZmZ ddlmZmZmZ ddlmZ dd	lmZ dd
lmZ dZdZd adWd„ZdXd„Z dYdZd„Z!	 d[	 	 	 	 	 d\d„Z" G d„ d«      Z#dYd]d„Z$	 d[	 	 	 	 	 d^d„Z% G d„ de&«      Z' G d„ de&«      Z(ddl)m*Z* d_d„Z+ G d„ d«      Z,e,ejZ                  fZ. G d„ de,«      Z/ G d„ de,«      Z-d`dad „Z0dYdbd!„Z1dcd"„Z2 G d#„ d$«      Z3ddd%„Z4ded&„Z5dfd'„Z6d d(l7m8Z8 d d)l9m:Z:  e:e,ejZ                  e,jv                  «       e,`<dgd*„Z=dhd+„Z> e>d,«        e>d-«        e>d.«        e>d/«        e>d0«        e>d1«        e>d2«        e>d3«        e>d4«        e>d5«        e>d6«        e>d7«        e>d8d9¬:«        e>d;d9¬:«        e>d<d¬=«        e>d>d¬=«        e>d?d¬=«        e>d@d¬=«        e>dAd¬=«        e>dBd¬=«        e>dCd¬=«        e>dDd¬=«        e>dEdF¬G«        e>dHdF¬G«        e>dId¬=«        e>dJddF¬K«        e>dLddF¬M«        e>dNddF¬M«        e>dOddF¬M«        e>dPddF¬M«        e>dQddF¬M«        e>dRddF¬M«        e>dSddF¬M«        e>dTdddF¬U«        e>dVddF¬M«        e8ej~                  j€                  j‚                  ddF¬M«      ZAy)ié    )ÚannotationsN)ÚAnyÚOptionalÚTYPE_CHECKINGÚUnion)ÚCallableÚSequence)Útree_flattenÚtree_mapÚtree_unflattené   )Ú_match_levelsÚDimEntryÚndim_of_levels)ÚEnableAllLayers)Ú_PyInstDecoder)Ú
TensorInfoTc                ó>   — t        | xr | j                  d«      «      S )z4Check if opcode is relevant for variable assignment.ÚSTORE_)ÚboolÚ
startswith)Úopcodes    úU/var/www/html/ia-enhanced/venv/lib/python3.12/site-packages/functorch/dim/__init__.pyÚ_relevant_opr      s   € ä�Ò6˜6×,Ñ,¨XÓ6Ó7Ð7ó    c                ó   — | S )z8Handle tensor conversion for torch function integration.© )Útensors    r   Úhandle_from_tensorr   !   s   € à€Mr   ÚDimc                ó*   — t        | |�|«      S d«      S )zCreate a new Dim object.éÿÿÿÿ)r    )ÚnameÚsizes     r   Ú_create_dimr%   &   s   € äˆt˜TÐ-�TÓ6Ð6°2Ó6Ð6r   c                óL  ‡‡	‡
— d}dŠ
‰�t        ‰«      }| �| }t        j                  «       }|€t        d«      ‚|j                  }	 |€t        d«      ‚|j
                  }|j                  }t        ||«      Š	t        j                  dk\  r#‰	j                  «       dk(  r‰	j                  «        ‰	j                  «        t        ‰	j                  «       «      rdŠ
n3‰	j                  «       dk(  r ‰	j                  «       Š
‰	j                  «        |dk(  r‰
dk(  rt        d	«      ‚‰
}‰
|k7  rdŠ
dˆ	ˆ
ˆfd
„}‰�(t        ‰«      |k7  rt        d|› dt        ‰«      › �«      ‚|dk(  r	 |d«      ~S g }t!        |«      D ]  }|j#                   ||«      «       Œ t%        |«      ~S # ~w xY w)a·  
    Create and return one or more Dim objects.

    Uses bytecode inspection to determine variable names when possible.

    Args:
        n (int, optional): The number of dimensions to create. Can be omitted if sizes is specified.
        sizes (List[Optional[int]], optional): A list the same size as the number of dimensions to be
          created, specifying each dimensions size, or None to leave the size unset.

    Returns:
        Union[Dim, Tuple[Dim, ...]]: Single Dim if n=1, tuple of Dims otherwise.

    Examples:
        >>> batch, channel, width, height = dims(4)
        >>> batch, channel, width, height = dims(sizes=[None, 3, 224, 224])
        >>> single_dim = dims(1)
    r"   r   úUnable to get current frameúUnable to get caller frame©é   é   ÚPRECALLr   ÚUNPACK_SEQUENCEzTdims() must be assigned to a sequence of variable names or have argument n specifiedc                ó�   •— d }| ‰k  r‰j                  «       }|sd| › �}dŠn‰j                  «        ‰�‰|    nd }t        ||«      S ©NÚdr   )r#   Únextr%   )Úir#   r$   ÚdecoderÚfound_ndimsÚsizess      €€€r   Ú	genobjectzdims.<locals>.genobjectn   sS   ø€ àˆDØ�;ŠØ—|‘|“~�áØ˜1˜#�w�Ø‘à—‘”à$Ð0�5˜’8°dˆDÜ˜t TÓ*Ð*r   ú	expected ú sizes but found )r2   ÚintÚreturnr    )ÚlenÚinspectÚcurrentframeÚRuntimeErrorÚf_backÚf_codeÚf_lastir   ÚsysÚversion_infor   r1   r   ÚopargÚSyntaxErrorÚ
ValueErrorÚrangeÚappendÚtuple)Únr5   Úspecified_ndimsÚframeÚcodeÚlastir6   Úresultr2   r3   r4   s    `       @@r   ÚdimsrP   +   s®  ú€ ð* €OØ€Kð ÐÜ˜e›*ˆØ€}Øˆô × Ñ Ó"€EØ€}ÜÐ8Ó9Ð9Ø�L‰L€Eð=Øˆ=ÜÐ;Ó<Ð<Ø�|‰|ˆØ—‘ˆä   uÓ-ˆä×Ñ˜wÒ&Ø�~‰~Ó 9Ò,Ø—‘”ð 	�‰Œô ˜Ÿ™Ó(Ô)Ø‰KØ�^‰^ÓÐ!2Ò2Ø!Ÿ-™-›/ˆKØ�L‰LŒNà˜bÒ Ø˜aÒÜ!Øjóð ð *ˆOà˜/Ò)ØˆK÷	+ð  Ð¤ U£¨Ò!>Ü˜y¨Ð(9Ð9JÌ3ÈuË:È,ÐWÓXÐXà˜aÒÙ˜Q“<ñ ð ˆÜ�Ó'ò 	(ˆAØ�M‰M™) A›,Õ'ð	(ô �V‹}ñ ø‰Eús   ÁD"F  Å+3F  Æ F#c                  óÐ   — e Zd ZU dZded<   ded<   ded<   	 	 d	 	 	 dd	„Zdd
„Zdd„Zdd„Zdd„Z	dd„Z
dd„Zedd„«       Zdd„Zdd„Zdd„Zdd„Ze	 	 d 	 	 	 	 	 	 	 	 	 d!d„«       Zy)"ÚDimLista(  
    A list of first-class dimensions that can be bound to tensor dimensions.

    A DimList can be in one of two states:
    1. Unbound: Created with just a name, no specific dimensions yet
    2. Bound: Either created with specific dimensions/sizes, or bound later via bind() or bind_len()
    ú
str | NoneÚ_namez	list[Dim]Ú_dimsr   Ú_boundNc                ó’  — || _         g | _        d| _        t        |t        «      r| j                  |«       y|�Žg }t        |«      D ]l  \  }}t        |t        «      r=| j                   r| j                   › |› �nd|› �}|j                  t        ||«      «       ŒS|j                  t        |«      «       Œn | j                  |«       yy)zÇ
        Initialize a new DimList object.

        Args:
            len_or_dims: Optional length (int) or sequence of dimensions/sizes
            name: Optional name for the dimension list
        FNÚdim)
rT   rU   rV   Ú
isinstancer9   Úbind_lenÚ	enumeraterH   r    Ú	_set_dims)ÚselfÚlen_or_dimsr#   rP   r2   ÚitemÚdim_names          r   Ú__init__zDimList.__init__›   s²   € ð ˆŒ
ØˆŒ
ØˆŒä�k¤3Ô'Ø�M‰M˜+Õ&ØÐ$ØˆDÜ$ [Ó1ò +‘��4Ü˜d¤CÔ(Ø59·Z²Z $§*¡* ¨a¨SÑ1ÀsÈ1È#ÀY�HØ—K‘K¤ H¨dÓ 3Õ4à—K‘K¤ D£	Õ*ð+ð �N‰N˜4Õ ð %r   c                ó    — d| _         || _        y)z%Set the dimensions and mark as bound.TN)rV   rU   )r]   rP   s     r   r\   zDimList._set_dims¸   s   € àˆŒØˆ�
r   c                ó\  — | j                   r=t        | j                  «      |k7  r$t        dt        | j                  «      › d|› �«      ‚yd| _         g | _        t	        |«      D ]G  }| j
                  r| j
                  › |› �nd|› �}| j                  j                  t        |«      «       ŒI y)zÐ
        Bind this DimList to a specific length.

        Args:
            size: Number of dimensions to bind to

        Raises:
            DimensionBindError: If already bound to a different size
        zDimlist has size z but it is being bound to size TrX   N)rV   r;   rU   ÚDimensionBindErrorrG   rT   rH   r    )r]   r$   r2   r`   s       r   rZ   zDimList.bind_len½   s¢   € ð �;Š;Ü�4—:‘:‹ $Ò&Ü(Ø'¬¨D¯J©J«Ð'8Ð8WÐX\ÐW]Ð^óð ð 'ð
 ˆDŒKØˆDŒJÜ˜4“[ò 1�Ø15·²˜dŸj™j˜\¨!¨Ñ-À3ÀqÀcÀ�Ø—
‘
×!Ñ!¤# h£-Õ0ñ1r   c                óâ   — t        |d«      rt        |d«      st        d«      ‚t        |«      }| j                  |«       t	        |«      D ]"  \  }}t        |«      | j                  |   _        Œ$ y)zÁ
        Bind this DimList to specific sizes.

        Args:
            sizes: Sequence of sizes for each dimension

        Raises:
            ValueError: If sizes is not a sequence
        Ú__len__Ú__getitem__zexpected a sequenceN)ÚhasattrrF   r;   rZ   r[   r9   rU   r$   )r]   r5   r$   r2   Údim_sizes        r   ÚbindzDimList.bindÓ   sd   € ô �u˜iÔ(´¸¸}Ô0MÜÐ2Ó3Ð3ä�5‹zˆØ�‰�dÔä$ UÓ+ò 	/‰KˆAˆxÜ!$ X£ˆD�J‰J�q‰MÕñ	/r   c                óZ   — | j                   st        d«      ‚t        | j                  «      S )NúDimList not bound)rV   rd   r;   rU   ©r]   s    r   Ú_sizezDimList._sizeæ   s#   € Ø�{Š{Ü$Ð%8Ó9Ð9Ü�4—:‘:‹Ðr   c                ó"   — | j                  «       S )z7Return the size (number of dimensions) of this DimList.©rn   rm   s    r   r$   zDimList.sizeë   s   € à�z‰z‹|Ðr   c                ó   — || _         y)z(Set the bound status (for internal use).N©rV   )r]   Úbs     r   Ú
_set_boundzDimList._set_boundï   s	   € àˆ�r   c                ó   — | j                   S )z&Property to check if DimList is bound.rr   rm   s    r   Úis_boundzDimList.is_boundó   s   € ð �{‰{Ðr   c                ó"   — | j                  «       S )z!Return the length of the DimList.)r$   rm   s    r   rf   zDimList.__len__ø   s   € à�y‰y‹{Ðr   c                ó¾  — | j                   st        d«      ‚t        |t        «      r7|dk  s|t	        | j
                  «      k\  rt        d«      ‚| j
                  |   S t        |t        «      re|j                  t	        | j
                  «      «      \  }}}g }t        |||«      D ]   }|j                  | j
                  |   «       Œ" t        |«      S t        d«      ‚)Nrl   r   zindex out of boundszexpected an int or a slice)rV   rd   rY   r9   r;   rU   Ú
IndexErrorÚsliceÚindicesrG   rH   rI   rF   )r]   ÚkeyÚstartÚstopÚsteprO   r2   s          r   rg   zDimList.__getitem__ü   s½   € Ø�{Š{Ü$Ð%8Ó9Ð9ä�cœ3ÔØ�QŠw˜#¤ T§Z¡Z£Ò0Ü Ð!6Ó7Ð7Ø—:‘:˜c‘?Ð"Ü˜œUÔ#Ø #§¡¬C°·
±
«OÓ <ÑˆE�4˜ØˆFÜ˜5 $¨Ó-ò -�Ø—‘˜dŸj™j¨™mÕ,ð-ä˜“=Ð äÐ9Ó:Ð:r   c                óž   — | j                   r&ddj                  d„ | j                  D «       «      › d�S | j                  �d| j                  › �S y)ú,Return string representation of the DimList.ú(z, c              3  ó2   K  — | ]  }t        |«      –— Œ y ­w©N)Úrepr)Ú.0rX   s     r   ú	<genexpr>z#DimList.__repr__.<locals>.<genexpr>  s   è ø€ Ò A¨s¤ c§Ñ Aùs   ‚ú)Ú*z<unbound_dimlist>)rV   ÚjoinrU   rT   rm   s    r   Ú__repr__zDimList.__repr__  sL   € à�;Š;à�t—y‘yÑ A°d·j±jÔ AÓAÐBÀ!ÐDÐDØ�Z‰ZÐ#à�t—z‘z�lÐ#Ð#ð 'r   c                ó"   — | j                  «       S )r�   )r‹   rm   s    r   Ú__str__zDimList.__str__  s   € à�}‰}‹Ðr   c                ó2   — t         j                  ||||«      S r„   )Ú_TensorÚ__torch_function__)ÚclsÚfuncÚtypesÚargsÚkwargss        r   r�   zDimList.__torch_function__  s   € ô ×)Ñ)¨$°°t¸VÓDÐDr   ©NN)r^   zint | Sequence | Noner#   rS   )rP   Úlistr:   ÚNone)r$   r9   r:   r˜   )r5   zSequence[int]r:   r˜   ©r:   r9   )rs   r   r:   r˜   ©r:   r   )r|   zint | slicer:   úDim | tuple[Dim, ...]©r:   Ústr©r   N©
r’   r   r“   rI   r”   rI   r•   zdict | Noner:   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__ra   r\   rZ   rj   rn   r$   rt   Úpropertyrv   rf   rg   r‹   r�   Úclassmethodr�   r   r   r   rR   rR   Ž   sÒ   … ñð ÓØÓØƒLð .2Øð!à*ð!ð ó!ó:ó
1ó,/ó&ó
óð òó ðóó;ó"
'óð ð
 Ø"ðEàðEð ðEð ð	Eð
 ðEð 
òEó ñEr   rR   c                óð   — t        | ¬«      }|�gt        |t        «      r|j                  |«       |S |j                  t	        |«      «       t        |«      D ]  \  }}|€Œ	||j                  |   _        Œ |S )z>Create a DimList object with the given name and optional size.)r#   )rR   rY   r9   rZ   r;   r[   rU   r$   )r#   r$   Údimlistr2   Úss        r   Ú_create_dimlistrª   (  sy   € ä˜4Ô €GØÐÜ�dœCÔ Ø×Ñ˜TÔ"ð €Nð	 ×ÑœS ›YÔ'Ü! $›ò .‘��1Ø‘=Ø,-�G—M‘M !Ñ$Õ)ð.ð €Nr   c                ó¢  ‡‡— d}dŠ|�t        |«      }| �| }t        j                  «       }|€t        d«      ‚|j                  }	 |€t        d«      ‚|j
                  }|j                  }t        ||«      Št        j                  dk\  r#‰j                  «       dk(  r‰j                  «        ‰j                  «        t        ‰j                  «       «      rdŠn3‰j                  «       d	k(  r ‰j                  «       Š‰j                  «        |dk(  r‰dk(  rt        d
«      ‚‰}‰|k7  rdŠdˆˆfd„}|�(t        |«      |k7  rt        d|› dt        |«      › �«      ‚|dk(  r! |d«      }t!        ||�
|d   «      ~S d«      ~S g }t#        |«      D ].  }	 ||	«      }|�||	   nd}
|j%                  t!        ||
«      «       Œ0 t'        |«      ~S # ~w xY w)zt
    Create and return one or more DimList objects.

    Similar to dims() but creates DimList objects instead.
    r"   r   Nr'   r(   r)   r,   r   r-   zXdimlists() must be assigned to a sequence of variable names or have argument n specifiedc                ól   •— d }| ‰k  r‰j                  «       }|s	d| › �}dŠ|S ‰j                  «        |S r/   )r#   r1   )r2   r#   r3   r4   s     €€r   r6   zdimlists.<locals>.genobjectm  sD   ø€ àˆDØ�;ŠØ—|‘|“~�áØ˜1˜#�w�Ø�ð ˆKð —‘”àˆKr   r7   r8   )r2   r9   r:   r�   )r;   r<   r=   r>   r?   r@   rA   r   rB   rC   r   r1   r   rD   rE   rF   rª   rG   rH   rI   )rJ   r5   rK   rL   rM   rN   r6   r#   rO   r2   r$   r3   r4   s              @@r   Údimlistsr­   7  sï  ù€ ð €OØ€Kð ÐÜ˜e›*ˆØ€}Øˆä× Ñ Ó"€EØ€}ÜÐ8Ó9Ð9Ø�L‰L€EðAØˆ=ÜÐ;Ó<Ð<Ø�|‰|ˆØ—‘ˆä   uÓ-ˆä×Ñ˜wÒ&Ø�~‰~Ó 9Ò,Ø—‘”ð 	�‰Œô ˜Ÿ™Ó(Ô)Ø‰KØ�^‰^ÓÐ!2Ò2Ø!Ÿ-™-›/ˆKØ�L‰LŒNà˜bÒ Ø˜aÒÜ!Ønóð ð *ˆOà˜/Ò)ØˆKö	ð Ð¤ U£¨Ò!>Ü˜y¨Ð(9Ð9JÌ3ÈuË:È,ÐWÓXÐXð ˜aÒÙ˜Q“<ˆDÜ" 4°UÐ5F¨¨q©ÓQñ ð MQÓQñ ð ˆÜ�Ó'ò 	7ˆAÙ˜Q“<ˆDØ$Ð0�5˜’8°dˆDØ�M‰Mœ/¨$°Ó5Õ6ð	7ô
 �V‹}ñ ø‰Eús   ÁD2G Å:G ÆAG ÇGc                  ó   — e Zd Zy)ÚDimensionMismatchErrorN©r    r¡   r¢   r   r   r   r¯   r¯   �  ó   „ Ør   r¯   c                  ó   — e Zd Zy)rd   Nr°   r   r   r   rd   rd   ”  r±   r   rd   )Úop_propertiesc                 ó  — ddl }g }| D ]g  }t        |d«      r?dt        t        |«      «      v r)|j	                  dt        |«      j
                  › d�«       ŒN|j	                  t        |«      «       Œi t        |i |¤d|j                  i¤Ž y)z;Safe print that avoids recursive torch function dispatches.r   NÚ	__class__Útorchú<ú>Úfile)rB   rh   r�   ÚtyperH   r    ÚprintÚstderr)r”   r•   rB   Ú	safe_argsÚargs        r   Ú_safe_printr¿   ›  s€   € ãð €IØò 'ˆÜ�3˜Ô$¨´C¼¸S»	³NÑ)BØ×Ñ˜q¤ c£×!3Ñ!3Ð 4°AÐ6Õ7à×ÑœS ›XÕ&ð	'ô 
ˆ9Ð0˜Ñ0 S§Z¡ZÔ0r   c                  óÄ   — e Zd Zdd„Zdd„Zedd„«       Zedd„«       Zdd„Ze		 	 d	 	 	 	 	 	 	 	 	 dd„«       Z
e	 	 	 	 	 	 	 	 	 	 dd„«       Zdd	„Zdd
„Z	 	 	 	 	 	 dd„Zdd„Zy)r�   c                ó   — t        d«      ‚)Nz+_get_levels must be implemented by subclass©ÚNotImplementedErrorrm   s    r   Ú_get_levelsz_Tensor._get_levels«  ó   € Ü!Ð"OÓPÐPr   c                ó   — t        d«      ‚)Nz+_get_tensor must be implemented by subclassrÂ   rm   s    r   Ú_get_tensorz_Tensor._get_tensor®  rÅ   r   c                ó   — t        d«      ‚)Nz$ndim must be implemented by subclassrÂ   rm   s    r   Úndimz_Tensor.ndim±  s   € ä!Ð"HÓIÐIr   c                óB   — t        d„ | j                  «       D «       «      S )Nc              3  ó^   K  — | ]%  }|j                  «       rŒ|j                  «       –— Œ' y ­wr„   )Úis_positionalrX   ©r†   Úls     r   r‡   z_Tensor.dims.<locals>.<genexpr>·  s   è ø€ ÒR ÀÇÁÕ@Q�Q—U‘U—WÑRùs   ‚-˜-)rI   rÄ   rm   s    r   rP   z_Tensor.dimsµ  s   € äÑR d×&6Ñ&6Ó&8ÔRÓRÐRr   c                ó   — | j                   S r„   )rÉ   rm   s    r   rX   z_Tensor.dim¹  s   € Ø�y‰yÐr   Nc                ó†  — |€i }t         �r»|t        j                  j                  u �ržt	        |«      dk(  �r�|�sŒt        |d   t        t        j                  f«      �rht        |d   t        t        j                  f«      �rDt        j                  |d   dd¬«      }t        j                  |d   dd¬«      }|�r|�r|j                  �ü|j                  �ð|j                  j                  «       dk(  rÓ|j                  j                  «       dk(  r¶|j                  j                  «       rœ|j                  j                  «       r‚|j                  xs |j                  }g }|j                  D ]  }	|	|vsŒ|j                  |	«       Œ |j                  D ]  }	|	|vsŒ|j                  |	«       Œ t        j                  ||||«      S |t        j                  j                   u rddlm}
  |
| ||||«      S |t        j                  j&                  u r?ddlm} t	        |«      dk(  r ||d   |d   |d   «       y t+        d	t	        |«      › �«      ‚|t        j                  j,                  u r|d   j/                  d«      S |t        j0                  u rt1        |i |¤ŽS |t        j2                  u rt3        |i |¤ŽS |t        j                  j4                  u sJ|t        j6                  j4                  u s.|t        j6                  j8                  u s|t        j4                  u rt5        |i |¤ŽS t        j;                  ||||«      S )
Né   r   r   F©Úensure_batchedÚensure_present)Úgetitem©Úsetitemr*   z%Expected 3 args for __setitem__, got )ÚDOT_OPTIMIZEDr¶   ÚTensorÚ__mul__r;   rY   r�   r   Úcreater   rX   Úis_floating_pointÚ
has_deviceÚlevelsrH   Úcreate_delayedrg   Úfunctorch.dim._getsetitemrÕ   Ú__setitem__r×   rF   rf   r$   ÚsoftmaxÚstackÚsplitÚ_VFÚsplit_with_sizesÚ_torch_function_fallback)r‘   r’   r“   r”   r•   Úlhs_infoÚrhs_inforÝ   rÞ   ÚlevelrÕ   r×   s               r   r�   z_Tensor.__torch_function__¼  sÏ  € ð ˆ>ØˆFæ˜T¤U§\¡\×%9Ñ%9Ò9ô �D“	˜Q“ÚÜ˜t A™w¬´%·,±,Ð(?Õ@Ü˜t A™w¬´%·,±,Ð(?Õ@ô &×,Ñ,Ø˜‘G¨EÀ%ô�ô &×,Ñ,Ø˜‘G¨EÀ%ô�ò
 Ú Ø Ÿ™Ð3Ø Ÿ™Ð3Ø Ÿ™×+Ñ+Ó-°Ò2Ø Ÿ™×+Ñ+Ó-°Ò2ð !Ÿ™×9Ñ9Ô;Ø$ŸO™O×=Ñ=Ô?ð &.×%8Ñ%8Ò%O¸H×<OÑ<O˜
Ø!#˜à%-§_¡_ò 5˜EØ$¨FÒ2Ø &§¡¨eÕ 4ð5ð &.§_¡_ò 5˜EØ$¨FÒ2Ø &§¡¨eÕ 4ð5ô  &×4Ñ4°T¸4ÀÈÓTÐTà”5—<‘<×+Ñ+Ñ+Ý9á˜3  e¨T°6Ó:Ð:à”5—<‘<×+Ñ+Ñ+Ý9ô �4‹y˜AŠ~Ù˜˜Q™  a¡¨$¨q©'Ô2Øä Ð#HÌÈTËÈÐ!TÓUÐUð ”5—<‘<×'Ñ'Ñ'Ø˜‘7—<‘< “?Ð"ð ”5—=‘=Ñ Ü˜DÐ+ FÑ+Ð+ð ”5—;‘;ÑÜ˜$Ð) &Ñ)Ð)ð ”E—L‘L×&Ñ&Ñ&Ø”u—y‘y—‘Ñ&Ø”u—y‘y×1Ñ1Ñ1Ø”u—{‘{Ñ"ä˜$Ð) &Ñ)Ð)ä×/Ñ/°°e¸TÀ6ÓJÐJr   c                óV  ‡‡‡— t         xr | t        j                  v }t        ||f«      \  }}dŠg }g Š|D ]¯  }t	        j
                  || d«      }	|j                  |	«       |	sŒ/|s|	j                  €t        d«      ‚‰€|	j                  r|	j                  Š|	j                  D ]?  }
t        |
t        «      st        dt        |
«      › �«      ‚|
‰vsŒ/‰j                  |
«       ŒA Œ± |rÉt        |«      D ]o  \  }}	|	sŒ	|	j                  €Œ|	j                  }‰�'|	j                  s|j!                  ‰j"                  «      }t%        ||	j                  ‰«      }t'        |«      ||<   Œq t)        ||«      \  }} | |i |¤Ž}dˆˆfd„}t        |t*        j,                  «      r ||«      S t/        ||«      S t1        ‰«      5 Št        |«      D ]t  \  }}	|	sŒ	|	j                  €Œ|	j                  }‰�'|	j                  s|j!                  ‰j"                  «      }‰j3                  ||	j                  «       t'        |«      ||<   Œv t)        ||«      \  }} | |i |¤Ž}dˆˆfd„}t        |t*        j,                  «      r ||«      cddd«       S t/        ||«      cddd«       S # 1 sw Y   yxY w)zGFallback torch function implementation for non-special-cased functions.NFz-Expected pointwise or batchedtensor to be setzExpected DimEntry, got c                ón   •— t        | t        j                  «      rt        j                  | ‰‰d u«      S | S r„   )rY   r¶   rÙ   Úfrom_positional)ÚobjÚdevice_holding_tensorÚresult_levelss    €€r   Úwrap_tensorz5_Tensor._torch_function_fallback.<locals>.wrap_tensorE  s8   ø€ Ü˜c¤5§<¡<Ô0Ü!×1Ñ1Ø˜]Ð,AÈÐ,Móð ð �
r   c                ód   •— t        | t        j                  «      r‰j                  | ‰d u«      S | S r„   )rY   r¶   rÙ   Úfrom_batched)rî   rï   Úguards    €€r   Úunwrap_tensorz7_Tensor._torch_function_fallback.<locals>.unwrap_tensora  s0   ø€ Ü˜c¤5§<¡<Ô0Ø ×-Ñ-¨cÐ3HÐPTÐ3TÓUÐUØ�
r   )rî   r   r:   r   )ÚPOINTWISE_OPTIMIZEr³   Ú	pointwiser
   r   rÛ   rH   ÚbatchedtensorÚAssertionErrorrÝ   r   rÞ   rY   r   rº   r[   ÚtoÚdevicer   r   r   r¶   rÙ   r   r   Úinplace_update_layers)r’   r“   r”   r•   Úis_pointwiseÚ	flat_argsÚspecÚinfosÚfÚinforê   r2   r   ÚmlÚunflat_argsÚunflat_kwargsrO   rñ   Úbatchedrõ   rï   rô   rð   s                       @@@r   rç   z _Tensor._torch_function_fallback  s�  ú€ ô
 *ÒM¨d´m×6MÑ6MÐ.Mˆä&¨¨f ~Ó6‰ˆ	�4Ø $Ðà"$ˆØ(*ˆàò 	4ˆAÜ×$Ñ$ Q¨LÐ(8¸%Ó@ˆDØ�L‰L˜ÔÚÙ$¨×(:Ñ(:Ð(FÜ(ØGóð ð )Ð0°T·_²_Ø,0¯K©KÐ)à!Ÿ[™[ò 4�EÜ% e¬XÔ6Ü,Ð/FÄtÈEÃ{ÀmÐ-TÓUÐUØ MÒ1Ø%×,Ñ,¨UÕ3ñ	4ð	4ñ" ä$ UÓ+ò :‘��4Ú˜DŸK™KÑ3Ø!Ÿ[™[�FØ,Ð8ÀÇÂØ!'§¡Ð+@×+GÑ+GÓ!H˜Ü& v¨t¯{©{¸MÓJ�BÜ#5°bÓ#9�I˜a’Lð:ô *8¸	À4Ó)HÑ&ˆK˜Ù˜;Ð8¨-Ñ8ˆFöô ˜&¤%§,¡,Ô/Ù" 6Ó*Ð*ä ¨VÓ4Ð4ô ˜]Ó+ð 	7¨uä$ UÓ+ò ?‘��4Ú˜D×.Ñ.Ñ:Ø"×0Ñ0�GØ,Ð8ÀÇÂØ")§*¡*Ð-B×-IÑ-IÓ"J˜Ø×/Ñ/°¸¿¹ÔEÜ#5°gÓ#>�I˜a’Lð?ô *8¸	À4Ó)HÑ&ˆK˜Ù˜;Ð8¨-Ñ8ˆFöô
 ˜&¤%§,¡,Ô/Ù$ VÓ,÷)	7ñ 	7ô,   ¨vÓ6÷-	7÷ 	7ò 	7ús   Æ>JÇJÇ B JÊ
JÊJ(c                ó"   — ddl m}  || ||«      S )z2Set values in tensor using first-class dimensions.r   rÖ   )rà   r×   )r]   ÚindexÚvaluer×   s       r   rá   z_Tensor.__setitem__k  s   € å5á�t˜U EÓ*Ð*r   c                óf  — t        j                  | dd¬«      }|D ]™  }t        |t        «      rŒt        | t        j
                  «      r2t        | t        «      s"t	        j
                  j                  | g|¢­Ž c S | j                  t        j
                  j                  t        | «      f| f|z   «      c S  |s9| j                  t        j
                  j                  t        | «      f| f|z   «      S |j                  }|€9| j                  t        j
                  j                  t        | «      f| f|z   «      S |j                  }g }g }g }|D ]º  }	|D ]4  }
|
j                  «       rŒ|
j                  «       |	u sŒ't        d|	› d�«      ‚ |D ]4  }|j                  «       rŒ|j                  «       |	u sŒ't        d|	› d�«      ‚ |j                  t!        |	«      «       |j                  |	j"                  «       |j                  d«       Œ¼ |j%                  |«       t'        |j#                  «       «      }t'        |j)                  «       «      }|j%                  |«       |j%                  |«       |j+                  |||j-                  «       «      }t
        j/                  |||j0                  «      }|S )aq  
        Expand tensor by adding new dimensions or expanding existing dimensions.

        If all arguments are Dim objects, adds new named dimensions.
        Otherwise, falls back to regular tensor expansion behavior.

        Args:
            args: Either Dim objects for new dimensions or sizes for regular expansion

        Returns:
            New tensor with expanded dimensions

        Example:
            >>> i, j = dims()
            >>> t = torch.randn(3, 4)
            >>> expanded = t[i].expand(j, k)  # Add j, k dimensions
            >>> expanded2 = t[i].expand(2, 4)  # Regular expand with sizes
        FrÒ   zexpanding dimension z# already exists in tensor with dimsr   )r   rÛ   rY   r    r¶   rÙ   r�   Úexpandr�   rº   r   rÞ   rÌ   rX   rd   rH   r   r$   Úextendr—   ÚstrideÚ
as_stridedÚstorage_offsetrí   rÝ   )r]   r”   r  r¾   ÚdatarÞ   Ú
new_levelsÚ	new_sizesÚnew_stridesr0   rê   Ú	new_levelÚ
orig_sizesÚorig_stridesÚexpanded_datarO   s                   r   r  z_Tensor.expandt  st  € ô& × Ñ  °eÈEÔRˆàò 	ˆCÜ˜c¤3Õ'ä˜d¤E§L¡LÔ1¼*ÀTÌ7Ô:SÜ Ÿ<™<×.Ñ.¨tÐ;°dÒ;Ò;à×2Ñ2ÜŸ™×+Ñ+¬d°4«j¨]¸T¸GÀd¹Nóò ð	ñ à×*Ñ*Ü—‘×#Ñ#¤d¨4£j ]°T°G¸d±Nóð ð
 �{‰{ˆØˆ<à×*Ñ*Ü—‘×#Ñ#¤d¨4£j ]°T°G¸d±Nóð ð —‘ˆà%'ˆ
Øˆ	Øˆàò 	"ˆAàò �Ø×*Ñ*Õ,°·±³ÀÒ1AÜ,Ø.¨q¨cÐ1TÐUóð ðð
 (ò �	Ø ×.Ñ.Õ0°Y·]±]³_ÈÒ5IÜ,Ø.¨q¨cÐ1TÐUóð ðð ×Ñœh q›kÔ*Ø×Ñ˜QŸV™VÔ$Ø×Ñ˜qÕ!ð	"ð$ 	×Ñ˜&Ô!ô ˜$Ÿ)™)›+Ó&ˆ
Ü˜DŸK™K›MÓ*ˆØ×Ñ˜Ô$Ø×Ñ˜<Ô(ð Ÿ™¨	°;À×@SÑ@SÓ@UÓVˆô ×'Ñ'¨°zÀ4Ç?Á?ÓSˆØˆr   c                ó¨  ‡ ‡%— ddl m} ddlm}m} ddlmŠ% ddd„}dˆ%ˆ fd„}dˆ fd„}g }	g }
t        |t        t        f«      }t        |t        t        f«      }|rd|rb|}|}t        |«      t        |«      k7  r$t        d	t        |«      › d
t        |«      › d�«      ‚|	j                  |«       |
j                  |«       n"|	j                  |«       |
j                  |«       t        j                  ‰ dd«      }g }g }g }t!        t        |	«      «      D �]—  } ||	|   d¬«      \  }}|�rgt        |«      dk(  r|j                  t#        «       «       Œ? ||d   «      }|j                  |«       t        |«      dk(  rŒjt        |«      dk(  r|j                  |j$                  «       g }t!        dt        |«      «      D ]`  } |||   «      }d}t!        t        |«      «      D ]  }||   |k(  sŒ|j'                  |«       d} n |s ||«       |j                  |«       Œb d}t!        t        |«      «      D ]  }||   |k(  sŒ|} n |€
 ||«       �Œ@t)        |«      D ]  \  }}|j+                  |dz   |z   |«       Œ |j                  |«       �Œ~|j                   ||	|   «      «       �Œš t        |«      dkD  râ|j,                  €t/        d«      ‚ ||j,                  |j$                  |«      }|j1                  «       }g } g }!t!        t        |«      «      D ]e  }||   |v r4t        | «      dk(  r| j                  ||   «       Œ-| dxx   ||   z  cc<   Œ>| j                  ||   «       |!j                  ||   «       Œg |j3                  | «      |_        |!|_        d}"|
D ]  }#t        |#t        t        f«      sŒd}" n  ||g ||
|"«      }$ ||$«      S )z<
        Index tensor using first-class dimensions.
        r   )r   )Úgetsetitem_flatÚinvoke_getitem©Ú	_wrap_dimFc                óJ   — t        | t        t        f«      rt        | «      dfS y)NT)NF)rY   rI   r—   )rî   Úcheck_firsts     r   Úmaybe_dimpackz$_Tensor.index.<locals>.maybe_dimpackÚ  s!   € Ü˜#¤¤t˜}Ô-Ü˜C“y $�Ð&Ør   c                ó~   •—  ‰| ‰j                   d«      }|j                  «       rt        dt        | «      › �«      ‚|S )NFz)expected a dimension specifyer but found )rÉ   Úis_noneÚ	TypeErrorr…   )r©   r0   r  r]   s     €€r   Úparse_dim_entryz&_Tensor.index.<locals>.parse_dim_entryß  s;   ø€ Ù˜!˜TŸY™Y¨Ó.ˆAØ�y‰yŒ{ÜÐ"KÌDÐQRËGÈ9Ð UÓVÐVØˆHr   c                óÞ   •— | j                  «       r7t        d| j                  «       ‰j                  z   › d‰j                  › d�«      ‚t        dt	        | j                  «       «      › d�«      ‚)Nú
dimension z not in tensor of z dimensionsz not in tensor)rÌ   r"  ÚpositionrÉ   r…   rX   )r0   r]   s    €r   Údim_not_presentz&_Tensor.index.<locals>.dim_not_presentæ  sb   ø€ Ø�‰Ô ÜØ  §¡£°·	±	Ñ!9Ð :Ð:LÈTÏYÉYÈKÐWbÐcóð ô   *¬T°!·%±%³'«]¨O¸>Ð JÓKÐKr   zdims (z) and indices (z) must have the same length)r  r   TNz2Cannot perform dimension flattening on None tensorr"   )F)rî   r   r  r   r:   ztuple[Any, bool])r©   r   r:   r   )r0   r   r:   r˜   )Ú
_dim_entryr   Ú_getsetitemr  r  Ú_wrapr  rY   rI   r—   r;   r"  r  rH   r   rÛ   rG   r   rÞ   Úpopr[   Úinsertr   rù   r$   Úreshape)&r]   rP   r{   r   r  r  r  r#  r'  Ú	dims_listÚindices_listÚlhs_listÚrhs_listÚdims_seqÚindices_seqÚ	self_infor  Ú
to_flattenÚdims_list_flatr2   ÚmÚ
is_dimpackÚfirstÚrestÚjr0   ÚremovedÚkÚ	first_idxÚrÚ
rearrangedr5   r  Úreshape_levelsÚhas_dimpacksÚidxr  r  s&   `                                    @r   r  z_Tensor.indexÉ  sô  ù€ õ 	.ß@Ý$ô	ö
	õ	Lð &(ˆ	Ø9;ˆä˜d¤U¬D MÓ2ˆÜ˜g¬¬t }Ó5ˆá™àˆHØ!ˆKÜ�8‹}¤ KÓ 0Ò0ÜØœS ›]˜O¨?¼3¸{Ó;KÐ:LÐLgÐhóð ð ×Ñ˜XÔ&Ø×Ñ Õ,à×Ñ˜TÔ"Ø×Ñ Ô(ô ×%Ñ% d¨E°5Ó9ˆ	à "ˆ
Ø "ˆ
Øˆô ”s˜9“~Ó&ó ,	EˆAÙ)¨)°A©,ÀEÔJ‰MˆAˆzÚÜ�q“6˜Q’;Ø"×)Ñ)¬(«*Ô5Øá'¨¨!©Ó-�Ø×%Ñ% eÔ,ä�q“6˜Q’;Øô �z“? aÒ'Ø×%Ñ% i×&6Ñ&6Ô7à�Ü˜q¤# a£&Ó)ò 
#�AÙ'¨¨!©Ó-�AØ#�GÜ"¤3 z£?Ó3ò "˜Ø% a™=¨AÓ-Ø&ŸN™N¨1Ô-Ø&*˜GÙ!ð	"ñ
 #Ù'¨Ô*Ø—K‘K •Nð
#ð !�	Üœs :›Ó/ò �AØ! !‘}¨Ó-Ø$%˜	Ùðð Ð$Ù# EÔ*Ùä% d›Oò <‘D�A�qØ×%Ñ% i°!¡m°aÑ&7¸Õ;ð<à×!Ñ! $Ö'à×%Ñ%¡o°iÀ±lÓ&CÖDðY,	Eô^ ˆz‹?˜QÒØ×ÑÐ'Ü$ØHóð ñ ' y×'7Ñ'7¸×9IÑ9IÈ:ÓVˆJØ—O‘OÓ%ˆEØ#%ˆIØˆNäœ3˜z›?Ó+ò 9�Ø˜a‘= JÑ.Ü˜9“~¨Ò*Ø!×(Ñ(¨¨q©Õ2à! "›¨¨q©Ñ1œà×$Ñ$ U¨1¡XÔ.Ø"×)Ñ)¨*°Q©-Õ8ð9ð  *×1Ñ1°)Ó<ˆIÔØ-ˆIÔð ˆØò 	ˆCÜ˜#¤¤t˜}Õ-Ø#�Ùð	ñ ØØØØØó
ˆñ ˜dÓ#Ð#r   c                ó  — | j                  «       | j                  «       | j                  }}}g }|D ]¦  }t        |d«      r3|j	                  «       r#|j                  |j                  «       |z   «       ŒBt        |d«      r |j                  |j                  «       «       Œnt        |d«      r|j                  |j                  «       Œ–|j                  |«       Œ¨ |› dt        |«      › dt        |j                  «       «      › �S )NrÌ   rX   r  z
with dims=z sizes=)rÇ   rÄ   rÉ   rh   rÌ   rH   r&  rX   r  rI   r$   )r]   r   rÞ   rÉ   Ú	dims_reprrÎ   s         r   r‹   z_Tensor.__repr__b  sØ   € Ø#×/Ñ/Ó1°4×3CÑ3CÓ3EÀtÇyÁy˜�ˆØˆ	Øò 		$ˆAÜ�q˜/Ô*¨q¯©Ô/@à× Ñ  §¡£°Ñ!4Õ5Ü˜˜EÔ"Ø× Ñ  §¡£Õ)Ü˜˜FÔ#Ø× Ñ  §¡Õ(à× Ñ  Õ#ð		$ð �˜¤e¨IÓ&6Ð%7°w¼uÀVÇ[Á[Ã]Ó?SÐ>TÐUÐUr   ©r:   ú	list[Any]©r:   útorch.Tensor | Noner™   )r:   ztuple[Any, ...]rž   rŸ   )
r’   r   r“   rI   r”   rI   r•   Údictr:   r   )r  r   r	  r   r:   r˜   )r”   r    r:   r�   )rP   z3int | Dim | tuple[int | Dim, ...] | list[int | Dim]r{   zfint | slice | torch.Tensor | tuple[int | slice | torch.Tensor, ...] | list[int | slice | torch.Tensor]r:   r�   rœ   )r    r¡   r¢   rÄ   rÇ   r¥   rÉ   rP   rX   r¦   r�   Ústaticmethodrç   rá   r  r  r‹   r   r   r   r�   r�   ª  s  „ óQóQð òJó ðJð òSó ðSóð ð
 Ø"ðZKàðZKð ðZKð ð	ZKð
 ðZKð 
òZKó ðZKðx ðO7ØðO7Ø$ðO7Ø,1ðO7Ø;?ðO7à	òO7ó ðO7ób+óSðjW$àAðW$ð+ðW$ð 
óW$ôrVr   r�   c                  óè   — e Zd ZU ded<   ded<   ded<   ded<   ded<   ddd	„Zedd
„«       Zedd„«       Zedd„«       Z	e	j                  dd„«       Z	edd„«       Zdd„Zdd„Zdd„Zej                   Zy)r    r9   Ú_levelr�   rT   rn   rI  Ú_rangeÚ_batchtensorc                ód   — || _         || _        t        | _        t        dz  ad | _        d | _        y ©Nr   )rT   rn   Ú_n_dims_createdrM  rN  rO  )r]   r#   r©   s      r   ra   zDim.__init__|  s0   € àˆŒ
ØˆŒ
Ü%ˆŒÜ˜1ÑˆØˆŒØ ˆÕr   c                 ó   — yrQ  r   rm   s    r   rÉ   zDim.ndim…  s   € àr   c                ó   — t        |«      | u S r„   ©rº   )r‘   rî   s     r   Úcheck_exactzDim.check_exact‰  s   € ä�C‹y˜CÐÐr   c                ój   — | j                   dk(  rt        d| j                  › d�«      ‚| j                   S )Nr"   r%  z is unbound)rn   rF   rT   rm   s    r   r$   zDim.size�  s0   € à�:‰:˜ÒÜ˜z¨$¯*©*¨°[ÐAÓBÐBØ�z‰zÐr   c                óž   — | j                   dk(  r|| _         y | j                   |k7  r't        dt        | «      › d| j                   › d|› �«      ‚y )Nr"   zDim 'z*' previously bound to a dimension of size z$ cannot bind to a dimension of size )rn   rd   r…   )r]   Úvs     r   r$   zDim.size“  sX   € à�:‰:˜ÒØˆD�JØ�Z‰Z˜1Š_Ü$Øœ˜T›
�|Ð#MÈdÏjÉjÈ\ð Z6Ø67°Sð:óð ð r   c                ó    — | j                   dk7  S )z1Return True if this dimension is bound to a size.r"   rp   rm   s    r   rv   zDim.is_bound�  s   € ð �z‰z˜RÑÐr   c                óz   — | j                   €$t        j                  | j                  «      | _         | j                   S )z 
        Get a tensor representing the range [0, size) for this dimension.

        Returns:
            A 1D tensor with values [0, 1, 2, ..., size-1]
        )rN  r¶   Úaranger$   rm   s    r   Ú
_get_rangezDim._get_range¢  s,   € ð �;‰;ÐÜŸ,™, t§y¡yÓ1ˆDŒKØ�{‰{Ðr   c                óÂ   — | j                   €Ht        j                  j                  j	                  | j                  «       d| j                  «      | _         | j                   S )z•
        Get a batched tensor representation of this dimension.

        Returns:
            A batched tensor created from the range tensor
        r   )rO  r¶   Ú_CÚ
_functorchÚ_add_batch_dimr]  rM  rm   s    r   Ú_get_batchtensorzDim._get_batchtensor­  sM   € ð ×ÑÐ$Ü %§¡× 3Ñ 3× BÑ BØ—‘Ó! 1 d§k¡kó!ˆDÔð × Ñ Ð r   c                ó   — | j                   S )z&String representation of a Dim object.)rT   rm   s    r   r‹   zDim.__repr__º  s   € à�z‰zÐr   N)r"   )r#   r�   r©   r9   r:   r˜   r™   )rî   r   r:   r   )rY  r9   r:   r˜   rš   ©r:   útorch.Tensorrœ   )r    r¡   r¢   r¤   ra   r¥   rÉ   r¦   rV  r$   Úsetterrv   r]  rb  r‹   ÚobjectÚ
__format__r   r   r   r    r    u  s¦   … ØƒKØƒJØƒJØÓØ%Ó%ô!ð òó ðð ò ó ð ð òó ðð
 
‡[�[òó ðð ò ó ð ó	ó!óð ×"Ñ"�Jr   c                  óü   — e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
ed<   ded<   edd„«       Zedd„«       Ze	 	 	 	 	 	 	 	 dd„«       Ze	 	 	 	 	 	 	 	 	 	 dd„«       Z	dd„Z
dd„Zdd„Zdd„Z	 	 	 	 	 	 d d„Zd!d„Zy)"rÙ   rI  Ú_tensorrO  úlist[DimEntry]Ú_levelsr   Ú_has_devicez!Callable[[], torch.Tensor] | NoneÚ_delayedzCallable | NoneÚ_delayed_origztuple | NoneÚ_delayed_argsc                ó:   — t        d„ | j                  D «       «      S )Nc              3  óD   K  — | ]  }|j                  «       rd nd–— Œ y­w)r   r   N)rÌ   rÍ   s     r   r‡   zTensor.ndim.<locals>.<genexpr>Ñ  s   è ø€ ÒG°Q˜Ÿ™Ô)‘1¨qÓ0ÑGùs   ‚ )Úsumrl  rm   s    r   rÉ   zTensor.ndimÏ  s   € äÑG¸$¿,¹,ÔGÓGÐGr   c                ó   — t        |«      | u S r„   rU  )r‘   Úothers     r   rV  zTensor.check_exactÓ  s   € ä�E‹{˜cÐ!Ð!r   c                ó  — d}d}|D ]b  }|j                  «       rK|dk(  s5|dz   |j                  «       k(  st        d|› d|j                  «       › �«      ‚|j                  «       }Œ^|dz  }Œd |dk(  s|dk(  st        d|› �«      ‚|s|S  | «       }||_        ||_        ||_        d|_        d|_        d|_        d|_	        |j                  «       t        |«      k7  r)t        d|j                  «       › d	t        |«      › d
�«      ‚|S )a0  
        Create a functorch Tensor from a regular PyTorch tensor with specified dimension levels.

        This is the primary way to create Tensor objects with first-class dimensions.

        Args:
            tensor: The underlying PyTorch tensor
            levels: List of DimEntry objects specifying the dimension structure
            has_device: Whether the tensor is on a device (not CPU)

        Returns:
            A new Tensor instance with the specified dimensions, or a regular torch.Tensor
            if there are no named dimensions
        r   r   z/Positional dimensions must be consecutive, got z then r"   z0Final positional dimension must be 0 or -1, got NzTensor has z dimensions but z levels provided)rÌ   r&  rù   rj  rl  rm  rO  rn  ro  rp  rX   r;   )r‘   r   rÞ   rÝ   Ú	seen_dimsÚlastrÎ   rO   s           r   rí   zTensor.from_positional×  s3  € ð$ ˆ	Øˆàò 
	ˆAØ�‰Ô à š	 T¨A¡X°·±³Ò%=Ü(ØIÈ$ÈÈvÐVW×V`ÑV`ÓVbÐUcÐdóð ð —z‘z“|‘ð ˜Q‘‘	ð
	ð ˜’	˜T RšZÜ ØBÀ4À&ÐIóð ñ ØˆMñ “ˆØˆŒØˆŒØ'ˆÔØ"ˆÔØˆŒØ#ˆÔØ#ˆÔð �:‰:‹<œ3˜v›;Ò&Ü Ø˜fŸj™j›l˜^Ð+;¼CÀ»K¸=ÐHXÐYóð ð ˆr   c                óˆ   ‡‡—  | «       }d|_         ||_        ||_        d|_        ‰|_        ‰|_        dˆˆfd„}||_        |S )zP
        Create a delayed tensor that defers the operation until later.
        Nc                 óš   •— g } ‰D ]?  }t        |d«      r | j                  |j                  «       «       Œ/| j                  |«       ŒA  ‰| Ž S )NrÇ   )rh   rH   rÇ   )Úunwrapped_argsr¾   r”   Úorigs     €€r   Úevaluate_delayedz/Tensor.create_delayed.<locals>.evaluate_delayed#  sQ   ø€ ØˆNØò /�Ü˜3 Ô.Ø"×)Ñ)¨#¯/©/Ó*;Õ<à"×)Ñ)¨#Õ.ð	/ñ
 ˜Ð(Ð(r   rd  )rj  rl  rm  rO  ro  rp  rn  )r‘   r|  r”   rÞ   rÝ   rO   r}  s    ``    r   rß   zTensor.create_delayed  sM   ù€ ñ “ˆØˆŒØˆŒØ'ˆÔØ"ˆÔØ#ˆÔØ#ˆÔö	)ð +ˆŒàˆr   c                ó¶   — t        | d«      rB| j                  �6| j                  €*| j                  «       | _        d| _        d| _        d| _        | j                  S )zAGet the underlying tensor, handling delayed operations if needed.rn  N)rh   rn  rj  ro  rp  rm   s    r   rÇ   zTensor._get_tensor0  sR   € ô �D˜*Ô%Ø—‘Ð)Ø—‘Ð$ð  Ÿ=™=›?ˆDŒLà ˆDŒMØ!%ˆDÔØ!%ˆDÔØ�|‰|Ðr   c                ó   — | j                   S )zGet the dimension levels.)rl  rm   s    r   rÄ   zTensor._get_levels?  s   € à�|‰|Ðr   c                ó   — | j                   S )z/Get whether this tensor has device information.)rm  rm   s    r   Ú_get_has_devicezTensor._get_has_deviceC  s   € à×ÑÐr   c                ó˜   — | j                   €3| j                  | j                  «       | j                  «       «      | _         | j                   S )zDGet the batched tensor representation, creating it lazily if needed.)rO  Ú_add_batch_dimsrÇ   rÄ   rm   s    r   rb  zTensor._get_batchtensorG  sF   € à×ÑÐ$Ø $× 4Ñ 4Ø× Ñ Ó" D×$4Ñ$4Ó$6ó!ˆDÔð × Ñ Ð r   c                óÔ  — t        |«      }	 d}d}t        d«      }d}d}t        |«      D ]f  \  }}	|	j                  «       rŒ|	j	                  «       s;|	j                  «       j                  |k  r|	j                  «       j                  }|}|}|dz  }Œh |dk(  r|S |€t        d«      ‚t        j                  j                  j                  ||t        |«      «      }t        «       ||<   ŒÝ)Nr"   Úinfr   r   zExpected t to be non-None)r—   Úfloatr[   r!  rÌ   rX   rM  rù   r¶   r_  r`  ra  r9   r   )
r]   ÚtÚlevels_rÞ   Úmin_real_indexÚ	min_indexÚ	min_valuer2   r?  rÎ   s
             r   rƒ  zTensor._add_batch_dimsO  sÝ   € ô �g“ˆàØˆNØˆIÜ˜e›ˆIØˆAØˆAä! &Ó)ò ‘��1Ø—y‘y•{ØŸ?™?Ô,°·±³·±À)Ò1KØ$%§E¡E£G§N¡N˜	Ø$%˜	Ø)*˜Ø˜‘F‘Aðð ˜BŠØ�àˆyÜ$Ð%@ÓAÐAÜ—‘×#Ñ#×2Ñ2°1°iÄÀYÃÓPˆAä%-£ZˆF�>Ñ"ð- r   c                ó$   — ddl m}  || g|¢­Ž }|S )z&Reorder the dimensions of this tensor.r   )Úorder)Ú_orderr�  )r]   rP   r�  rO   s       r   r�  zTensor.orderm  s   € å!á�tÐ#˜dÒ#ˆØˆr   Nr™   )ru  r   r:   r   )r   re  rÞ   rk  rÝ   r   r:   ú_Tensor | torch.Tensor)
r|  r   r”   rI   rÞ   rk  rÝ   r   r:   r�   rH  rF  rš   )r‡  rI  rˆ  rG  r:   rI  )rP   r   r:   r�   )r    r¡   r¢   r¤   r¥   rÉ   r¦   rV  rí   rß   rÇ   rÄ   r�  rb  rƒ  r�  r   r   r   rÙ   rÙ   Æ  sû   … Ø Ó Ø%Ó%ØÓØÓØ/Ó/Ø"Ó"ØÓàòHó ðHð ò"ó ð"ð ð9Ø!ð9Ø+9ð9ØGKð9à	ò9ó ð9ðv ðØðØ#(ðØ2@ðØNRðà	òó ðó8óó ó!ðØ$ðØ/8ðà	óô<r   rÙ   c                ót  — | st        d«      ‚t        |t        «      st        j                  | |¬«      }|S g }g }| D ]R  }t        j                  |dd¬«      }|j                  |«       |j                  D ]  }||vsŒ|j                  |«       Œ ŒT t        | «      |_
        g }	|D ]K  }|j                  €t        d«      ‚t        |j                  |j                  |«      }
|	j                  |
«       ŒM t        |«      }d}|�9t        |t        «      r|dk(  s$dd	lm}  |||d«      }	 |j%                  |«      }|}t        j                  |	|«      }|j)                  |t+        |«      «       t,        j/                  |||r|d   j0                  «      }|S d«      }|S # t         $ r t'        d
|› d�«      d‚w xY w)a$  
    Stack tensors along a new dimension.

    Args:
        tensors: Sequence of tensors to stack
        new_dim: The new Dim to create for stacking
        dim: The dimension position to insert the new dimension (default: 0)

    Returns:
        Stacked tensor with the new dimension
    z-stack expects a non-empty sequence of tensors)rX   FrÒ   Nz*Cannot stack tensors with None tensor datar   r   r  z
Dimension z does not exist in inputsT)rF   rY   r    r¶   rã   r   rÛ   rH   rÞ   r;   r$   r   rù   r   r   r9   r*  r  r  r"  r,  r   rÙ   rí   rÝ   )ÚtensorsÚnew_dimrX   rO   rð   r   r‡  r  rê   ÚinputsÚmatched_tensorrÉ   Úrawdimr  r0   rC  Útensor_results                    r   rã   rã   u  sÜ  € ñ ÜÐHÓIÐIô �gœsÔ#ä—‘˜W¨#Ô.ˆØˆð €MØ€Eàò ,ˆÜ× Ñ  °5ÈÔOˆØ�‰�TÔØ—[‘[ò 	,ˆEØ˜MÒ)Ø×$Ñ$ UÕ+ñ	,ð,ô �w“<€G„Lð €FØò &ˆØ�;‰;ÐÜ Ð!MÓNÐNÜ& t§{¡{°D·K±KÀÓOˆØ�‰�nÕ%ð	&ô ˜-Ó(€DØ€FØ
€¤
¨3´Ô 4¸ÀºÝ$á�c˜4 Ó'ˆð	SØ×%Ñ% aÓ(ˆCð ˆô �[‰[˜ Ó(€Fð ×Ñ˜¤¨'Ó!2Ô3ô ×*Ñ*Ø�±e˜u Q™x×2Ñ2ó€Mð Ðð BFó€Mð Ðøô ò 	SÜ˜j¨¨Ð-FÐGÓHÈdÐRð	Sús   Ä)F ÆF7c           	     ó’  — ddl m} t        |t        «      }t        |t        «      rK|rt        d«      ‚t        j                  t        j                  j                  t        | «      f| |fd|i«      S g }d}d}|D ](  }|j                  |«       t        |t        «      rd}Œ'd}Œ* |rK|rt        d«      ‚t        j                  t        j                  j                  t        | «      f| |fd|i«      S |st        d«      ‚t        j                  | dd¬«      }	|	j                  «       }
|s|
d	k(  rt        d
«      ‚|�
 |||
d«      nt!        |
 «      }d}t#        |	j$                  «      D ]  \  }}||k(  sŒ|} n |€|€d	}t        d|› �«      ‚g }d	}g }t#        |«      D ]W  \  }}|j&                  r$|j                  |j(                  «       ||d   z  }Œ6|j                  d	«       |j                  |«       ŒY |	j*                  €t-        d«      ‚|	j*                  j)                  |«      }|ra||kD  rt        d|› d|› d�«      ‚||z
  }|t/        |«      z   dz
  t/        |«      z  }|D ]"  }t1        ||«      }|||   _        |||<   ||z  }Œ$ n||k7  rt        d|› d|› d�«      ‚|	j*                  j3                  ||«      }g }t5        |	j$                  «      }t#        t7        ||«      «      D ]O  \  }\  }}t!        |«      ||<   |j                  t        j9                  |t5        |«      |	j:                  «      «       ŒQ t=        |«      S )zÇ
    Split tensor along a dimension.

    Can handle both regular integer sizes and Dim objects for split sizes.
    When Dim objects are used, they get bound to the resulting tensor dimensions.
    r   r  zKwhen dim is specified as a Dim object, split sizes must also be dimensions.rX   TFz-split list must be ints or dims but got a mixrÒ   r   z+split expects at least a 1-dimension tensorNz"tensor does not contain dimension r"   z%Cannot get tensor size on None tensorz+sizes of target dimensions add up to more (z) than source dim (rˆ   z#sum of sizes of target dimensions (z) do not match the source dim ()r*  r  rY   r    r9   r"  r�   rç   r¶   rÙ   rä   rº   rH   r   rÛ   rÉ   r   r[   rÞ   rv   r$   r   rù   r;   Úminræ   r—   Úziprí   rÝ   rI   )r   Úsplit_size_or_sectionsrX   r  Údim_is_objectr5   Úall_dimsÚall_intsr_   r4  rÉ   Údim_lrC  r2   rê   r{   Ú
total_sizeÚunboundÚsize_dimÚtensor_sizeÚremaining_sizeÚ
chunk_sizeÚuÚszÚresult_tensorsrO   r  Úresult_tensors                               r   rä   rä   º  s±  € õ !ô ˜s¤CÓ(€Mô Ð(¬#Ô.áÜØ]óð ô ×/Ñ/Ü�L‰L×ÑÜ�&‹\ˆOØÐ+Ð,Ø�CˆLó	
ð 	
ð €EØ€HØ€Hà&ò ˆØ�‰�TÔÜ�dœCÔ Ø‰Hà‰Hðñ áÜØ]óð ô ×/Ñ/Ü�L‰L×ÑÜ�&‹\ˆOØÐ+Ð,Ø�CˆLó	
ð 	
ñ ÜÐGÓHÐHô ×!Ñ! &¸ÈuÔU€IØ�>‰>Ó€Dá˜T QšYÜÐEÓFÐFð ,/¨?‰I�c˜4 Ô'ÄÈ$ÈÃ€Eð €CÜ˜i×.Ñ.Ó/ò ‰ˆˆ5Ø�E‹>ØˆCÙðð
 €{Øˆ;ØˆCÜÐ<¸S¸EÐBÓCÐCð €GØ€JØ€Gä  Ó'ò ‰ˆˆ8Ø×ÒØ�N‰N˜8Ÿ=™=Ô)Ø˜' "™+Ñ%‰Jà�N‰N˜1ÔØ�N‰N˜1Õðð ×ÑÐÜÐDÓEÐEØ×"Ñ"×'Ñ'¨Ó,€Kñ Ø˜Ò#ÜØ=¸j¸\ÐI\Ð]hÐ\iÐijÐkóð ð % zÑ1ˆØ$¤s¨7£|Ñ3°aÑ7¼CÀ»LÑHˆ
Øò 	!ˆAÜ�Z Ó0ˆBØˆE�!‰HŒMØˆG�A‰JØ˜bÑ ‰Nñ		!ð
 
˜
Ò	"ÜØ1°*°Ð=\Ð]hÐ\iÐijÐkó
ð 	
ð
 ×%Ñ%×6Ñ6°wÀÓD€Nð €FÜ�i×&Ñ&Ó'€Jä(1´#°nÀeÓ2LÓ(Mò 
Ñ$ˆÑ$ˆM˜8Ü" 8Ó,ˆ
�3‰Ø�‰Ü×"Ñ"Øœt JÓ/°×1EÑ1Eóõ	
ð
ô �‹=Ðr   c                óV   — t        d«      }t        | ||«      j                  ||g|«      S rQ  )rP   rã   r  )r‘  rX   r’  rJ   s       r   Úcatrª  ;  s+   € ÜˆQ‹€AÜ�˜!˜SÓ!×'Ñ'¨¨C¨°'Ó:Ð:r   c                  ó    — e Zd ZdZdd„Zdd„Zy)ÚDotPartzA
    Helper class for organizing dimensions in dot products.
    c                ó    — g | _         d| _        y rQ  )rP   rŸ  rm   s    r   ra   zDotPart.__init__E  s   € Ø$&ˆŒ	Øˆ�r   c                ó¶   — | j                   j                  |«       |j                  «       s.| xj                  |j	                  «       j
                  z  c_        yy)z#Add a dimension entry to this part.N)rP   rH   rÌ   rŸ  rX   r$   )r]   Ú	dim_entrys     r   rH   zDotPart.appendI  s?   € à�	‰	×Ñ˜Ô#Ø×&Ñ&Ô(Ø�OŠO˜yŸ}™}›×3Ñ3Ñ3ŽOð )r   N)r:   r˜   )r¯  r   r:   r˜   )r    r¡   r¢   r£   ra   rH   r   r   r   r¬  r¬  @  s   „ ñóô4r   r¬  c                óX  — g }d}| D ]7  }t        |j                  «      dk7  rd}|j                  |j                  «       Œ9 |j                  €t	        d«      ‚t        |j                  |j                  |«      }|s|S | D �cg c]  }|j                  ‘Œ }}|j                  |«      S c c}w )zJ
    Prepare tensor for dot product by matching levels and reshaping.
    Fr   Tz)Cannot perform dot product on None tensor)	r;   rP   r  r   r>   r   rÞ   rŸ  r-  )ÚpartsÚtensor_infor  Úneeds_reshapeÚpartrO   Úviews          r   Údot_preparer¶  P  s­   € ð €JØ€Màò %ˆÜˆt�y‰y‹>˜QÒØ ˆMØ×Ñ˜$Ÿ)™)Õ$ð%ð
 ×ÑÐ!ÜÐFÓGÐGÜ˜;×-Ñ-¨{×/AÑ/AÀ:ÓN€FáØˆð ).Ö. ˆD�O‹OÐ.€DÐ.Ø�>‰>˜$ÓÐùò /s   ÂB'c                ó>  — g }d}| D ]7  }t        |j                  «      dk7  rd}|j                  |j                  «       Œ9 |rCg }|D ]+  }|j                  |j	                  «       j
                  «       Œ- |j                  |«      }t        j                  ||d«      }|S )zE
    Finish dot product by reshaping result and creating Tensor.
    Fr   T)	r;   rP   r  rH   rX   r$   r-  rÙ   rí   )r±  r¨  rð   r³  r´  Únew_sizerê   r–  s           r   Ú
dot_finishr¹  h  sŸ   € ð €MØ€Màò (ˆÜˆt�y‰y‹>˜QÒØ ˆMØ×Ñ˜TŸY™YÕ'ð(ñ
 ØˆØ"ò 	.ˆEØ�O‰O˜EŸI™I›K×,Ñ,Õ-ð	.à%×-Ñ-¨hÓ7ˆä×*Ñ*¨=¸-ÈÓN€MØÐr   c                óÊ  ‡‡‡‡‡‡‡— t        j                  | dd¬«      }t        j                  |dd¬«      }|r|st        j                  | |«      S |j                  �|j                  €t        d«      ‚|j                  j                  «       Š|j                  j                  «       Št        «       Št        «       Št        «       Št        «       Šd	ˆˆˆˆˆˆˆfd„}dgt        |j                  «      z  }t        |j                  «      D ]<  \  }}d}	t        |j                  «      D ]  \  }
}||k(  sŒ|
}	d||
<    n  ||||	«       Œ> t        |j                  «      D ]  \  }}||   rŒ ||d|«       Œ t        ‰j                  «      t        ‰«      k7  r2‰D ]-  }||j                  vsŒ||j                  vsŒ!t        d|› �«      ‚ t        ‰j                  «      dk7  rCt        ‰‰‰g|«      }t        ‰‰‰g|«      }t        j                  ||«      }t        ‰‰‰g|«      S t        ‰‰g|«      }t        ‰‰g|«      }t        j                   ||«      }t        ‰‰g|«      S )
zÿ
    Perform dot product between two tensors along specified dimensions.

    Args:
        lhs: Left-hand side tensor
        rhs: Right-hand side tensor
        sum_dims: Dimensions to sum over (contract)

    Returns:
        Result of dot product
    FrÒ   Nz*Cannot perform dot product on None tensorsc                óä   •— | ‰v }|�‰|   nd}|�‰
|   nd}|r‰j                  | «       y|dk(  |dk(  k(  r‰	j                  | «       y|dk7  r‰j                  | «       y‰j                  | «       y)z?Insert dimension into appropriate part based on stride pattern.Nr   )rH   )r0   Úlhs_idxÚrhs_idxÚreducedÚ
lhs_strideÚ
rhs_strideÚlhs_stridesÚlo_dimsÚlr_dimsÚlro_dimsÚrhs_stridesÚro_dimsÚsum_dimss         €€€€€€€r   Ú
insert_dimzdot.<locals>.insert_dimž  sx   ø€ à�x�-ˆØ-4Ð-@�[ Ò)Àaˆ
Ø-4Ð-@�[ Ò)Àaˆ
áØ�N‰N˜1Õà˜a‘ Z°1¡_Ò5Ø—‘ Õ"Ø˜q’Ø—‘˜qÕ!à—‘˜qÕ!r   Tz$summing over non-existent dimension r   )r0   r   r¼  r   r½  r   r:   r˜   )r   rÛ   r¶   Úmatmulr   rù   r  r¬  r;   rÞ   r[   rP   rF   r¶  Úbmmr¹  Úmm)ÚlhsÚrhsrÇ  rè   ré   rÈ  Úrhs_seenr2   Ú	lhs_levelr½  r;  Ú	rhs_levelr0   Ú
lhs_tensorÚ
rhs_tensorrO   rÁ  rÂ  rÃ  rÄ  rÅ  rÆ  s     `             @@@@@@r   ÚdotrÓ  ~  sQ  þ€ ô × Ñ  °UÈ5ÔQ€HÜ× Ñ  °UÈ5ÔQ€Há™ä�|‰|˜C Ó%Ð%à‡�Ð (§/¡/Ð"9ÜÐIÓJÐJà—/‘/×(Ñ(Ó*€KØ—/‘/×(Ñ(Ó*€Kô ‹y€HÜ‹i€GÜ‹i€GÜ‹i€G÷"ó "ð" ˆwœ˜XŸ_™_Ó-Ñ-€Hô " (§/¡/Ó2ò *‰ˆˆ9ØˆÜ% h§o¡oÓ6ò 	‰LˆAˆyØ˜IÓ%Ø�Ø"�˜‘Ùð		ñ 	�9˜a Õ)ð*ô " (§/¡/Ó2ò +‰ˆˆ9Ø˜‹{Ù�y $¨Õ*ð+ô
 ˆ7�<‰<ÓœC ›MÒ)Øò 	MˆAØ˜Ÿ™Ò'¨A°X·_±_Ò,DÜ Ð#GÈÀsÐ!KÓLÐLð	Mô
 ˆ8�=‰=Ó˜QÒä  (¨G°WÐ!=¸xÓHˆ
Ü  (¨G°WÐ!=¸xÓHˆ
Ü—‘˜: zÓ2ˆÜ˜8 W¨gÐ6¸Ó?Ð?ô ! '¨7Ð!3°XÓ>ˆ
Ü  '¨7Ð!3°XÓ>ˆ
Ü—‘˜* jÓ1ˆÜ˜7 GÐ,¨fÓ5Ð5r   )r*  )Ú	wrap_typec                óF  — t        | t        «      rt        j                  | ||«      S t        j                  | dd¬«      }|j
                  €t        d«      ‚t        j                  |j
                  |j                  |j                  «      }t        j                  |||«      S )a�  
    Index a regular tensor by binding specified positions to dims.

    This converts a regular tensor to a first-class tensor by binding
    the specified positional dimensions to Dim objects.

    Args:
        positions: Tuple of dimension positions to bind
        dims: Dim objects or tuple of Dim objects to bind to

    Returns:
        First-class tensor with specified dimensions bound
    FrÒ   zCannot index None tensor)rY   r�   r  r   rÛ   r   rù   rÙ   rí   rÞ   rÝ   )r]   Ú	positionsrP   r  rO   s        r   r  r  Þ  s„   € ô �$œÔ Ü�}‰}˜T 9¨dÓ3Ð3ô ×Ñ˜T°%ÈÔN€Dð ‡{�{ÐÜÐ7Ó8Ð8Ü×#Ñ# D§K¡K°·±¸d¿o¹oÓN€Fô �=‰=˜ ¨DÓ1Ð1r   c           	     ót   — t        t        j                  | «      }t        t        | t        |g|¢­i |¤Ž«       y r„   )Úgetattrr¶   rÙ   Úsetattrr�   r*  )r#   r”   r•   r|  s       r   Ú_defrÚ  ý  s-   € Ü”5—<‘< Ó&€DÜŒG�Tœ5 Ð7¨Ò7°Ñ7Õ8r   Úmeanrs  ÚallÚamaxÚaminÚaminmaxÚanyÚcount_nonzeroÚ	logsumexpÚnanmeanÚnansumÚprodÚstdrÑ   )Úkeepdim_offsetÚvarÚmax)Ú
single_dimr˜  ÚargmaxÚargminÚkthvalueÚmedianÚ	nanmedianÚmodeÚsortF)ÚreduceÚargsortÚunbindÚchunk)Ú
dim_offsetrò  Úcummax)rê  rò  ÚcumminÚcumprodÚcumprod_ÚcumsumÚcumsum_ÚlogcumsumexpÚrenorm)rö  rê  rò  râ   )r   rS   r:   r   )r   re  r:   re  r„   )r#   r�   r$   ú
int | Noner:   r    r–   )rJ   rÿ  r5   úlist[int | None] | Noner:   r›   )r#   r�   r$   zint | list[int | None] | Noner:   rR   )rJ   rÿ  r5   r   r:   zDimList | tuple[DimList, ...])r”   r   r•   r   r:   r˜   )r   )r‘  r   r’  r   rX   r9   r:   r�   )r   r   rš  r   rX   r   r:   rI   )r‘  r   rX   r   r’  r   r:   r�   )r±  úlist[DotPart]r²  r   r:   re  )r±  r  r¨  re  r:   rÙ   )rÌ  r   rÍ  r   rÇ  r   r:   r�  )r]   r   rÖ  r   rP   r   r:   r�   )r#   r�   r”   r   r•   r   r:   r˜   )BÚ
__future__r   Údisr<   rB   Útypingr   r   r   r   Úcollections.abcr   r	   r¶   Útorch.utils._pytreer
   r   r   r(  r   r   r   Ú_enable_all_layersr   Ú_py_inst_decoderr   Ú_tensor_infor   rö   rØ   rR  r   r   r%   rP   rR   rª   r­   Ú	Exceptionr¯   rd   Ú r³   r¿   r�   rÙ   Ú
TensorLiker    rã   rä   rª  r¬  r¶  r¹  rÓ  Úfunctorch.dim._wrapr*  Úfunctorch.dim.wrap_typerÔ  r�   rÉ   r  rÚ  ÚnnÚ
functionalrâ   r   r   r   ú<module>r     sì  ðÝ "ã 
Û Û 
ß 6Ó 6ñ ß2ã ß FÑ Fç ?Ñ ?Ý /Ý ,Ý $ð Ð Ø€ð €ó8ó
ô
7ð <@ð`Øð`Ø!8ð`àó`÷FWEñ WEôtð  <@ðVØðVØ!8ðVà"óVôr	˜Yô 	ô	˜ô 	õ ó1÷EVñ EVðP �u—|‘|Ð$€
ôK#ˆ'ô K#ôblˆWô lô^BôJ~óB;÷
4ñ 4ó  ó0ó,U6õp &Ý -ñ 
ˆ'�5—<‘< ×!;Ñ!;Ô <Ø€Ló2ó>9ñ
 €V„Ù €U„Ù €U„Ù €V„Ù €V„Ù €Y„Ù €U„Ù €_Ô Ù €[Ô Ù €Y„Ù €X„Ù €V„Ù €U˜1Õ Ù €U˜1Õ Ù €U�tÕ Ù €U�tÕ Ù €X˜$Õ Ù €X˜$Õ Ù €Z˜DÕ !Ù €X˜$Õ Ù €[˜TÕ "Ù €V˜Õ Ù €V�EÕ Ù €Y�uÕ Ù €X˜$Õ Ù €W˜ 5Õ )Ù €X˜$ uÕ -Ù €X˜$ uÕ -Ù €Y˜4¨Õ .Ù €Z˜D¨Õ /Ù €X˜$ uÕ -Ù €Y˜4¨Õ .Ù €^ ¨UÕ 3Ù €X˜!¨°UÕ ;Ù €Y˜4¨Õ .Ù
�—‘×#Ñ#×+Ñ+¸ÀUÔ
K�r   