Ë
    ¤ehWš  ã                  ó¸  — d dl mZ d dlmZmZ d dlmZ d dlZd dlm	Z	 d dl
mZmZmZmZmZmZ d dlZd dlmZmZ d dlmZ d d	lmZ d d
lmZ d dlmZm Z m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.c m/Z0 d dl1m2Z2 d dl3m.c m4c m5Z6 d dl3m7Z7m8Z8 d dl9m:Z: erd dl;m<Z<m=Z=m>Z>m?Z?m@Z@  eAd «      ZB ej†                  ejˆ                  «      ZE G d„ de7«      ZFy)é    )Úannotations)ÚHashableÚIterator)Ú	timedeltaN)Ú	getsizeof)ÚTYPE_CHECKINGÚAnyÚCallableÚLiteralÚcastÚoverload)ÚindexÚlib)Úunique_deltas)Ú
no_default)Úfunction)Úcache_readonlyÚdeprecate_nonkeyword_argumentsÚdoc)Úensure_platform_intÚensure_python_intÚis_floatÚ
is_integerÚ	is_scalarÚis_signed_integer_dtype)ÚABCTimedeltaIndex)Úops)Úextract_array)ÚIndexÚmaybe_extract_name)Úunpack_zerodim_and_defer)ÚAxisÚDtypeÚ
NaPositionÚSelfÚnptc                  óÖ  ‡ — e Zd ZU dZdZedfZded<   ded<   edLd„«       Z		 	 	 	 	 	 dM	 	 	 	 	 	 	 dNd	„Z
edOdPd
„«       Ze	 dQ	 	 	 	 	 dRd„«       ZedSd„«       ZedTd„«       ZedUd„«       ZdVd„Zd„ Zd„ ZdWd„ZedXd„«       ZedXd„«       ZedXd„«       ZedXd„«       ZdYdZd„Zed[d„«       Zed\d„«       Zed\d„«       Zed\d„«       Zd]d„Zed^d„«       Z  e!e"jF                  «      dXd„«       Z#	 	 	 d_	 	 	 	 	 	 	 d`ˆ fd„Z$ed\d „«       Z%dad!„Z& e!e"jN                  «      dbd"„«       Z' e!e"jP                  «      e)fdcd#„«       Z(ddd$„Z* e!e"jV                  «      dedfd%„«       Z+dgd&„Z,dhdid'„Z-dhdid(„Z.djd)„Z/	 	 dk	 	 	 	 	 dld*„Z0dmˆ fd+„Z1e2d,d,d,d,d-œ	 	 	 	 	 	 	 	 	 dnd.„«       Z3e2d,d,d,d/œ	 	 	 	 	 	 	 	 	 dod0„«       Z3e2d,d,d,d,d-œ	 	 	 	 	 	 	 	 	 dpd1„«       Z3 e4d2d3gd4¬5«      	 	 	 	 dq	 	 	 	 	 	 	 	 	 dpˆ fd6„«       Z3dYdrˆ fd7„Z5dsd8„Z6dtd9„Z7dud:„Z8dvˆ fd;„Z9dQˆ fd<„	Z:	 dO	 dwˆ fd=„Z;dxˆ fd>„Z<dyˆ fd?„Z=dzˆ fd@„Z>dXdA„Z?edXdB„«       Z@ˆ fdC„ZAd{dD„ZB eCdE«      ˆ fdF„«       ZDd\dG„ZEd\dH„ZFˆ fdI„ZGˆ fdJ„ZH	 	 	 d|	 	 	 	 	 d}dK„ZIˆ xZJS )~Ú
RangeIndexaL  
    Immutable Index implementing a monotonic integer range.

    RangeIndex is a memory-saving special case of an Index limited to representing
    monotonic ranges with a 64-bit dtype. Using RangeIndex may in some instances
    improve computing speed.

    This is the default index type used
    by DataFrame and Series when no explicit index is provided by the user.

    Parameters
    ----------
    start : int (default: 0), range, or other RangeIndex instance
        If int and "stop" is not given, interpreted as "stop" instead.
    stop : int (default: 0)
    step : int (default: 1)
    dtype : np.int64
        Unused, accepted for homogeneity with other index types.
    copy : bool, default False
        Unused, accepted for homogeneity with other index types.
    name : object, optional
        Name to be stored in the index.

    Attributes
    ----------
    start
    stop
    step

    Methods
    -------
    from_range

    See Also
    --------
    Index : The base pandas Index type.

    Examples
    --------
    >>> list(pd.RangeIndex(5))
    [0, 1, 2, 3, 4]

    >>> list(pd.RangeIndex(-2, 4))
    [-2, -1, 0, 1, 2, 3]

    >>> list(pd.RangeIndex(0, 10, 2))
    [0, 2, 4, 6, 8]

    >>> list(pd.RangeIndex(2, -10, -3))
    [2, -1, -4, -7]

    >>> list(pd.RangeIndex(0))
    []

    >>> list(pd.RangeIndex(1, 0))
    []
    Ú
rangeindexzsigned integerÚrangeÚ_rangeú
np.ndarrayÚ_valuesc                ó"   — t         j                  S ©N)ÚlibindexÚInt64Engine©Úselfs    úW/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/indexes/range.pyÚ_engine_typezRangeIndex._engine_type‚   s   € ä×#Ñ#Ð#ó    c                óÄ  — | j                  |«       t        ||| «      }t        || «      r|j                  |¬«      S t        |t        «      r| j                  ||¬«      S t        j                  |||«      rt        d«      ‚|�t        |«      nd}|€d|}}nt        |«      }|�t        |«      nd}|dk(  rt        d«      ‚t	        |||«      }| j                  ||¬«      S )N©Únamez,RangeIndex(...) must be called with integersr   é   zStep must not be zero)Ú_validate_dtyper    Ú
isinstanceÚcopyr*   Ú_simple_newÚcomÚall_noneÚ	TypeErrorr   Ú
ValueError)ÚclsÚstartÚstopÚstepÚdtyper=   r9   Úrngs           r4   Ú__new__zRangeIndex.__new__‰   sè   € ð 	×Ñ˜EÔ"Ü! $¨¨sÓ3ˆô �e˜SÔ!Ø—:‘: 4�:Ó(Ð(Ü˜œuÔ%Ø—?‘? 5¨t�?Ó4Ð4ô �<‰<˜˜t TÔ*ÜÐJÓKÐKà,1Ð,=Ô! %Ô(À1ˆàˆ<Ø˜U�4‰Eä$ TÓ*ˆDà*.Ð*:Ô  Ô&ÀˆØ�1Š9ÜÐ4Ó5Ð5ä�E˜4 Ó&ˆØ�‰˜s¨ˆÓ.Ð.r6   c                ó²   — t        |t        «      s$t        | j                  › dt	        |«      › d�«      ‚| j                  |«       | j                  ||¬«      S )af  
        Create :class:`pandas.RangeIndex` from a ``range`` object.

        Returns
        -------
        RangeIndex

        Examples
        --------
        >>> pd.RangeIndex.from_range(range(5))
        RangeIndex(start=0, stop=5, step=1)

        >>> pd.RangeIndex.from_range(range(2, -10, -3))
        RangeIndex(start=2, stop=-10, step=-3)
        z7(...) must be called with object coercible to a range, z was passedr8   )r<   r*   rA   Ú__name__Úreprr;   r>   )rC   Údatar9   rG   s       r4   Ú
