Ë
   tcøÈzàã            	       óx  — U d Z ddlZddlmc mZ ddlZddlZddl	Z	ddl
Z
ddlZddlZddlmZ ddlmZmZmZmZ ddlmZ ddlmZmZmZmZmZmZmZ ddlmZ ddlm Z   ed	«      Z!d
edede"fd„Z#dee!   dee$e%e%ee!   f      de&e!   fd„Z' G d„ dee%   «      Z(de%de%dee%ge"f   de%fd„Z) G d„ dee!   «      Z*de%fd„Z+ G d„ d«      Z, e,«       Z- e«       Z. G d„ d«      Z/dee%ge"f   de%fd„Z0da1da2e3e4d <   da5e3e4d!<   ejl                  Z7de3fd"„Z8d#ee!   d$ee!   de"fd%„Z9d#ee!   d$ee!   de"fd&„Z:d'e%de%fd(„Z;y))z¢A module for miscellaneous useful bits and bobs that don't
obviously belong anywhere else. If you spot a better home for
anything that lives here, please move it.é    N)Ú	ArrayType)ÚCallableÚIterableÚIteratorÚSequence)ÚLock)ÚAnyÚClassVarÚGenericÚLiteralÚTypeVarÚUnionÚoverload)ÚHypothesisWarning)Úfloat_to_intÚTÚaÚbÚreturnc                 ó,  — t        | «      t        |«      uryt        | t        «      rt        | «      t        |«      k(  S t        | t        t
        f«      r3t        | «      t        |«      k(  xr t        t        t        | |«      «      S t        | |k(  «      S )a’  Like ==, but requires identical types (so True != 1 != 1.0) and
    compares floats by bitpattern (so nan == nan and 0.0 != -0.0), applying
    both rules elementwise through lists and tuples.

    Values of any other type - dicts, sets, arbitrary objects - are compared
    by plain == after the type check, so a NaN, signed zero, or bool/int
    confusion nested inside them is missed: a NaN there compares unequal and
    a nested True matches 1. Callers use this for best-effort,
    replay-verified inversion, where such a miss costs a widening opportunity
    - the replay produces a wrong or unequal value and is rejected - never
    correctness.
    F)ÚtypeÚ
isinstanceÚfloatr   ÚlistÚtupleÚlenÚallÚmapÚequal_valuesÚbool)r   r   s     ún/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/internal/conjecture/junkdrawer.pyr   r   (   sv   € ô ˆAƒw”d˜1“gÑØÜ�!”UÔä˜A‹¤,¨q£/Ñ1Ð1Ü�!”dœE�]Ô#Ü�1‹vœ˜Q›ÑÒ@¤C¬¬L¸!¸QÓ(?Ó$@Ð@Ü��Q‘‹<Ðó    ÚlsÚreplacementsc           
      óž  — g }d}d}|D ]A  \  }}}|j                  | || «       |j                  |«       |}|t        |«      ||z
  z
  z  }ŒC |j                  | |d «       t        |«      }t        | «      }	|	|z   }
||
k(  }|�sÁt        j                  d|fd||
f«      dt	        j
                  «       v st        j                  t        «      rt        j                  t        «      nddt	        j
                  «       v st        j                  |«      rt        j                  |«      ndt        j                  |«      dt	        j
                  «       v st        j                  t        «      rt        j                  t        «      nddt	        j
                  «       v st        j                  | «      rt        j                  | «      ndt        j                  |	«      dt	        j
                  «       v st        j                  |«      rt        j                  |«      ndd	œz  }d
d|iz  }t        t        j                  |«      «      ‚dx}x}x}	}
|S )ztSubstitute multiple replacement values into a list.

    Replacements is a list of (start, end, value) triples.
    r   N)ú==)zZ%(py3)s
{%(py3)s = %(py0)s(%(py1)s)
} == (%(py8)s
{%(py8)s = %(py5)s(%(py6)s)
} + %(py9)s)r   Úresultr#   Úoffset)Úpy0Úpy1Úpy3Úpy5Úpy6Úpy8Úpy9zassert %(py12)sÚpy12)
Úextendr   Ú
@pytest_arÚ_call_reprcompareÚ@py_builtinsÚlocalsÚ_should_repr_global_nameÚ	_safereprÚAssertionErrorÚ_format_explanation)r#   r$   r'   Úprevr(   ÚuÚvÚrÚ@py_assert2Ú@py_assert7Ú@py_assert10Ú@py_assert4Ú@py_format11Ú@py_format13s                 r!   Úreplace_allrD   ?   st  € ð €FØ€DØ€FØò #‰ˆˆ1ˆaØ�‰�b˜˜a�jÔ!Ø�‰�aÔØˆØ”#�a“&˜A ™EÑ"Ñ"‰ð	#ð
 ‡M�M�"�T�U�)ÔÜˆv‹;Ð*œ#˜b›'Ð*˜' FÑ*Ð*ˆ;Ð*Ñ*×*×*Ö*ˆ;Ð*×*×*×*×*×*Ñ*Œ3×*×*Ó*Œ3×*×*×*×*×*Ò*ˆv×*×*Ó*ˆv×*×*Ô*ˆ;×*×*×*×*×*Ð*œ#×*×*Ó*œ#×*×*×*×*×*Ò*˜b×*×*Ó*˜b×*×*Ô*˜'×*×*×*×*×*Ð* F×*×*Ó* F×*×*×*×*×*×*×*Ø€Mr"   c            	       óð  — e Zd ZU dZg d¢Zeee      ed<    e	 e
