Ë
    iKêjbM  ã            	       ó^  — U d 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„Z*da+da,e-e.d <   da/e-e.d!<   ej`                  Z1de-fd"„Z2d#ee   d$ee   defd%„Z3d#ee   d$ee   defd&„Z4d'edefd(„Z5y))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J ‚|S )ztSubstitute multiple replacement values into a list.

    Replacements is a list of (start, end, value) triples.
    r   N)Úextendr   )r#   r$   ÚresultÚprevÚoffsetÚuÚvÚrs           r!   Úreplace_allr-   ?   s–   € ð €FØ€DØ€FØò #‰ˆˆ1ˆaØ�‰�b˜˜a�jÔ!Ø�‰�aÔØˆØ”#�a“&˜A ™EÑ"Ñ"‰ð	#ð
 ‡M�M�"�T�U�)ÔÜˆv‹;œ#˜b›' 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 )	r6   Ú_array_or_listÚOverflowErrorÚAssertionErrorr   r   ÚintÚ
ValueErrorÚ_IntList__underlying)Úselfr9   Ú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 )Nr0   r   )Úarray)ÚclsrE   s     r!   Ú	of_lengthzIntList.of_lengthq   s   € á”5—;‘;˜s Q CÓ(¨1Ñ,Ó-Ð-r"   rB   ÚcontentszArrayType[int]c                 óN   — | dk(  rt        |«      S t        j                  | |«      S )Nr5   )r   rG   )rB   rJ   s     r!   r;   zIntList._array_or_listu   s&   € ð �3Š;Ü˜“>Ð!Ü�{‰{˜4 Ó*Ð*r"   Úvaluec                 ó8   — | j                   j                  |«      S ©N)r@   Úcount)rA   rL   s     r!   rO   zIntList.count}   s   € Ø× Ñ ×&Ñ& uÓ-Ð-r"   c                 ó4   — dt        | j                  «      ›d�S )NzIntList(ú))r   r@   ©rA   s    r!   Ú__repr__zIntList.__repr__€   s   € Øœ$˜t×0Ñ0Ó1Ð4°AÐ6Ð6r"   c                 ó,   — t        | j                  «      S rN   )r   r@   rR   s    r!   Ú__len__zIntList.__len__ƒ   s   € Ü�4×$Ñ$Ó%Ð%r"   Úic                  ó   — y rN   © ©rA   rV   s     r!   Ú__getitem__zIntList.__getitem__†   s   € Ø*-r"   zlist[int] | ArrayType[int]c                  ó   — y rN   rX   rY   s     r!   rZ   zIntList.__getitem__‰   s   € ØEHr"   z int | list[int] | ArrayType[int]c                 ó    — | j                   |   S rN   ©r@   rY   s     r!   rZ   zIntList.__getitem__Œ   s   € Ø× Ñ  Ñ#Ð#r"   Nc                 ó   — | j                   |= y rN   r]   rY   s     r!   Ú__delitem__zIntList.__delitem__�   s   € Ø×Ñ˜aÑ r"   r+   c                 ó<   — | j                   j                  ||«       y rN   )r@   Úinsert)rA   rV   r+   s      r!   ra   zIntList.insert’   s   € Ø×Ñ× Ñ   AÕ&r"   c                 ó,   — t        | j                  «      S rN   )Úiterr@   rR   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   r/   ÚNotImplementedr@   ©rA   re   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 )NFrg   ri   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   )r@   Úappendr<   r   )rA   rE   rV   s      r!   ro   zIntList.append¦   sW   € ð	Ø×Ñ×$Ñ$ QÕ'øÜò 	Ü�D×%Ñ%Ó&ˆAØ×Ñ×$Ñ$ QÔ'ØˆD�‹Gð	ús   ‚ ž>AÁAc                 ót   — 	 	 || j                   |<   y # t        $ r |dkD  sJ ‚| j                  «        Y nw xY wŒ8rn   )r@   r<   Ú_IntList__upgrade)rA   rV   rE   s      r!   Ú__setitem__zIntList.__setitem__°   sF   € Øð!Ø'(�×!Ñ! !Ñ$ØøÜ ò !Ø˜1’u��uØ—‘Ö ð!úð	 s   ƒ “ 6µ6r#   c                 ó4   — |D ]  }| j                  |«       Œ y rN   )ro   )rA   r#   rE   s      r!   r&   zIntList.extend¹   s   € Øò 	ˆAØ�K‰K˜�Nñ	r"   c                 óØ   — t        | j                  t        j                  «      sJ ‚| j                  | j                  j                     }| j                  || j                  «      | _        y rN   )r   r@   rG   r7   Útypecoder;   )rA   rB   s     r!   Ú	__upgradezIntList.__upgrade½   sS   € Ü˜$×+Ñ+¬U¯[©[Ô9Ð9Ð9Ø×#Ñ# D×$5Ñ$5×$>Ñ$>Ñ?ˆØ ×/Ñ/°°d×6GÑ6GÓHˆÕr"   )rX   ©r   N))Ú__name__Ú
__module__Ú__qualname__Ú__doc__r6   r
   r   ÚstrÚ__annotations__ÚdictÚ	itertoolsÚpairwiser7   Ú	__slots__r   r>   rD   ÚclassmethodrI   Ústaticmethodr   r   r;   rO   rS   rU   r   rZ   Úslicer_   ra   r   rd   Úobjectr    rj   rl   ro   rr   r&   rq   rX   r"   r!   r/   r/   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"   r/   Ú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).
    é   é   rX   )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.r9   c                 óN   — || _         t        |«      | _        d | _        d | _        y rN   )Ú_LazySequenceCopy__valuesr   Ú_LazySequenceCopy__lenÚ_LazySequenceCopy__maskÚ_LazySequenceCopy__popped_at)rA   r9   s     r!   rD   zLazySequenceCopy.__init__Ü   s%   € ØˆŒÜ˜“[ˆŒ
Ø+/ˆŒð .2ˆÕr"   r   c                 óv   — | j                   €| j                  S | j                  t        | j                   «      z
  S rN   )r•   r“   r   rR   s    r!   rU   zLazySequenceCopy.__len__ä   s2   € Ø×ÑÐ#Ø—:‘:ÐØ�z‰zœC × 0Ñ 0Ó1Ñ1Ð1r"   rV   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•   ro   )rA   rV   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].NrX   )rA   rV   r›   s      r!   ÚswapzLazySequenceCopy.swapù   s(   € à�Š6ØØ ™7 D¨¡GÐˆˆQ‰��a’r"   c                 óœ   — | j                  |«      \  }}| j                  |   }| j                  €|S | j                  j                  ||«      S rN   )r™   r’   r”   Úget)rA   rV   Ú_Údefaults       r!   rZ   zLazySequenceCopy.__getitem__ÿ   sH   € Ø×&Ñ& qÓ)‰ˆˆ1à—-‘- Ñ"ˆØ�;‰;ÐØˆNà—;‘;—?‘? 1 gÓ.Ð.r"   r+   c                 óp   — | j                  |«      \  }}| j                  €i | _        || j                  |<   y rN   )r™   r”   )rA   rV   r+   r    s       r!   rr   zLazySequenceCopy.__setitem__  s4   € Ø×&Ñ& qÓ)‰ˆˆ1Ø�;‰;ÐØˆDŒKØˆ�‰�AŠr"   c                 óH  — t        | «      }|| k  s||k\  rt        d|› d|› d�«      ‚|dk  r||z  }d|cxk  r|k  sJ ‚ J ‚|}| j                  �Ot        | j                  «      t        | j                  «      k  sJ ‚t	        | j                  «      D ]
  }|||k  z  }Œ ||fS )NzIndex z out of range [0, rQ   r   )r   r˜   r•   r’   Úreversed)rA   rV   rE   r*   Úps        r!   Ú__underlying_indexz#LazySequenceCopy.__underlying_index  s¿   € ô$ �‹IˆØ�ˆrŠ6�Q˜!’VÜ˜v a SÐ(:¸1¸#¸QÐ?Ó@Ð@ØˆqŠ5Ø�‰FˆAØ�AŒz˜ŠzÐ‰zÐˆzàˆØ×ÑÐ'Ü�t×'Ñ'Ó(¬C°·±Ó,>Ò>Ð>Ð>Ü˜d×.Ñ.Ó/ò �Ø�Q˜!‘V‘‘ðà�!ˆtˆr"   c              #   óL   K  — t        t        | «      «      D ]	  }| |   –— Œ y ­wrN   )Úranger   rY   s     r!   rd   zLazySequenceCopy.__iter__/  s'   è ø€ Ü”s˜4“yÓ!ò 	ˆAØ�q‘'‹Mñ	ùs   ‚"$)éÿÿÿÿ)rx   ry   rz   r{   r   r   rD   r>   rU   rš   r�   rZ   rr   r   r™   r   rd   rX   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 rn   )Ú_active_contextsÚsetÚ_known_limitsÚ_original_limitrR   s    r!   rD   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)rA   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                óâ   — | j                   dk(  r:| j                  �J ‚|| _        | j                  j                  | j                  «       | xj                   dz  c_         | j	                  |«       y )Nr   rŠ   )r´   r·   r¶   rÁ   rÄ   )rA   rº   rÃ   s      r!   Úenter_contextzStackframeLimiter.enter_contexth  se   € Ø× Ñ  AÒ%ð ×'Ñ'Ð/Ð/Ð/Ø#0ˆDÔ Ø×Ñ×"Ñ" 4×#7Ñ#7Ô8à×Ò Ñ"ÕØ×Ñ 	Õ*r"   c                ó$  — | j                   dkD  sJ ‚| xj                   dz  c_         | j                   dk(  r4| j                  }|€J ‚	 | j                  ||¬«       d | _        |h| _        y | j                  ||¬«       y # d | _        |h| _        w xY w)Nr   rŠ   r¸   )r´   r·   rÄ   r¶   )rA   rº   r¹   Úoriginal_limits       r!   Úexit_contextzStackframeLimiter.exit_contexts  s§   € Ø×$Ñ$ qÒ(Ð(Ð(Ø×Ò Ñ"Õà× Ñ  AÒ%ð "×1Ñ1ˆNØ!Ð-Ð-Ð-ð6Ø×'Ñ'¨¸eÐ'ÔDà'+�Ô$ð '5Ð%5�Õ"à×#Ñ# I°UÐ#Õ;øð (,�Ô$ð '5Ð%5�Õ"ús   ÁA> Á>B)	rx   ry   rz   rD   r>   r    rÄ   rÆ   rÉ   rX   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/J d| j
                  | j                  z
  › d| j                  › d�«       ‚	 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è  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...)rÃ   Fr¸   )
r°   Ú_stackframe_limiter_lockr«   r¾   Ú	old_limitrº   Ú_stackframe_limiterrÆ   Ú	ExceptionrÉ   )rA   Ú	cur_depths     r!   Ú	__enter__z!ensure_free_stackframes.__enter__�  sÝ   € Ü)Ó+ˆ	Ü%ñ 	Ü ×2Ñ2Ó4ˆDŒNð '¨Ñ-ˆDŒNð  Ò$ð Ø/°·±ÀÇÁÑ0OÐ/Pð Q&Ø&*§n¡nÐ%5ð 6/ð/óÐ$ð
Ü#×1Ñ1Ø—N‘N°$·.±.ð 2õ ÷#	ð 	øô( ò ô
 $×0Ñ0°·±ÀuÐ0ÔMØðú÷)	ð 	ús   ‘ACÁ*+BÂ,CÃCÃCc                 óx   — t         5  t        j                  | j                  «       d d d «       y # 1 sw Y   y xY wrN   )rÍ   rÏ   rÉ   rÎ   )rA   ÚargsÚkwargss      r!   Ú__exit__z ensure_free_stackframes.__exit__®  s,   € Ü%ñ 	=Ü×,Ñ,¨T¯^©^Ô<÷	=÷ 	=ñ 	=ús   ‡ 0°9rw   )rx   ry   rz   r{   rÒ   rÖ   rX   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ˆ   rV   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rN   )rÛ   Údurationrä   )rè   s    r!   Úhookz gc_cumulative_time.<locals>.hook  s(   € ðÜ'¨5¯>©>Ñ9Ñ'øÜ%ò Ùðús   ‚ –	"¡"T)Ú_gc_initializedÚhasattrÚgcr   r~   r|   r>   rÝ   ra   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rN   rX   ©Ú.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!   Ú
startswithr    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rN   rX   rö   s      r!   rú   zendswith.<locals>.<genexpr>  s   è ø€ ÒL™F˜B ˆr�R�xÑLùrû   rü   rþ   r   s     r!   Úendswithr    s;   € Ü
ˆ2ƒw”�R“ÒØÜÑL¤c¨"¬c°"«g¨X¨Z¨.¸"ÀUÔ&KÔLÓLÐLr"   rE   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.é   é   rX   )rE   s    r!   Úbits_to_bytesr  !  s   € ð �‰E�a‰<Ðr"   )6r{   rG   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   r>   r   r-   r/   rŽ   r�   r°   r²   rÏ   rÍ   rË   rÙ   rì   rÚ   r   r}   rÛ   Úperf_counterrã   rñ   r  r  r  rX   r"   r!   ú<module>r     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"   