from_rangezRangeIndex.from_range­   s\   € ô" ˜$¤Ô&ÜØ—<‘<�.ð !Ü˜t›*˜ [ð2óð ð 	×Ñ˜EÔ"Ø�‰˜t¨$ˆÓ/Ð/r6   c                ó¬   — t         j                  | «      }t        |t        «      sJ ‚||_        ||_        i |_        |j                  «        d |_        |S r/   )	ÚobjectrI   r<   r*   r+   Ú_nameÚ_cacheÚ_reset_identityÚ_references)rC   Úvaluesr9   Úresults       r4   r>   zRangeIndex._simple_newÉ   sP   € ô —‘ Ó$ˆä˜&¤%Ô(Ð(Ð(àˆŒØˆŒØˆŒØ×ÑÔ Ø!ˆÔØˆr6   c                óZ   — |€y | j                   \  }} ||«      st        d|› d|› �«      ‚y )Nz#Incorrect `dtype` passed: expected z, received )Ú_dtype_validation_metadatarB   )rC   rG   Úvalidation_funcÚexpecteds       r4   r;   zRangeIndex._validate_dtypeØ   sD   € àˆ=Øà$'×$BÑ$BÑ!ˆ˜Ù˜uÔ%ÜØ5°h°Z¸{È5È'ÐRóð ð &r6   c                ó   — t         S )z(return the class to use for construction)r   r2   s    r4   Ú_constructorzRangeIndex._constructorç   s	   € ô ˆr6   c                óŒ   — t        j                  | j                  | j                  | j                  t         j
                  ¬«      S )z�
        An int array that for performance reasons is created only when needed.

        The constructed array is saved in ``_cache``.
        ©rG   )ÚnpÚarangerD   rE   rF   Úint64r2   s    r4   Ú_datazRangeIndex._dataí   s)   € ô �y‰y˜Ÿ™ T§Y¡Y°·	±	ÄÇÁÔJÐJr6   c                ól   — | j                   }d|j                  fd|j                  fd|j                  fgS )z,return a list of tuples of start, stop, steprD   rE   rF   )r+   rD   rE   rF   ©r3   rH   s     r4   Ú_get_data_as_itemszRangeIndex._get_data_as_itemsö   s3   € à�k‰kˆØ˜#Ÿ)™)Ð$ v¨s¯x©xÐ&8¸6À3Ç8Á8Ð:LÐMÐMr6   c                óª   — d| j                   i}|j                  t        | j                  «       «      «       t        j
                  t        | «      |fd fS )Nr9   )rQ   ÚupdateÚdictre   ÚibaseÚ
_new_IndexÚtype)r3   Úds     r4   Ú
__reduce__zRangeIndex.__reduce__û   sE   € Ø�T—Z‘ZÐ ˆØ	�‰”�d×-Ñ-Ó/Ó0Ô1Ü×Ñ¤$ t£*¨a °$Ð6Ð6r6   c                ó²   — t        d| j                  «       «      }| j                  �0|j                  dt	        j
                  | j                  «      f«       |S )zH
        Return a list of tuples of the (attr, formatted_value)
        zlist[tuple[str, str | int]]r9   )r   re   rQ   Úappendri   Údefault_pprint)r3   Úattrss     r4   Ú_format_attrszRangeIndex._format_attrs  sI   € ô Ð2°D×4KÑ4KÓ4MÓNˆØ�:‰:Ð!Ø�L‰L˜&¤%×"6Ñ"6°t·z±zÓ"BÐCÔDØˆr6   c               ó  — t        | j                  «      s|S t        | j                  d   «      }t        | j                  d   «      }t        t        |«      t        |«      «      }|| j                  D �cg c]
  }|d|› d�›‘Œ c}z   S c c}w )Nr   éÿÿÿÿú<Ú )Úlenr+   ÚstrÚmax)r3   ÚheaderÚna_repÚfirst_val_strÚlast_val_strÚ
max_lengthÚxs          r4   Ú_format_with_headerzRangeIndex._format_with_header  sz   € ä�4—;‘;ÔØˆMÜ˜DŸK™K¨™NÓ+ˆÜ˜4Ÿ;™; r™?Ó+ˆÜœ˜]Ó+¬S°Ó->Ó?ˆ
à°t·{±{ÖC°!˜A˜a 
˜|¨0˜^Ð,Ñ-ÒCÑCÐCùÒCs   Á5B	c                ó.   — | j                   j                  S )a	  
        The value of the `start` parameter (``0`` if this was not supplied).

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.start
        0

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.start
        2
        )r+   rD   r2   s    r4   rD   zRangeIndex.start  s   € ð  �{‰{× Ñ Ð r6   c                ó.   — | j                   j                  S )zç
        The value of the `stop` parameter.

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.stop
        5

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.stop
        -10
        )r+   rE   r2   s    r4   rE   zRangeIndex.stop*  s   € ð �{‰{×ÑÐr6   c                ó.   — | j                   j                  S )a´  
        The value of the `step` parameter (``1`` if this was not supplied).

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.step
        1

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.step
        -3

        Even if :class:`pandas.RangeIndex` is empty, ``step`` is still ``1`` if
        not supplied.

        >>> idx = pd.RangeIndex(1, 0)
        >>> idx.step
        1
        )r+   rF   r2   s    r4   rF   zRangeIndex.step;  s   € ð. �{‰{×ÑÐr6   c                ó\   ‡— | j                   Št        ‰«      t        ˆfd„dD «       «      z   S )zD
        Return the number of bytes in the underlying data.
        c              3  óH   •K  — | ]  }t        t        ‰|«      «      –— Œ y ­wr/   )r   Úgetattr)Ú.0Ú	attr_namerH   s     €r4   ú	<genexpr>z$RangeIndex.nbytes.<locals>.<genexpr>Z  s%   øè ø€ ò $
àô ”g˜c 9Ó-×.ñ$
ùs   ƒ")rD   rE   rF   )r+   r   Úsumrd   s    @r4   ÚnbyteszRangeIndex.nbytesT  s3   ø€ ð
 �k‰kˆÜ˜‹~¤ó $
à6ô$
ó !
ñ 
ð 	
r6   c                ó   — | j                   S )aè  
        Memory usage of my values

        Parameters
        ----------
        deep : bool
            Introspect the data deeply, interrogate
            `object` dtypes for system-level memory consumption

        Returns
        -------
        bytes used

        Notes
        -----
        Memory usage does not include memory consumed by elements that
        are not components of the array if deep=False

        See Also
        --------
        numpy.ndarray.nbytes
        )r‹   )r3   Údeeps     r4   Úmemory_usagezRangeIndex.memory_usage_  s   € ð. �{‰{Ðr6   c                ó   — t         S r/   )Ú_dtype_int64r2   s    r4   rG   zRangeIndex.dtypex  s   € äÐr6   c                 ó   — y)z%return if the index has unique valuesT© r2   s    r4   Ú	is_uniquezRangeIndex.is_unique|  s   € ð r6   c                óT   — | j                   j                  dkD  xs t        | «      dk  S ©Nr   r:   ©r+   rF   rw   r2   s    r4   Úis_monotonic_increasingz"RangeIndex.is_monotonic_increasing�  ó$   € à�{‰{×Ñ !Ñ#Ò5¤s¨4£y°A¡~Ð5r6   c                óT   — | j                   j                  dk  xs t        | «      dk  S r•   r–   r2   s    r4   Úis_monotonic_decreasingz"RangeIndex.is_monotonic_decreasing…  r˜   r6   c                ój   — t        |«       	 t        |«      }|| j                  v S # t        $ r Y yw xY w©NF)Úhashr   rA   r+   )r3   Úkeys     r4   Ú__contains__zRangeIndex.__contains__‰  s=   € ÜˆSŒ	ð	Ü# CÓ(ˆCð �d—k‘kÐ!Ð!øô ò 	Ùð	ús   �& ¦	2±2c                 ó   — y)NÚintegerr’   r2   s    r4   Úinferred_typezRangeIndex.inferred_type‘  s   € àr6   c                óD  — t        |«      st        |«      r7|j                  «       r't        |«      }	 | j                  j	                  |«      S t        |t        «      rt        |«      ‚| j                  |«       t        |«      ‚# t
        $ r}t        |«      |‚d }~ww xY wr/   )