j                  e«      «      Zee	eef      ed<   dZd&dee   fd„Zeded	d fd
„«       Zededee   d	eee   df   fd„«       Zded	efd„Zd	efd„Zd	efd„Zeded	efd„«       Zeded	dfd„«       Zdeez  d	dfd„Zdeez  d	dfd„Zdeded	dfd„Zd	ee   fd„Z de!d	e"fd„Z#de!d	e"fd „Z$ded	dfd!„Z%deded	dfd"„Z&d#ee   d	dfd$„Z'd'd%„Z(y)(ÚIntLista  Class for storing a list of non-negative integers compactly.

    We store them as the smallest size integer array we can get
    away with. When we try to add an integer that is too large,
    we upgrade the array to the smallest word size needed to store
    the new value.)ÚBÚHÚIÚLÚQÚOÚARRAY_CODESÚNEXT_ARRAY_CODE)Ú__underlyingÚvaluesc                 ó
  — | j                   D ]  }	 | j                  ||«      } n t        d|›�«      ‚t	        |t
        «      r*|D ]%  }t	        |t        «      r|dk  sŒt        d|›�«      ‚ || _        y # t        $ r Y Œtw xY w)NzCould not create storage for r   zCould not create IntList for )	rM   Ú_array_or_listÚOverflowErrorr8   r   r   ÚintÚ