r   r   Úintr+   r   rB   ÚKeyErrorr<   r   Ú_check_indexing_error)r3   rž   Únew_keyÚerrs       r4   Úget_loczRangeIndex.get_loc˜  s‡   € ä�cŒ?œx¨œ}°·±Ô1AÜ˜#“hˆGð-Ø—{‘{×(Ñ(¨Ó1Ð1ô �cœ8Ô$Ü˜3“-ÐØ×"Ñ" 3Ô'Ü�s‹mÐøô ò -Ü˜s“m¨Ð,ûð-ús   ³B Â	BÂBÂBc                ó  •— t        j                  |||«      rt        ‰| �  ||||¬«      S | j                  dkD  r%| j
                  | j                  | j                  }}}n6| j                  d d d…   }|j
                  |j                  |j                  }}}t        j                  |«      }	|	|z
  }
|
|z  dk(  |
dk\  z  |	|k  z  }d|
| <   |
|   |z  |
|<   || j                  k7  rt        | «      dz
  |
|   z
  |
|<   t        |
«      S )N)ÚmethodÚ	toleranceÚlimitr   rt   r:   )r?   Úany_not_noneÚsuperÚ_get_indexerrF   rD   rE   r+   r_   Úasarrayrw   r   )r3   Útargetr«   r­   r¬   rD   rE   rF   ÚreverseÚtarget_arrayÚlocsÚvalidÚ	__class__s               €r4   r°   zRangeIndex._get_indexer¥  s  ø€ ô ×Ñ˜F I¨uÔ5Ü‘7Ñ'Ø˜v°À%ð (ó ð ð �9‰9�qŠ=Ø $§
¡
¨D¯I©I°t·y±y˜�4‰Eð —k‘k¡$ B $Ñ'ˆGØ '§¡¨w¯|©|¸W¿\¹\˜�4ˆEä—z‘z &Ó)ˆØ˜eÑ#ˆØ˜‘ Ñ! d¨a¡iÑ0°LÀ4Ñ4GÑHˆØˆˆeˆV‰Ø˜5‘k DÑ(ˆˆU‰à�4—9‘9Òä˜d›) a™-¨$¨u©+Ñ5ˆD�‰KÜ" 4Ó(Ð(r6   c                 ó   — y)zA
        Should an integer key be treated as positional?
        Fr’   r2   s    r4   Ú_should_fallback_to_positionalz)RangeIndex._should_fallback_to_positionalÃ  s   € ð
 r6   c                ó,   — t        | j                  «      S r/   )Úlistr+   r2   s    r4   ÚtolistzRangeIndex.tolistÌ  s   € Ü�D—K‘KÓ Ð r6   c              #  ó8   K  — | j                   E d {  –—†  y 7 Œ­wr/   ©r+   r2   s    r4   Ú__iter__zRangeIndex.__iter__Ï  s   è ø€ à—;‘;×Òús   ‚’“c                ó‚  — |t         u r| j                  n|}|j                  j                  dk(  rt	        ||t
        j                  ¬«      S t        |«      }t        |«      dk(  r?|d   dk7  r7|d   }t        |d   |d   |z   |«      }t        | «      j                  ||¬«      S | j                  j                  ||¬«      S )NÚf)r9   rG   r:   r   rt   r8   )r   rQ   rG   Úkindr   r_   Úfloat64r   rw   r*   rk   r>   r\   )r3   rU   r9   Úunique_diffsÚdiffÚ	new_ranges         r4   Ú_shallow_copyzRangeIndex._shallow_copyÓ  s·   € à!¤ZÑ/ˆt�zŠz°Tˆà�<‰<×Ñ Ò#Ü˜ d´"·*±*Ô=Ð=ô % VÓ,ˆÜˆ|Ó Ò! l°1¡o¸Ò&:Ø ‘?ˆDÜ˜f Q™i¨°©°dÑ):¸DÓAˆIÜ˜“:×)Ñ)¨)¸$Ð)Ó?Ð?à×$Ñ$×0Ñ0°¸dÐ0ÓCÐCr6   c                óˆ   — t        | «      j                  | j                  | j                  ¬«      }| j                  |_        |S )Nr8   )rk   r>   r+   rQ   rR   )r3   rV   s     r4   Ú_viewzRangeIndex._viewã  s3   € Ü�d“×'Ñ'¨¯©¸$¿*¹*Ð'ÓEˆØŸ™ˆŒØˆr6   c                óV   — | j                  ||¬«      d   }| j                  |¬«      }|S )N)r9   r�   r   r8   )Ú_validate_namesÚ_rename)r3   r9   r�   Ú	new_indexs       r4   r=   zRangeIndex.copyè  s2   € à×#Ñ#¨°DÐ#Ó9¸!Ñ<ˆØ—L‘L d�LÓ+ˆ	ØÐr6   c                óè   — t        | «      dz
  }|dk(  rt        j                  S |dk(  r| j                  dkD  s|dk(  r| j                  dk  r| j                  S | j                  | j                  |z  z   S )Nr:   rt   Úminr   ry   )rw   r_   ÚnanrF   rD   )r3   ÚmethÚno_stepss      r4   Ú_minmaxzRangeIndex._minmaxî  sc   € Ü�t“9˜q‘=ˆØ�rŠ>Ü—6‘6ˆMØ�eŠm §	¡	¨A¢°4¸5²=ÀTÇYÁYÐQRÂ]Ø—:‘:Ðà�z‰z˜DŸI™I¨Ñ0Ñ0Ð0r6   c                óz   — t        j                  |«       t        j                  ||«       | j                  d«      S )z#The minimum value of the RangeIndexrÏ   )ÚnvÚvalidate_minmax_axisÚvalidate_minrÓ   ©r3   ÚaxisÚskipnaÚargsÚkwargss        r4   rÏ   zRangeIndex.min÷  ó-   € ä