ValueErrorÚ_IntList__underlying)ÚselfrP   ÚcodeÚ
underlyingr<   s        r!   Ú__init__zIntList.__init__b   s¥   € Ø×$Ñ$ò 	MˆDðØ!×0Ñ0°°vÓ>�
Ùð	Mô !Ð#@ÀÀ
Ð!KÓLÐLÜ�j¤$Ô'Øò Q�Ü! !¤SÔ)¨Q°«UÜ$Ð'DÀVÀJÐ%OÓPÐPðQð 9CˆÕøô !ò Ùðús   ‘A6Á6	BÂBÚnr   c                 óB   —  | t        j                   ddg«      |z  «      S )NrG   r   )Úarray)Úclsr[   s     r!   Ú	of_lengthzIntList.of_lengthq   s   € á”5—;‘;˜s Q CÓ(¨1Ñ,Ó-Ð-r"   rX   ÚcontentszArrayType[int]c                 óN   — | dk(  rt        |«      S t        j                  | |«      S )NrL   )r   r]   )rX   r`   s     r!   rR   zIntList._array_or_listu   s&   € ð �3Š;Ü˜“>Ð!Ü�{‰{˜4 Ó*Ð*r"   Úvaluec                 ó8   — | j                   j                  |«      S ©N)rV   Úcount)rW   rb   s     r!   re   zIntList.count}   s   € Ø× Ñ ×&Ñ& uÓ-Ð-r"   c                 ó4   — dt        | j                  «      ›d�S )NzIntList(ú))r   rV   ©rW   s    r!   Ú__repr__zIntList.__repr__€   s   € Øœ$˜t×0Ñ0Ó1Ð4°AÐ6Ð6r"   c                 ó,   — t        | j                  «      S rd   )r   rV   rh   s    r!   Ú__len__zIntList.__len__ƒ   s   € Ü�4×$Ñ$Ó%Ð%r"   Úic                  ó   — y rd   © ©rW   rl   s     r!   Ú__getitem__zIntList.__getitem__†   s   € Ø*-r"   zlist[int] | ArrayType[int]c                  ó   — y rd   rn   ro   s     r!   rp   zIntList.__getitem__‰   s   € ØEHr"   z int | list[int] | ArrayType[int]c                 ó    — | j                   |   S rd   ©rV   ro   s     r!   rp   zIntList.__getitem__Œ   s   € Ø× Ñ  Ñ#Ð#r"   Nc                 ó   — | j                   |= y rd   rs   ro   s     r!   Ú__delitem__zIntList.__delitem__�   s   € Ø×Ñ˜aÑ r"   r<   c                 ó<   — | j                   j                  ||«       y rd   )rV   Úinsert)rW   rl   r<   s      r!   rw   zIntList.insert’   s   € Ø×Ñ× Ñ   AÕ&r"   c                 ó,   — t        | j                  «      S rd   )ÚiterrV   rh   s    r!   Ú__iter__zIntList.__iter__•   s   € Ü�D×%Ñ%Ó&Ð&r"   Úotherc                 ój   — | |u ryt        |t        «      st        S | j                  |j                  k(  S )NT©r   rF   ÚNotImplementedrV   ©rW   r{   s     r!   Ú__eq__zIntList.__eq__˜   s3   € Ø�5‰=ØÜ˜%¤Ô)Ü!Ð!Ø× Ñ  E×$6Ñ$6Ñ6Ð6r"   c                 ój   — | |u ryt        |t        «      st        S | j                  |j                  k7  S )NFr}   r   s     r!   Ú__ne__zIntList.__ne__Ÿ   s3   € Ø�5‰=ØÜ˜%¤Ô)Ü!Ð!Ø× Ñ  E×$6Ñ$6Ñ6Ð6r"   c                 óÄ   — 	 | j                   j                  |«       y # t        $ r8 t        | j                   «      }| j                   j                  d«       || |<   Y y w xY w©Nr   )rV   ÚappendrS   r   )rW   r[   rl   s      r!   r…   zIntList.append¦   sW   € ð	Ø×Ñ×$Ñ$ QÕ'øÜò 	Ü�D×%Ñ%Ó&ˆAØ×Ñ×$Ñ$ QÔ'ØˆD�‹Gð	ús   ‚ ž>AÁAc                 ó²  — 	 	 || j                   |<   y # t        $ r¹ d}||kD  }|s™t        j                  d|fd||f«      dt	        j
                  «       v st        j                  |«      rt        j                  |«      ndt        j                  |«      dœz  }dd|iz  }t        t        j                  |«      «      ‚d x}}| j                  «        Y nw xY wŒ×)Nr   ©ú>)z%(py0)s > %(py3)sr[   ©r)   r+   úassert %(py5)sr,   )rV   rS   r2   r3   r4   r5   r6   r7   r8   r9   Ú_IntList__upgrade)rW   rl   r[   r>   Ú@py_assert1Ú@py_format4Ú@py_format6s          r!   Ú__setitem__zIntList.__setitem__°   s|   € Øð!Ø'(�×!Ñ! !Ñ$ØøÜ ò !Ø��q˜1‘u——•�q˜1—————‘�q——“�q——”˜1——————‘Ø—‘Ö ð!úð	 s   ƒ “B?CÃCr#   c                 ó4   — |D ]  }| j                  |«       Œ y rd   )r…   )rW   r#   r[   s      r!   r1   zIntList.extend¹   s   € Øò 	ˆAØ�K‰K˜�Nñ	r"   c           	      óT  — | j                   }t        j                  }t        ||«      }|�s3ddt        j                  «       v st        j                  t        «      rt        j                  t        «      nddt        j                  «       v st        j                  | «      rt        j                  | «      ndt        j                  |«      dt        j                  «       v st        j                  t        «      rt        j                  t        «      ndt        j                  |«      t        j                  |«      dœz  }t        t        j                  |«      «      ‚d x}x}}| j                  | j                   j                     }| j                  || j                   «      | _         y )Nzrassert %(py8)s
{%(py8)s = %(py0)s(%(py3)s
{%(py3)s = %(py1)s.__underlying
}, %(py6)s
{%(py6)s = %(py4)s.array
})
}r   rW   r]   )r)   r*   r+   Úpy4r-   r.   )rV   r]   r   r4   r5   r2   r6   r7   r8   r9   rN   ÚtypecoderR   )rW   r>   Ú@py_assert5r?   Ú@py_format9rX   s         r!   Ú	__upgradezIntList.__upgrade½   sí   € Ø×+Ñ+Ð9¬U¯[©[Ð9ŒzÐ+¨[Ó9Ð9Ò9×9×9×9×9Õ9Œz×9×9Ó9Œz×9×9×9×9×9Ò9˜$×9×9Ó9˜$×9×9Ô9Ð+×9×9×9×9×9Ð9¬U×9×9Ó9¬U×9×9Ô9¨[×9×9Ò9Ð9×9×9×9×9×9Ô9Ø×#Ñ# D×$5Ñ$5×$>Ñ$>Ñ?ˆØ ×/Ñ/°°d×6GÑ6GÓHˆÕr"   )rn   ©r   N))Ú__name__Ú
__module__Ú__qualname__Ú__doc__rM   r
   r   ÚstrÚ__annotations__ÚdictÚ	itertoolsÚpairwiserN   Ú	__slots__r   rT   rZ   Úclassmethodr_   Ústaticmethodr   r   rR   re   ri   rk   r   rp   Úsliceru   rw   r   rz   Úobjectr    r€   r‚   r…   r�   r1   r‹   rn   r"   r!   rF   rF   U   sæ  … ñò (F€K�˜$˜s™)Ñ$ÓEÙ04Ð5G°Y×5GÑ5GÈÓ5TÓ0U€O�X˜d 3¨ 8™nÑ-ÓUà!€IñC˜x¨™}ó Cð ð.˜#ð . )ò .ó ð.ð ð+Øð+Ø% c™]ð+à	ˆt�C‰yÐ*Ð*Ñ	+ò+ó ð+ð.˜3ð . 3ó .ð7˜#ó 7ð&˜ó &ð Ø-˜SÐ- SÒ-ó Ø-àØH˜UÐHÐ'CÒHó ØHð$˜S 5™[ð $Ð-Oó $ð!˜S 5™[ð !¨Tó !ð'˜ð ' ð '¨ó 'ð'˜( 3™-ó 'ð7˜Fð 7 tó 7ð7˜Fð 7 tó 7ð˜ð  ó ð!˜Sð ! Sð !¨Tó !ð˜ #™ð ¨4ó ôIr"   rF   ÚloÚhiÚfc                 óh   —  || «      }| dz   |k  r!| |z   dz  } ||«      |k(  r|} n|}| dz   |k  rŒ!| S )z¬Binary searches in [lo , hi) to find
    n such that f(n) == f(lo) but f(n + 1) != f(lo).
    It is implicitly assumed and will not be checked
    that f(hi) != f(lo).
    é   é   rn   )r¦   r§   r¨   Ú	referenceÚmids        r!   Úbinary_searchr®   Ã   sO   € ñ �"“€Ià
ˆq‰&�2Š+Ø�B‰w˜1‰nˆÙˆS‹6�YÒØ‰BàˆBð ˆq‰&�2‹+ð €Ir"   c                   ó¤   — e Zd ZdZdee   fd„Zdefd„Zddedefd„Z	dededd	fd
„Z
dedefd„Zdededd	fd„Zdedeeef   fd„Zdee   fd„Zy	)ÚLazySequenceCopyaE  A "copy" of a sequence that works by inserting a mask in front
    of the underlying sequence, so that you can mutate it without changing
    the underlying sequence. Effectively behaves as if you could do list(x)
    in O(1) time. The full list API is not supported yet but there's no reason
    in principle it couldn't be.rP   c                 óN   — || _         t        |«      | _        d | _        d | _        y rd   )Ú_LazySequenceCopy__valuesr   Ú_LazySequenceCopy__lenÚ_LazySequenceCopy__maskÚ_LazySequenceCopy__popped_at)rW   rP   s     r!   rZ   zLazySequenceCopy.__init__Ü   s%   € ØˆŒÜ˜“[ˆŒ
Ø+/ˆŒð .2ˆÕr"   r   c                 óv   — | j                   €| j                  S | j                  t        | j                   «      z
  S rd   )rµ   r³   r   rh   s    r!   rk   zLazySequenceCopy.__len__ä   s2   € Ø×ÑÐ#Ø—:‘:ÐØ�z‰zœC × 0Ñ 0Ó1Ñ1Ð1r"   rl   c                 ó2  — t        | «      dk(  rt        d«      ‚| j                  |«      \  }}d }| j                  �| j                  j	                  |d «      }|€| j
                  |   }| j                  €g | _        | j                  j                  |«       |S )Nr   zCannot pop from empty list)r   Ú