×Ñ Ô%Ü
�‰˜˜fÔ%Ø�|‰|˜EÓ"Ð"r6   c                óz   — t        j                  |«       t        j                  ||«       | j                  d«      S )z#The maximum value of the RangeIndexry   )rÕ   rÖ   Úvalidate_maxrÓ   rØ   s        r4   ry   zRangeIndex.maxý  rÝ   r6   c                ó„  — |j                  dd«      }|j                  dd«       t        j                  ||«       | j                  j                  dkD  r/t        j                  t        | «      t
        j                  ¬«      }n3t        j                  t        | «      dz
  ddt
        j                  ¬«      }|s|ddd…   }|S )	zÞ
        Returns the indices that would sort the index and its
        underlying data.

        Returns
        -------
        np.ndarray[np.intp]

        See Also
        --------
        numpy.ndarray.argsort
        Ú	ascendingTrÂ   Nr   r^   r:   rt   )	ÚpoprÕ   Úvalidate_argsortr+   rF   r_   r`   rw   Úintp)r3   rÛ   rÜ   rá   rV   s        r4   ÚargsortzRangeIndex.argsort  s‘   € ð —J‘J˜{¨DÓ1ˆ	Ø�
‰
�6˜4Ô Ü
×Ñ˜D &Ô)à�;‰;×Ñ˜aÒÜ—Y‘Yœs 4›y´·±Ô8‰Fä—Y‘Yœs 4›y¨1™}¨b°"¼B¿G¹GÔDˆFáØ™D˜b˜D‘\ˆFØˆr6   c                ó¬   — t        j                  t        | «      t         j                  ¬«      }| }|r| j                  dk  r|d d d…   }|d d d…   }||fS )Nr^   r   rt   )r_   r`   rw   rä   rF   )r3   ÚsortÚuse_na_sentinelÚcodesÚuniquess        r4   Ú	factorizezRangeIndex.factorize  sR   € ô
 —	‘	œ#˜d›)¬2¯7©7Ô3ˆØˆÙ�D—I‘I ’MØ™$˜B˜$‘KˆEØ™d ˜d‘mˆGØ�gˆ~Ðr6   c                ót   •— t        |t        «      r| j                  |j                  k(  S t        ‰| �  |«      S )zL
        Determines if two Index objects contain the same elements.
        )r<   r(   r+   r¯   Úequals)r3   Úotherr·   s     €r4   rí   zRangeIndex.equals)  s1   ø€ ô �eœZÔ(Ø—;‘; %§,¡,Ñ.Ð.Ü‰w‰~˜eÓ$Ð$r6   .©Úreturn_indexerrá   Úna_positionrž   c                ó   — y r/   r’   ©r3   rð   rá   rñ   rž   s        r4   Úsort_valueszRangeIndex.sort_values2  ó   € ð 	r6   )rá   rñ   rž   c                ó   — y r/   r’   ró   s        r4   rô   zRangeIndex.sort_values=  rõ   r6   c                ó   — y r/   r’   ró   s        r4   rô   zRangeIndex.sort_valuesH  rõ   r6   z3.0r3   rô   )ÚversionÚallowed_argsr9   c                ó"  •— |�t         ‰| �  ||||¬«      S | }d}|r| j                  dk  r$| d d d…   }d}n| j                  dkD  r
| d d d…   }d}|r=|rt        t	        | «      dz
  dd«      }nt        t	        | «      «      }|t        |«      fS |S )Nrï   Fr   rt   Tr:   )r¯   rô   rF   r*   rw   r(   )	r3   rð   rá   rñ   rž   Úsorted_indexÚinverse_indexerrH   r·   s	           €r4   rô   zRangeIndex.sort_valuesS  sµ   ø€ ð ˆ?Ü‘7Ñ&Ø-Ø#Ø'Øð	 'ó ð ð  ˆLØ#ˆOÙØ—9‘9˜q’=Ø#'©¨"¨¡:�LØ&*‘Oà—9‘9˜q’=Ø#'©¨"¨¡:�LØ&*�OáÙÜœC ›I¨™M¨2¨rÓ2‘äœC ›IÓ&�Ø¤¨C£Ð0Ð0àÐr6   c                óf  •— t        |t        «      st        ‰| �  ||¬«      S | j                  dk  r| j
                  d d d…   n| j
                  }|j                  dk  r|j
                  d d d…   n|j
                  }t        |j                  |j                  «      }t        |j                  |j                  «      }||k  r| j                  t        «      S | j                  |j                  |j                  «      \  }}}	|j                  |j                  z
  |z  r| j                  t        «      S |j                  |j                  |j                  z
  |j                  z  |z  |z  z   }
|j                  |j                  z  |z  }t        |
||«      }| j                  |«      }|j                  |«      }t        ||j                  |j                  «      }| j                  |«      }| j                  dk  xr |j                  dk  |j                  dk  ur|d d d…   }|€|j                  «       }|S )N©rç   r   rt   )r<   r(   r¯   Ú_intersectionrF   r+   ry   rD   rÏ   rE   r>   Ú_empty_rangeÚ_extended_gcdr*   Ú_min_fitting_elementrô   )r3   rî   rç   ÚfirstÚsecondÚint_lowÚint_highÚgcdÚsÚ_Ú	tmp_startÚnew_steprÆ   rÍ   Ú	new_startr·   s                  €r4   rÿ   zRangeIndex._intersection|  sß  ø€ ô ˜%¤Ô,Ü‘7Ñ(¨°TÐ(Ó:Ð:à%)§Y¡Y°¢]�—‘™D˜b˜DÒ!¸¿¹ˆØ',§z¡z°A¢~�—‘™d ˜dÒ#¸5¿<¹<ˆô �e—k‘k 6§<¡<Ó0ˆÜ�u—z‘z 6§;¡;Ó/ˆØ�wÒØ×#Ñ#¤LÓ1Ð1ð ×&Ñ& u§z¡z°6·;±;Ó?‰	ˆˆQ�ð �K‰K˜&Ÿ,™,Ñ&¨#Ò-Ø×#Ñ#¤LÓ1Ð1ð —K‘K 6§<¡<°%·+±+Ñ#=ÀÇÁÑ"KÈsÑ"RÐUVÑ"VÑVˆ	Ø—:‘: §¡Ñ+¨sÑ2ˆÜ˜) X¨xÓ8ˆ	Ø×$Ñ$ YÓ/ˆ	ð ×2Ñ2°7Ó;ˆ	Ü˜) Y§^¡^°Y·^±^ÓDˆ	Ø×$Ñ$ YÓ/ˆ	à�I‰I˜‰MÒ,˜eŸj™j¨1™n°i·n±nÀqÑ6HÑIØ!¡$ B $™ˆIàˆ<Ø!×-Ñ-Ó/ˆIàÐr6   c                óš   — || j                   z
   t        | j                  «      z   }| j                   t        | j                  «      |z  z   S )z?Returns the smallest element greater than or equal to the limit)rD   ÚabsrF   )r3   Úlower_limitrÒ   s      r4   r  zRangeIndex._min_fitting_elementª  s?   € à" T§Z¡ZÑ/Ð0´C¸¿	¹	³NÑBÐCˆØ�z‰zœC §	¡	›N¨XÑ5Ñ5Ð5r6   c                óx   — d\  }}d\  }}||}}|r&||z  }	|||	|z  z
  }}|||	|z  z
  }}|||	|z  z
  }}|rŒ&|||fS )z¼
        Extended Euclidean algorithms to solve Bezout's identity:
           a*x + b*y = gcd(x, y)
        Finds one particular solution for x, y: s, t
        Returns: gcd, s, t
        )r   r:   )r:   r   r’   )
r3   ÚaÚbr  Úold_sÚtÚold_tÚrÚold_rÚquotients
             r4   r  zRangeIndex._extended_gcd¯  su   € ð ‰ˆˆ5Ø‰ˆˆ5Ø�aˆ5ˆÙØ ‘zˆHØ˜% (¨Q¡,Ñ.�1ˆEØ˜% (¨Q¡,Ñ.�1ˆEØ˜% (¨Q¡,Ñ.�1ˆEò	 ð
 �e˜UÐ"Ð"r6   c                óÜ   — |sy| j                   syt        |«      dkD  r$|j                  | j                   j                  z  ry|j                  | j                   v xr |d   | j                   v S )z)Check if other range is contained in selfTFr:   rt   )r+   rw   rF   rD   )r3   rî   s     r4   Ú_range_in_selfzRangeIndex._range_in_selfÀ  s\   € ñ ØØ�{Š{ØÜˆu‹:˜Š>˜eŸj™j¨4¯;©;×+;Ñ+;Ò;ØØ�{‰{˜dŸk™kÐ)ÒF¨e°B©i¸4¿;¹;Ð.FÐFr6   c                óæ  •— t        |t        «      �rO|dv s1|du �rF| j                  dkD  �r6| j                  |j                  «      �r| j
                  | j                  }}| j
                  | j                  t        | «      dz
  z  z   }|j
                  |j                  }}|j
                  |j                  t        |«      dz
  z  z   }| j                  dk  r|| |}}}|j                  dk  r|| |}}}t        | «      dk(  r3t        |«      dk(  r%t        | j
                  |j
                  z
  «      x}}n!t        | «      dk(  r|}nt        |«      dk(  r|}t        ||«      }	t        ||«      }