IndexErrorÚ#_LazySequenceCopy__underlying_indexr´   Úpopr²   rµ   r…   )rW   rl   r;   r<   s       r!   rº   zLazySequenceCopy.popé   s�   € Üˆt‹9˜Š>ÜÐ9Ó:Ð:Ø×&Ñ& qÓ)‰ˆˆ1àˆØ�;‰;Ð"Ø—‘—‘  4Ó(ˆAØˆ9Ø—‘˜aÑ ˆAà×ÑÐ#Ø!ˆDÔØ×Ñ×Ñ Ô"Øˆr"   ÚjNc                 ó2   — ||k(  ry| |   | |   c| |<   | |<   y)zSwap the elements ls[i], ls[j].Nrn   )rW   rl   r»   s      r!   ÚswapzLazySequenceCopy.swapù   s(   € à�Š6ØØ ™7 D¨¡GÐˆˆQ‰��a’r"   c                 óœ   — | j                  |«      \  }}| j                  |   }| j                  €|S | j                  j                  ||«      S rd   )r¹   r²   r´   Úget)rW   rl   Ú_Údefaults       r!   rp   zLazySequenceCopy.__getitem__ÿ   sH   € Ø×&Ñ& qÓ)‰ˆˆ1à—-‘- Ñ"ˆØ�;‰;ÐØˆNà—;‘;—?‘? 1 gÓ.Ð.r"   r<   c                 óp   — | j                  |«      \  }}| j                  €i | _        || j                  |<   y rd   )r¹   r´   )rW   rl   r<   rÀ   s       r!   r�   zLazySequenceCopy.__setitem__  s4   € Ø×&Ñ& qÓ)‰ˆˆ1Ø�;‰;ÐØˆDŒKØˆ�‰�AŠr"   c                 ó„  — t        | «      }|| k  s||k\  rt        d|› d|› d�«      ‚|dk  r||z  }d}||k  }||k  }|r|sÜt        j                  d||fd|||f«      t        j                  |«      dt        j                  «       v st        j                  |«      rt        j                  |«      nddt        j                  «       v st        j                  |«      rt        j                  |«      ndd	œz  }d
d|iz  }t        t        j                  |«      «      ‚d x}x}}|}| j                  ��
| j                  }t        |«      }	| j                  }
t        |
«      }|	|k  }|�s¨t        j                  d|fd|	|f«      dt        j                  «       v st        j                  t         «      rt        j                  t         «      nddt        j                  «       v st        j                  | «      rt        j                  | «      ndt        j                  |«      t        j                  |	«      dt        j                  «       v st        j                  t         «      rt        j                  t         «      nddt        j                  «       v st        j                  | «      rt        j                  | «      ndt        j                  |
«      t        j                  |«      dœz  }dd|iz  }t        t        j                  |«      «      ‚d x}x}	x}x}
}t        | j                  «      D ]
  }|||k  z  }Œ ||fS )NzIndex z out of range [0, rg   r   )ú<=ú<)z%(py1)s <= %(py4)sz%(py4)s < %(py5)srl   r[   )r*   r’   r,   úassert %(py7)sÚpy7©rÄ   )z‘%(py5)s
{%(py5)s = %(py0)s(%(py3)s
{%(py3)s = %(py1)s.__popped_at
})
} <= %(py12)s
{%(py12)s = %(py7)s(%(py10)s
{%(py10)s = %(py8)s.__values
})
}r   rW   )r)   r*   r+   r,   rÇ   r.   Úpy10r0   zassert %(py14)sÚpy14)r   r¸   r2   r3   r7   r4   r5   r6   r8   r9   rµ   r²   Úreversed)rW   rl   r[   Ú@py_assert0r>   Ú@py_assert3rŽ   Ú@py_format8r;   rA   Ú@py_assert9Ú@py_assert11Ú@py_assert6rC   Ú@py_format15Úps                   r!   Ú__underlying_indexz#LazySequenceCopy.__underlying_index  s  € ô$ �‹IˆØ�ˆrŠ6�Q˜!’VÜ˜v a SÐ(:¸1¸#¸QÐ?Ó@Ð@ØˆqŠ5Ø�‰FˆAØÐˆq�A‰zÐ�A˜‰z×××Ðˆq�A˜××Óˆq×××××Ð�A××Ó�A×××××Ò˜××Ó˜××××××ÕàˆØ×ÑÑ'Ø×'Ñ'Ð>”3Ð'Ó(Ð>°·±Ð>¬C°Ó,>Ð>Ð(Ð,>Ñ>×>×>Ö>Ð(Ð,>×>×>×>×>×>Ñ>”3×>×>Ó>”3×>×>×>×>×>Ò>�t×>×>Ó>�t×>×>Ô>Ð'×>×>Ò>Ð(×>×>×>×>×>Ð>¬C×>×>Ó>¬C×>×>×>×>×>Ò>°×>×>Ó>°×>×>Ô>°×>×>Ò>Ð,>×>×>×>×>×>×>×>Ü˜d×.Ñ.Ó/ò �Ø�Q˜!‘V‘‘ðà�!ˆtˆr"   c              #   óL   K  — t        t        | «      «      D ]	  }| |   –— Œ y ­wrd   )Úranger   ro   s     r!   rz   zLazySequenceCopy.__iter__/  s'   è ø€ Ü”s˜4“yÓ!ò 	ˆAØ�q‘'‹Mñ	ùs   ‚"$)éÿÿÿÿ)r˜   r™   rš   r›   r   r   rZ   rT   rk   rº   r½   rp   r�   r   r¹   r   rz   rn   r"   r!   r°   r°   Õ   s©   „ ñ$ð2˜x¨™{ó 2ð2˜ó 2ñ
�Sð  !ó ð ,�cð ,˜cð , dó ,ð/˜Sð / Qó /ð˜Sð  Qð ¨4ó ð Cð ¨E°#°s°(©Oó ðB˜( 1™+ô r"   r°   c                  ó`   — t        j                  d«      } d}| r| j                  } |dz  }| rŒ|S )aJ  Get stack size for caller's frame.

    From https://stackoverflow.com/a/47956089/9297601 , this is a simple
    but much faster alternative to `len(inspect.stack(0))`.  We use it
    with get/set recursionlimit to make stack overflows non-flaky; see
    https://github.com/HypothesisWorks/hypothesis/issues/2494 for details.
    r«   rª   )ÚsysÚ	_getframeÚf_back)ÚframeÚsizes     r!   Ústack_depth_of_callerrÞ   4  s8   € ô �M‰M˜!Ó€EØ€DÙ
Ø—‘ˆØ�‰	ˆò ð €Kr"   c                   óZ   — e Zd Zd„ Zddœdededdfd„Zded	eddfd
„Zddœdededdfd„Zy)ÚStackframeLimiterc                 ó>   — d| _         t        «       | _        d | _        y r„   )Ú_active_contextsÚsetÚ_known_limitsÚ_original_limitrh   s    r!   rZ   zStackframeLimiter.__init__S  s   € Ø !ˆÔÜ'*£uˆÔØ+/ˆÕr"   T©ÚcheckÚ	new_limitrç   r   Nc                ó  — |rPt        j                  «       x}| j                  vr.t        j                  d| j
                  › d|› d�t        d¬«       y | j                  j                  |«       t        j                  |«       y )NzXThe recursion limit will not be reset, since it was changed during test execution (from z to z).é   )Ú
stacklevel)	rÙ   Úgetrecursionlimiträ   ÚwarningsÚwarnrå   r   ÚaddÚsetrecursionlimit)rW   rè   rç   Úcurrent_limits       r!   Ú_setrecursionlimitz$StackframeLimiter._setrecursionlimitX  sz   € áÜ"%×"7Ñ"7Ó"9Ð9�À$×BTÑBTÑTä�M‰Mð/Ø/3×/CÑ/CÐ.DÀDÈÈÐWYð[ä!Øõ	ð à×Ñ×Ñ˜yÔ)Ü×Ñ˜iÕ(r"   rñ   c                óT  — | j                   dk(  ró| j                  }d }||u }|s­t        j                  d|fd||f«      dt	        j
                  «       v st        j                  | «      rt        j                  | «      ndt        j                  |«      t        j                  |«      dœz  }dd|iz  }t        t        j                  |«      «      ‚d x}x}}|| _        | j                  j                  | j                  «       | xj                   dz  c_         | j                  |«       y )	Nr   )Úis)z7%(py2)s
{%(py2)s = %(py0)s._original_limit
} is %(py5)srW   ©r)   Úpy2r,   rÆ   rÇ   rª   )râ   rå   r2   r3   r4   r5   r6   r7   r8   r9   rä   rï   rò   )rW   rè   rñ   rŒ   rA   rÍ   rŽ   rÎ   s           r!   Úenter_contextzStackframeLimiter.enter_contexth  sÅ   € Ø× Ñ  AÒ%ð ×'Ñ'Ð/¨4Ð/Ð'¨4Ð/×/×/Õ/Ð'¨4×/×/×/×/×/Ñ/�4×/×/Ó/�4×/×/Ô/Ð'×/×/Ò/¨4×/×/×/×/×/×/Ó/Ø#0ˆDÔ Ø×Ñ×"Ñ" 4×#7Ñ#7Ô8à×Ò Ñ"ÕØ×Ñ 	Õ*r"   c                óÔ  — | j                   }d}||kD  }|s­t        j                  d|fd||f«      dt        j                  «       v st        j
                  | «      rt        j                  | «      ndt        j                  |«      t        j                  |«      dœz  }dd|iz  }t        t        j                  |«      «      ‚d x}x}}| xj                   dz  c_         | j                   dk(  rÕ| j                  }d }	||	u}|s™t        j                  d	|fd
||	f«      dt        j                  «       v st        j
                  |«      rt        j                  |«      ndt        j                  |	«      dœz  }