||k(  r}||z
  |z  dk(  r&||z
  |k  r||z
  |k  r t        | «      |	|
|z   |«      S |dz  dk(  r¶t        ||z
  «      |dz  k(  r¢t        ||z
  «      |dz  k(  rŽ t        | «      |	|
|dz  z   |dz  «      S ||z  dk(  r1||z
  |z  dk(  r_||z   |k\  rW||z
  |k  rO t        | «      |	|
|z   |«      S ||z  dk(  r1||z
  |z  dk(  r&||z   |k\  r||z
  |k  r t        | «      |	|
|z   |«      S t        ‰| �1  ||¬«      S )aœ  
        Form the union of two Index objects and sorts if possible

        Parameters
        ----------
        other : Index or array-like

        sort : bool or None, default None
            Whether to sort (monotonically increasing) the resulting index.
            ``sort=None|True`` returns a ``RangeIndex`` if possible or a sorted
            ``Index`` with a int64 dtype if not.
            ``sort=False`` can return a ``RangeIndex`` if self is monotonically
            increasing and other is fully contained in self. Otherwise, returns
            an unsorted ``Index`` with an int64 dtype.

        Returns
        -------
        union : Index
        ©NTFr   r:   é   rþ   )r<   r(   rF   r  r+   rD   rw   r  rÏ   ry   rk   r¯   Ú_union)r3   rî   rç   Ústart_sÚstep_sÚend_sÚstart_oÚstep_oÚend_oÚstart_rÚend_rr·   s              €r4   r  zRangeIndex._unionË  s‘  ø€ ô( �eœZÕ(Ø�|Ñ#Ø˜’ $§)¡)¨a£-°D×4GÑ4GÈÏÉÕ4Uð #'§*¡*¨d¯i©i˜�ØŸ
™
 T§Y¡Y´#°d³)¸a±-Ñ%@Ñ@�Ø"'§+¡+¨u¯z©z˜�ØŸ™ e§j¡j´C¸³JÀ±NÑ&CÑC�Ø—9‘9˜q’=Ø-2°V°G¸W U˜V�GØ—:‘: ’>Ø-2°V°G¸W U˜V�GÜ�t“9 ’>¤c¨%£j°A¢oÜ&)¨$¯*©*°u·{±{Ñ*BÓ&CÐC�F™VÜ˜“Y !’^Ø#‘FÜ˜“Z 1’_Ø#�FÜ˜g wÓ/�Ü˜E 5Ó)�Ø˜VÒ#à  7Ñ*¨fÑ4¸Ò9Ø$ u™_°Ò7Ø$ u™_°Ò7à)œt D›z¨'°5¸6±>À6ÓJÐJà !™ qšÜ  ¨7Ñ!2Ó3°vÀ±zÒAÜ  ¨¡Ó/°6¸A±:Ò=ð  *œt D›z¨'°5¸6ÀA¹:Ñ3EÀvÐPQÁzÓRÐRà˜f‘_¨Ò)à  7Ñ*¨fÑ4¸Ò9Ø$ vÑ-°Ò8Ø" V™^¨uÒ4à)œt D›z¨'°5¸6±>À6ÓJÐJØ˜f‘_¨Ò)à  7Ñ*¨fÑ4¸Ò9Ø$ vÑ-°Ò8Ø" V™^¨uÒ4à)œt D›z¨'°5¸6±>À6ÓJÐJä‰w‰~˜e¨$ˆ~Ó/Ð/r6   c                ó¢  •— | j                  |«       | j                  |«       | j                  |«      \  }}t        |t        «      st
        ‰
| �  ||¬«      S |dur&| j                  dk  r| d d d…   j                  |«      S t        j                  | |«      }| j                  dk  r| j                  d d d…   n| j                  }| j                  |«      }|j                  dk  r|d d d…   }t        |«      dk(  r| j                  |¬«      S t        |«      t        | «      k(  r| d d j                  |«      S t        |«      dk(  rR|d   | d   k(  r| dd  S |d   | d   k(  r| d d S t        | «      dk(  r|d   | d   k(  r| d d d…   S t
        ‰
| �  ||¬«      S t        |«      dk(  r|d   |d   k(  r|d   |d   k(  r| dd S |j                  |j                  k(  r®|d   |j                  k(  r2t        |d   |j                  z   |j                   |j                  «      }nþ|d   |d   k(  r%t        |j                  |d   |j                  «      }nÎ|j                  |dd k(  rt        |«      dz
  }|d d |…   }n¥t
        ‰
| �  ||¬«      S t        | «      dkD  sJ ‚|j                  |j                  dz  k(  rW|d   |d   k(  r|d   |d   |d	   fv r	|dd d…   }nE|d   |d   k(  r|d   |d   |d	   fv r	|d d d…   }n"t
        ‰
| �  ||¬«      S t
        ‰
| �  ||¬«      S t#        | «      j%                  ||¬«      }	|| j                  ur|	d d d…   }	|	S )
Nrþ   Fr   rt   r8   r:   é   r  éþÿÿÿ)Ú_validate_sort_keywordÚ_assert_can_do_setopÚ_convert_can_do_setopr<   r(   r¯   Ú_differencerF   r   Úget_op_result_namer+   Úintersectionrw   ÚrenamerD   r*   rE   rk   r>   )r3   rî   rç   Úresult_nameÚres_namer  ÚoverlapÚnew_rngrF   rÍ   r·   s             €r4   r-  zRangeIndex._difference  s�  ø€ à×#Ñ# DÔ)Ø×!Ñ! %Ô(Ø!×7Ñ7¸Ó>Ñˆˆ{ä˜%¤Ô,Ü‘7Ñ& u°4Ð&Ó8Ð8à�uÑ §¡¨Q¢Ø™˜"˜‘:×)Ñ)¨%Ó0Ð0ä×)Ñ)¨$°Ó6ˆà%)§Y¡Y°¢]�—‘™D˜b˜DÒ!¸¿¹ˆØ×#Ñ# EÓ*ˆØ�<‰<˜!ÒØ™d ˜d‘mˆGäˆw‹<˜1ÒØ—;‘; H�;Ó-Ð-Üˆw‹<œ3˜t›9Ò$Ø˜˜�8—?‘? 8Ó,Ð,ô ˆw‹<˜1ÒØ�q‰z˜T !™WÒ$Ø˜A˜B�x�à˜‘˜t B™xÒ'Ø˜C˜R�yÐ ä�T“˜a’ G¨A¡J°$°q±'Ò$9Ø™C˜a˜C‘yÐ ô ‘wÑ*¨5°tÐ*Ó<Ð<ä�‹\˜QÒ 7¨1¡:°°q±Ò#9¸gÀb¹kÈUÐSUÉYÒ>Và˜˜"�:Ðà�<‰<˜5Ÿ:™:Ò%Ø�q‰z˜UŸ[™[Ò(ä ¨¡¨e¯j©jÑ 8¸%¿*¹*ÀeÇjÁjÓQ‘Ø˜‘  b¡	Ò)ä §¡¨W°Q©Z¸¿¹ÓD‘Ø—‘ 5¨¨2 ;Ò.ä˜5“z A‘~�Ø¡ $ ™-‘ô ‘wÑ*¨5°tÐ*Ó<Ð<ô
 �t“9˜q’=Ð �=à�|‰|˜uŸz™z¨A™~Ò-Ø˜1‘:  q¡Ò)¨g°b©k¸eÀB¹iÈÈrÉÐ=SÑ.Sà# A D q D™k‘Gà˜Q‘Z 5¨¡8Ò+°¸±ÀÀbÁ	È5ÐQSÉ9Ð?UÑ0Uà#¡C a C™j‘Gô !™7Ñ.¨u¸4Ð.Ó@Ð@ô ‘wÑ*¨5°tÐ*Ó<Ð<ä˜“J×*Ñ*¨7¸Ð*ÓBˆ	Ø˜Ÿ™Ñ#Ø!¡$ B $™ˆIàÐr6   c                óÚ   •— t        |t        «      r|�t        ‰| �  |||«      S | j	                  |«      }|j	                  | «      }|j                  |«      }|�|j                  |«      }|S r/   )r<   r(   r¯   Úsymmetric_differenceÚ
differenceÚunionr0  )r3   rî   r1  rç   ÚleftÚrightrV   r·   s          €r4   r6  zRangeIndex.symmetric_differencem  sm   ø€ ô ˜%¤Ô,°Ð0@Ü‘7Ñ/°°{ÀDÓIÐIà�‰˜uÓ%ˆØ× Ñ  Ó&ˆØ—‘˜EÓ"ˆàÐ"Ø—]‘] ;Ó/ˆFØˆr6   c                óÂ  •— t        |«      rF|dt        | «       fv r| dd  S |dt        | «      dz
  fv r| d d S t        | «      dk(  r‹|dv r‡| d d d…   S t        j                  |«      rjt        j                  t        j                  |t
        j                  ¬«      t        | «      «      }t        |t        «      r| |   }| j                  |d¬	«      S t        ‰| �1  |«      S )
Nr   r:   rt   r(  )r:   r)  r  r^   Frþ   )r   rw   r   Úis_list_likeÚmaybe_indices_to_slicer_   r±   rä   r<   Úslicer7  r¯   Údelete)r3   ÚlocÚslcrî   r·   s       €r4   r?  zRangeIndex.delete  sÔ   ø€ ô �cŒ?Ø�qœ3˜t›9˜*�oÑ%Ø˜A˜B�x�Ø�rœ3˜t›9 q™=Ð)Ñ)Ø˜C˜R�yÐ Ü�4‹y˜AŠ~ #¨¡.Ø™C˜a˜C‘yÐ ä×Ñ˜cÔ"Ü×,Ñ,¬R¯Z©Z¸Ä2Ç7Á7Ô-KÌSÐQUËYÓWˆCä˜#œuÔ%ð ˜S™	�Ø—‘ u°5�Ó9Ð9ä‰w‰~˜cÓ"Ð"r6   c                ó~  •— t        | «      �r¡t        |«      st        |«      �rŠ| j                  }|dk(  rs|| d   | j                  z
  k(  r^t        |j                  |j                  z
  |j                  |j                  «      }t        | «      j                  || j                  ¬«      S |t        | «      k(  rs|| d   | j                  z   k(  r^t        |j                  |j                  |j                  z   |j                  «      }t        | «      j                  || j                  ¬«      S t        | «      dk(  rw|| d   | j                  dz  z   k(  r_t        | j                  dz  «      }t        | j                  | j                  |«      }t        | «      j                  || j                  ¬«      S t        ‰| �5  ||«      S )Nr   r8   rt   r  )rw   r   r   r+   rF   r*   rD   rE   rk   r>   rQ   r¤   r¯   Úinsert)r3   r@  ÚitemrH   r4  rF   r·   s         €r4   rC  zRangeIndex.insert•  sY  ø€ Üˆt�9œ* TÔ*¬h°t­nð —+‘+ˆCØ�aŠx˜D D¨¡G¨d¯i©iÑ$7Ò7Ü §	¡	¨C¯H©HÑ 4°c·h±hÀÇÁÓI�Ü˜D“z×-Ñ-¨g¸D¿J¹JÐ-ÓGÐGàœ˜D›	Ò! d¨d°2©h¸¿¹Ñ.BÒ&BÜ §	¡	¨3¯8©8°c·h±hÑ+>ÀÇÁÓI�Ü˜D“z×-Ñ-¨g¸D¿J¹JÐ-ÓGÐGä�T“˜a’ D¨D°©G°d·i±iÀ!±mÑ,CÒ$Cä˜4Ÿ9™9 q™=Ó)�Ü §
¡
¨D¯I©I°tÓ<�Ü˜D“z×-Ñ-¨g¸D¿J¹JÐ-ÓGÐGä‰w‰~˜c 4Ó(Ð(r6   c           	     ó  •— t        d„ |D «       «      st        ‰| �	  ||«      S t        |«      dk(  r|d   S t	        t
        t           |«      }dx}x}}|D �cg c]  }t        |«      sŒ|‘Œ }}|D �]>  }|j                  }	|€)|	j                  }|€Œt        |	«      dkD  r~|	j                  }nq|€o|	j                  |k(  rQt        j                  |D �
cg c]  }
|
j                  ‘Œ c}
«      }| j                  |«      }|j                  |«      c S |	j                  |z
  }||	j                  k7  xr t        |	«      dkD  xs |duxr |	j                  |k7  }|rO| j                  t        j                  |D �
cg c]  }
|
j                  ‘Œ c}
«      «      }|j                  |«      c S |€�Œ7|	d   |z   }�ŒA |r/|€|d   j                  n|}t        |||«      j                  |«      S t        dd«      j                  |«      S c c}w c c}
w c c}
w )aŠ  
        Overriding parent method for the case of all RangeIndex instances.

        When all members of "indexes" are of type RangeIndex: result will be
        RangeIndex if possible, Index with a int64 dtype otherwise. E.g.:
        indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)
        indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Index([0,1,2,4,5], dtype='int64')
        c              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wr/   )r<   r(   ©r‡   r   s     r4   r‰   z%RangeIndex._concat.<locals>.<genexpr>³  s   è ø€ Ò>°”:˜a¤×,Ñ>ùs   ‚r:   r   Nrt   )Úallr¯   Ú_concatrw   r   r»   r(   r+   rD   rF   r_   Úconcatenater-   r\   r0  rE   )r3   Úindexesr9   Úrng_indexesrD   rF   Únext_ÚobjÚnon_empty_indexesrH   r   rU   rV   Únon_consecutiverE   r·   s                  €r4   rI  zRangeIndex._concatª  s  ø€ ô Ñ>°gÔ>Ô>Ü‘7‘? 7¨DÓ1Ð1ä�‹\˜QÒØ˜1‘:Ðäœ4¤
Ñ+¨WÓ5ˆà#Ð#ˆÐ#��uð -8ÖD S¼3¸s½8šSÐDÐÐDà$ó 	'ˆCØ—*‘*ˆCàˆ}àŸ	™	�Ø�<¤C¨£H¨q¢LØŸ8™8‘DØ�à—9‘9 Ò%ÜŸ^™^ÀÖ,L¸1¨Q¯Y«YÒ,LÓM�FØ!×.Ñ.¨vÓ6�FØ!Ÿ=™=¨Ó.Ò.à—y‘y 5Ñ(�à# s§x¡xÑ/Ò@´C¸³H¸q±Lò Ø˜TÐ!Ò8 c§i¡i°5Ñ&8ð ñ Ø×*Ñ*Ü—N‘N°{Ö#C°! A§I£IÒ#CÓDó�ð —}‘} TÓ*Ò*àÒØ˜B™ $™’ð7	'ñ: ð 27°Ð$ RÑ(×-Ò-ÀEˆDÜ˜e T¨4Ó0×7Ñ7¸Ó=Ð=ô ˜!˜QÓ×&Ñ& tÓ,Ð,ùòO Eùò -Mùò $Ds   ÁG?Á)G?ÃH
Å3H	c                ó,   — t        | j                  «      S )z5
        return the length of the RangeIndex
        )rw   r+   r2   s    r4   Ú__len__zRangeIndex.__len__ç  s   € ô �4—;‘;ÓÐr6   c                ó   — t        | «      S r/   )rw   r2   s    r4   ÚsizezRangeIndex.sizeí  s   € ä�4‹yÐr6   c           	     ó4  •— t        |t        «      r| j                  |«      S t        |«      rt	        |«      }	 | j
                  |   S t        |«      rt        d«      ‚t        ‰| �)  |«      S # t        $ r }t        d|› dt        | «      › �«      |‚d}~ww xY w)zE
        Conserve RangeIndex type for scalar and slice keys.
        úindex ú' is out of bounds for axis 0 with size Nzuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices)r<   r>  Ú_getitem_slicer   r¤   r+   Ú