dd|
iz  }t        t        j                  |«      «      ‚d x}}		 | j                  ||¬«       d | _	        |h| _        y | j                  ||¬«       y # d | _	        |h| _        w xY w)Nr   r‡   )z7%(py2)s
{%(py2)s = %(py0)s._active_contexts
} > %(py5)srW   rõ   rÆ   rÇ   rª   )úis not)z%(py0)s is not %(py3)sÚoriginal_limitr‰   rŠ   r,   ræ   )râ   r2   r3   r4   r5   r6   r7   r8   r9   rå   rò   rä   )rW   rè   rç   rŒ   rA   rÍ   rŽ   rÎ   rú   r>   r�   s              r!   Úexit_contextzStackframeLimiter.exit_contexts  sR  € Ø×$Ñ$Ð( qÐ(Ð$ qÑ(×(×(Õ(Ð$ q×(×(×(×(×(Ñ(ˆt×(×(Ó(ˆt×(×(Ô(Ð$×(×(Ò( q×(×(×(×(×(×(Ó(Ø×Ò Ñ"Õà× Ñ  AÒ%ð "×1Ñ1ˆNØ)-Ð-�>¨Ð-×-×-Õ-�>¨×-×-×-×-×-Ñ-�>×-×-Ó-�>×-×-Ô-¨×-×-×-×-×-×-Ñ-ð6Ø×'Ñ'¨¸eÐ'ÔDà'+�Ô$ð '5Ð%5�Õ"à×#Ñ# I°UÐ#Õ;øð (,�Ô$ð '5Ð%5�Õ"ús   ÆG ÇG')	r˜   r™   rš   rZ   rT   r    rò   r÷   rû   rn   r"   r!   rà   rà   D  sb   „ ò0ð
 CGò )¨Cð )¸4ð )È4ó )ð 	+ sð 	+¸cð 	+Àdó 	+ð =Aò < cð <°Tð <ÀTô <r"   rà   c                   ó   — e Zd ZdZdd„Zd„ Zy)Úensure_free_stackframeszjContext manager that ensures there are at least N free stackframes (for
    a reasonable value of N).
    Nc                 ó  — t        «       }t        5  t        j                  «       | _        |dz   | _        d}||k  }|s×t        j                  d|fd||f«      dt        j                  «       v st        j                  |«      rt        j                  |«      ndt        j                  |«      dœz  }t        j                  d| j
                  | j                  z
  › d| j                  › d	�«      d
z   d|iz  }t        t        j                  |«      «      ‚d x}}	 t        j!                  | j
                  | j                  ¬«       	 d d d «       y # t"        $ r# t        j%                  | j                  d¬«       ‚ w xY w# 1 sw Y   y xY w)NiÐ  iè  rÈ   )z%(py0)s <= %(py3)sÚ	cur_depthr‰   zHypothesis would usually add z to the stack depth of z} here, but we are already much deeper than expected.  Aborting now, to avoid extending the stack limit in an infinite loop...z
>assert %(py5)sr,   )rñ   Fræ   )rÞ   Ú_stackframe_limiter_lockrÙ   rì   Ú	old_limitrè   r2   r3   r4   r5   r6   r7   Ú_format_assertmsgr8   r9   Ú_stackframe_limiterr÷   Ú	Exceptionrû   )rW   rÿ   r>   rŒ   r�   rŽ   s         r!   Ú	__enter__z!ensure_free_stackframes.__enter__�  sf  € Ü)Ó+ˆ	Ü%ñ 	Ü ×2Ñ2Ó4ˆDŒNð '¨Ñ-ˆDŒNð !%ð �9 Ñ$÷ ï
é ó�9 ÷ ò ÷
 �v÷ò ï
é ð ÷ ñ ÷
 �Ið ÷ ò ÷
 �Ið !%÷ õ ï
é ð	 0°·±ÀÇÁÑ0OÐ/Pð Q&Ø&*§n¡nÐ%5ð 6/ð/÷÷ ö ï
é ÷õ ð
Ü#×1Ñ1Ø—N‘N°$·.±.ð 2õ ÷#	ð 	øô( ò ô
 $×0Ñ0°·±ÀuÐ0ÔMØðú÷)	ð 	ús   ‘DE>Ä+EÅ,E;Å;E>Å>Fc                 óx   — t         5  t        j                  | j                  «       d d d «       y # 1 sw Y   y xY wrd   )r   r  rû   r  )rW   ÚargsÚkwargss      r!   Ú__exit__z ensure_free_stackframes.__exit__®  s,   € Ü%ñ 	=Ü×,Ñ,¨T¯^©^Ô<÷	=÷ 	=ñ 	=ús   ‡ 0°9r—   )r˜   r™   rš   r›   r  r	  rn   r"   r!   rý   rý   ‹  s   „ ñóó<=r"   rý   c                 óÊ   — t        dd«      D ]  } | |«      rŒ|dz
  c S  d}d} | |«      r|}|dz  } | |«      rŒ|dz   |k  r||z   dz  } | |«      r|}n|}|dz   |k  rŒ|S )z‘Finds a (hopefully large) integer such that f(n) is True and f(n + 1) is
    False.

    f(0) is assumed to be True and will not be checked.
    rª   é   rê   r«   )rÖ   )r¨   rl   r¦   r§   r­   s        r!   Úfind_integerr  ³  s”   € ô �1�a‹[ò ˆÙ��tØ�q‘5ŠLðð 
€Bð
 
€BÙ
ˆBŒ%ØˆØ
ˆa‰ˆñ ˆB�%ð ˆq‰&�2Š+Ø�B‰w˜1‰nˆÙˆSŒ6Ø‰BàˆBð ˆq‰&�2‹+ð €Ir"   FÚ	_gc_startÚ_gc_cumulative_timec                  ó¸  — t         sÏt        t        d«      rCdt        d   dt        t
        t        f   dd fd„} t        j                  j                  d| «       nzt        t        d«      rjd	t        dd fd