IndexErrorrw   r   r¯   Ú__getitem__)r3   rž   r§   r¨   r·   s       €r4   rZ  zRangeIndex.__getitem__ñ  s¨   ø€ ô �cœ5Ô!Ø×&Ñ& sÓ+Ð+Ü˜Œ_Ü˜#“hˆGðØ—{‘{ 7Ñ+Ð+ô
 �sŒ^Üð+óð ô ‰wÑ" 3Ó'Ð'øô ò Ü Ø˜S˜EÐ!HÌÈTËÈÐTóàðûðús   ºA. Á.	BÁ7BÂBc                ól   — | j                   |   }t        | «      j                  || j                  ¬«      S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r8   )r+   rk   r>   rQ   )r3   ÚslobjÚress      r4   rX  zRangeIndex._getitem_slice  s0   € ð �k‰k˜%Ñ ˆÜ�D‹z×%Ñ% c°·
±
Ð%Ó;Ð;r6   Ú__floordiv__c                óô  •— t        |«      rÞ|dk7  rÙt        | «      dk(  s$| j                  |z  dk(  ro| j                  |z  dk(  r]| j                  |z  }| j                  |z  }|t        | «      |z  z   }t	        |||xs d«      }| j                  || j                  ¬«      S t        | «      dk(  r<| j                  |z  }t	        ||dz   d«      }| j                  || j                  ¬«      S t        ‰| �!  |«      S )Nr   r:   r8   )	r   rw   rD   rF   r*   r>   rQ   r¯   r^  )r3   rî   rD   rF   rE   rÆ   r·   s         €r4   r^  zRangeIndex.__floordiv__  sí   ø€ ä�eÔ ¨!¢Ü�4‹y˜AŠ~ §¡¨eÑ!3°qÒ!8¸T¿Y¹YÈÑ=NÐRSÒ=SØŸ
™
 eÑ+�Ø—y‘y EÑ)�Øœs 4›y¨4Ñ/Ñ/�Ü! %¨¨tªy°qÓ9�	Ø×'Ñ'¨	¸¿
¹
Ð'ÓCÐCÜ�4‹y˜AŠ~ØŸ
™
 eÑ+�Ü! %¨°©°AÓ6�	Ø×'Ñ'¨	¸¿
¹
Ð'ÓCÐCä‰wÑ# EÓ*Ð*r6   c                ó   — d| j                   vS )Nr   r¾   ©r3   rÛ   rÜ   s      r4   rH  zRangeIndex.all"  s   € Ø˜Ÿ™Ð#Ð#r6   c                ó,   — t        | j                  «      S r/   )Úanyr+   ra  s      r4   rc  zRangeIndex.any%  s   € Ü�4—;‘;ÓÐr6   c                ó–   •— t        |t        «      r)| j                  |j                  k(  rt        ‰| �  | |«      S t        ‰| �  ||«      S r/   )r<   r(   r+   r¯   Ú_cmp_method)r3   rî   Úopr·   s      €r4   re  zRangeIndex._cmp_method*  s@   ø€ Ü�eœZÔ(¨T¯[©[¸E¿L¹LÒ-Hä‘7Ñ& t¨RÓ0Ð0Ü‰wÑ" 5¨"Ó-Ð-r6   c           	     ó:  •— t        |t        «      rt        S t        |t        t        j
                  f«      rt        ‰| �  ||«      S t        j                  t        |dd«      d«      rt        ‰| �  ||«      S |t        j                  t        j                  t        j                  t        j                   t        j"                  t        j$                  t&        t        j(                  fv rt        ‰| �  ||«      S d}|t        j*                  t        j,                  t        j.                  t        j0                  fv r|}t3        |dd¬«      }| }	 |rEt	        j4                  d¬«      5   ||j6                  |«      }ddd«       t9        «      r|s2t:        ‚|t        j<                  k(  r|j6                   n|j6                  }t	        j4                  d¬«      5   ||j>                  |«      } ||j@                  |«      }ddd«       t        jB                  | |«      }	 tE        | «      ||	¬«      }
tG        d	„ |||fD «       «      s|
jI                  d
«      }
|
S # 1 sw Y   ŒàxY w# 1 sw Y   ŒhxY w# t:        tJ        tL        f$ r t        ‰| �  ||«      cY S w xY w)z‘
        Parameters
        ----------
        other : Any
        op : callable that accepts 2 params
            perform the binary op
        rG   NÚmT)Úextract_numpyÚextract_rangeÚignore)rH  r8   c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr/   )r   rG  s     r4   r‰   z+RangeIndex._arith_method.<locals>.<genexpr>q  s   è ø€ ÒE¨”z !—}ÑEùs   ‚rÃ   )'r<   r   ÚNotImplementedr   r_   Útimedelta64r¯   Ú_arith_methodr   Úis_np_dtyper†   ÚoperatorÚpowr   ÚrpowÚmodÚrmodÚfloordivÚ	rfloordivÚdivmodÚrdivmodÚmulÚrmulÚtruedivÚrtruedivr   ÚerrstaterF   r   rB   ÚrsubrD   rE   r.  rk   rH  ÚastyperA   ÚZeroDivisionError)r3   rî   rf  rF   r:  r9  ÚrstepÚrstartÚrstopr2  rV   r·   s              €r4   ro  zRangeIndex._arith_method0  s&  ø€ ô �eÔ.Ô/ä!Ð!Ü˜¤	¬2¯>©>Ð:Ô;ô ‘7Ñ(¨°Ó3Ð3Ü�_‰_œW U¨G°TÓ:¸CÔ@ä‘7Ñ(¨°Ó3Ð3àÜ�L‰LÜ�H‰HÜ�L‰LÜ�H‰HÜ×ÑÜ�M‰MÜÜ�K‰Kð	