„}t        j                  j                  €|t        j                  _        t        j                  j                  €|t        j                  _        da t        S )NÚ	callbacksÚphase)ÚstartÚstopÚinfor   c                 óŒ   — 	 t        «       }| dk(  r|ay | dk(  rt        dkD  rt        |t        z
  z  ay y y # t        $ r daY y w xY w)Nr  r  r   )Ú_perf_counterr  r  ÚRecursionError)r  r  Únows      r!   Úgc_callbackz'gc_cumulative_time.<locals>.gc_callbackì  sW   € ðÜ'›/�CØ Ò'Ø$'™	Ø &š¬Y¸ª]Ü+¨s´Y©Ñ>Ñ+ð .;˜øä%ò 	ð !"�IÙð	ús   ‚5 ”5 µAÁAr   ÚhooksÚstatsc                 óJ   — 	 t         | j                  z  a y # t        $ r Y y w xY wrd   )r  Údurationr  )r  s    r!   Úhookz gc_cumulative_time.<locals>.hook  s(   € ðÜ'¨5¯>©>Ñ9Ñ'øÜ%ò Ùðús   ‚ –	"¡"T)Ú_gc_initializedÚhasattrÚgcr   rž   rœ   rT   r  rw   r	   r  Úon_gc_minorÚon_gc_collect_stepr  )r  r  s     r!   Úgc_cumulative_timer$  â  s³   € õ Ü”2�{Ô#ðÜ˜Ñ/ðÜ7;¼CÄ¸H±~ðàóô* �L‰L×Ñ  ;Õ/Ü”R˜Ô!ðœCð  Dó ô �x‰x×#Ñ#Ð+Ø'+”—‘Ô$Ü�x‰x×*Ñ*Ð2Ø.2”—‘Ô+àˆäÐr"   Úl1Úl2c           
      ó†   — t        | «      t        |«      k  ryt        d„ t        | d t        |«       |d¬«      D «       «      S )NFc              3   ó,   K  — | ]  \  }}||k(  –— Œ y ­wrd   rn   ©Ú.0Úv1Úv2s      r!   ú	<genexpr>zstartswith.<locals>.<genexpr>  s   è ø€ ÒK™F˜B ˆr�R�xÑKùó   ‚©Ústrict©r   r   Úzip©r%  r&  s     r!   Ú
startswithr4    s9   € Ü
ˆ2ƒw”�R“ÒØÜÑK¤c¨"¨Y¬s°2«w¨-¸ÀEÔ&JÔKÓKÐKr"   c           	      óˆ   — t        | «      t        |«      k  ryt        d„ t        | t        |«       d  |d¬«      D «       «      S )NFc              3   ó,   K  — | ]  \  }}||k(  –— Œ y ­wrd   rn   r)  s      r!   r-  zendswith.<locals>.<genexpr>  s   è ø€ ÒL™F˜B ˆr�R�xÑLùr.  r/  r1  r3  s     r!   Úendswithr7    s;   € Ü
ˆ2ƒw”�R“ÒØÜÑL¤c¨"¬c°"«g¨X¨Z¨.¸"ÀUÔ&KÔLÓLÐLr"   r[   c                 ó   — | dz   dz	  S )z©The number of bytes required to represent an n-bit number.
    Equivalent to (n + 7) // 8, but slightly faster. This really is
    called enough times that that matters.é   é   rn   )r[   s    r!   Úbits_to_bytesr;  !  s   € ð �‰E�a‰<Ðr"   )<r›   Úbuiltinsr4   Ú_pytest.assertion.rewriteÚ	assertionÚrewriter2   r]   r!  rŸ   rÙ   Útimerí   r   Úcollections.abcr   r   r   r   Ú	threadingr   Útypingr	   r
   r   r   r   r   r   Úhypothesis.errorsr   Úhypothesis.internal.floatsr   r   r    r   r   rT   r   rD   rF   r®   r°   rÞ   rà   r  r   rý   r  r  r  r   r�   r  Úperf_counterr  r$  r4  r7  r;  rn   r"   r!   ú<module>rG     sã  ðò-÷ „ ƒÛ 	Û Û 
Û Û Ý ß BÓ BÝ ÷÷ ñ õ 0Ý 3áˆCƒL€ð�Cð ˜Cð  Dó ð.Ø�‰ðà˜5  c¨8°A©;Ð!6Ñ7Ñ8ðð 
ˆ!�Wóô,kIˆh�s‰mô kIð\�cð ˜sð  x°°°t°Ñ'<ð Àó ô$\�w˜q‘zô \ð~˜só ÷ @<ñ @<ñF (Ó)Ð Ù›6Ð ÷%=ñ %=ðP#�H˜c˜U D˜[Ñ)ð #¨có #ðL €Ø€	ˆ5Ó ØÐ �UÓ ð ×!Ñ!€ð0˜Eó 0ðfL�8˜A‘;ð L H¨Q¡Kð L°Dó LðM�˜!‘ð M (¨1¡+ð M°$ó Mð�Sð ˜Sô r"   