ñ 	
ô ‘7Ñ(¨°Ó3Ð3à $ˆØ”(—,‘,¤§¡¬(×*:Ñ*:¼C¿L¹LÐIÑIØˆDô ˜e°4ÀtÔLˆØˆð 	4áÜ—[‘[ XÔ.ñ 3Ù  §¡¨EÓ2�E÷3ô
 " %Ô(±Ü$Ð$ð ')¬C¯H©H¢n˜Ÿ™™
¸$¿)¹)�ä—‘ Ô*ñ -Ù˜DŸJ™J¨Ó.�Ù˜4Ÿ9™9 eÓ,�÷-ô ×-Ñ-¨d°EÓ:ˆHØ”T˜$“Z ¨¨u¸8ÔDˆFô
 ÑE¨v°u¸eÐ.DÔEÔEØŸ™ yÓ1�àˆM÷33ð 3ú÷-ð -ûô œIÔ'8Ð9ò 	4ä‘7Ñ(¨°Ó3Ò3ð	4úsD   ÅI3 Å(IÅ<AI3 Ç'I'È AI3 ÉI$É I3 É'I0É,I3 É3$JÊJc                ó  — |rt        j                  d|«       t        |«      rt        d«      ‚t	        |«      }| j                  |||«       t        |«      dk(  r"t        j                  g | j                  ¬«      }nÝ|j                  «       }|t        | «      k\  rt        d|› dt        | «      › �«      ‚|j                  «       }|t        | «       k  rt        d|› dt        | «      › �«      ‚|j                  | j                  d¬«      }|dk  r|t        | «      z  }| j                  d	k7  r|| j                  z  }| j                  dk7  r|| j                  z  }| j                   j#                  || j$                  ¬
«      S )Nr’   z!Expected indices to be array-liker   r^   rV  rW  Úsafe)Úcastingr:   r8   )rÕ   Úvalidate_taker   rA   r   Ú_maybe_disallow_fillrw   r_   ÚarrayrG   ry   rY  rÏ   r€  rF   rD   r\   r>   r9   )	r3   ÚindicesrÙ   Ú
allow_fillÚ
fill_valuerÜ   ÚtakenÚind_maxÚind_mins	            r4   ÚtakezRangeIndex.take|  sb  € ñ Ü×Ñ˜R Ô(Ü�WÔÜÐ?Ó@Ð@Ü% gÓ.ˆð 	×!Ñ! *¨j¸'ÔBäˆw‹<˜1ÒÜ—H‘H˜R t§z¡zÔ2‰Eà—k‘k“mˆGØœ#˜d›)Ò#Ü Ø˜W˜IÐ%LÌSÐQUËYÈKÐXóð ð —k‘k“mˆGØœ#˜d›)˜Ò#Ü Ø˜W˜IÐ%LÌSÐQUËYÈKÐXóð ð —N‘N 4§:¡:°v�NÓ>ˆEØ˜Š{Øœ˜T›Ñ"�Ø�y‰y˜AŠ~Ø˜Ÿ™Ñ"�Ø�z‰z˜QŠØ˜Ÿ™Ñ#�ð × Ñ ×,Ñ,¨U¸¿¹Ð,ÓCÐCr6   )Úreturnztype[libindex.Int64Engine])NNNNFN)rG   úDtype | Noner=   Úboolr9   úHashable | Noner’  r%   )NN)rM   r*   rG   r“  r’  r%   r/   )rU   r*   r9   r•  r’  r%   )rG   r“  r’  ÚNone)r’  ztype[Index])r’  r,   )r’  zlist[tuple[str, int]])rz   ú	list[str]r{   rx   r’  r—  )r’  r¤   )F)r�   r”  r’  r¤   )r’  znp.dtype)r’  r”  )rž   r	   r’  r”  )r’  rx   )NNN)r²   r   r«   z
str | Noner­   z
int | Noner’  únpt.NDArray[np.intp])r’  z	list[int])r’  zIterator[int])r9   r   )r’  r%   rœ   )r9   r•  r�   r”  r’  r%   )rÑ   rx   r  )rÚ   r”  r’  r¤   )r’  r˜  )FT)rç   r”  rè   r”  r’  z'tuple[npt.NDArray[np.intp], RangeIndex])rî   rP   r’  r”  )
rð   zLiteral[False]rá   r”  rñ   r$   rž   úCallable | Noner’  r%   )
rð   zLiteral[True]rá   r”  rñ   r$   rž   r™  r’  z$tuple[Self, np.ndarray | RangeIndex])
rð   r”  rá   r”  rñ   r$   rž   r™  r’  z+Self | tuple[Self, np.ndarray | RangeIndex])FTÚlastN)rî   r   rç   r”  )r  r¤   r’  r¤   )r  r¤   r  r¤   r’  ztuple[int, int, int])rî   r*   r’  r”  )rî   r   rç   zbool | None)r1  r•  )r’  r   )r@  r¤   r’  r   )rK  zlist[Index]r9   r   r’  r   )r\  r>  r’  r%   )r   TN)rÙ   r"   rŒ  r”  r’  r   )KrK   Ú
__module__Ú__qualname__Ú__doc__Ú_typr   rX   Ú__annotations__Úpropertyr5   rI   ÚclassmethodrN   r>   r;   r   r\   rb   re   rm   rr   r€   rD   rE   rF   r‹   rŽ   rG   r“   r—   rš   rŸ   r¢   r   r   r©   r°   r¹   r¼   r¿   rÇ   r   rÉ   r=   rÓ   rÏ   ry   rå   rë   rí   r   rô   r   rÿ   r  r  r  r  r-  r6  r?  rC  rI  rR  rT  rZ  rX  r!   r^  rH  rc  re  ro  r‘  Ú__classcell__)r·   s   @r4   r(   r(   B   s  ø… ñ8ðt €DØ"9Ð;KÐ!LÐØƒMØÓàò$ó ð$ð ØØØ"ØØ $ð"/ð
 ð"/ð ð"/ð ð"/ð 
ó"/ðH ó0ó ð0ð6 à48ðØðØ"1ðà	òó ðð òó ðð òó ðð
 òKó ðKóNò
7òóDð ò!ó ð!ð" ò ó ð ð  ò ó ð ð0 ò
ó ð
ôð2 òó ðð òó ðð ò6ó ð6ð ò6ó ð6ó"ð òó ðñ 	ˆ�‰Óò
ó ð
ð "Ø Øð)àð)ð ð)ð ð	)ð 
õ)ð< òó ðó!ñ 	ˆ�‰Óòó ðñ 	ˆ×	Ñ	ÓØ5?ó Dó ðDóñ
 	ˆ�‰ƒ_óó ðó
1ô#ô#óð8 Ø $ð
àð
ð ð
ð 
1ó	
õ%ð ð *-ØØ"%Ø"ñð 'ðð ð	ð
  ðð ðð 
òó ðð ð
 Ø"%Ø"ñð &ðð ð	ð
  ðð ðð 
.òó ðð ð  #ØØ"%Ø"ñð ðð ð	ð
  ðð ðð 
5òó ðñ $Ø V H°=ôð
  %ØØ"(Ø#ð! àð! ð ð! ð  ð	! ð
 ð! ð 
5ô! óð! öL,ó\6ó
#ó"	GõI0õVUðp @DðØ"1õõ$#õ,)õ*;-óz ð òó ðô(ó.<ñ ˜nÓ-ó+ó .ð+ó$$ó ô
.ôH4ð^ ØØð'Dð ð'Dð ð	'Dð 
÷'Dr6   r(   )GÚ
__future__r   Úcollections.abcr   r   Údatetimer   rq  Úsysr   Útypingr   r	   r
   r   r   r   Únumpyr_   Úpandas._libsr   r0   r   Úpandas._libs.algosr   Úpandas._libs.libr   Úpandas.compat.numpyr   rÕ   Úpandas.util._decoratorsr   r   r   Úpandas.core.dtypes.commonr   r   r   r   r   r   Úpandas.core.dtypes.genericr   Úpandas.corer   Úpandas.core.commonÚcoreÚcommonr?   Úpandas.core.constructionr   Úpandas.core.indexes.baserK  Úbaseri   r   r    Úpandas.core.ops.commonr!   Úpandas._typingr"   r#   r$   r%   r&   r*   r   rG   ra   r�   r(   r’   r6   r4   ú<module>r¹     s¨   ðÝ "÷õ Û Ý ÷÷ ó ÷õ -Ý 'Ý .÷ñ ÷÷ õ 9å ß  Ð  Ý 2ß (Ó (÷õ <á÷õ ñ �Q‹x€Øˆr�x‰x˜Ÿ™Ó!€ôaD�õ aDr6   