Ë
    iKêjI  ã            	       ó¾  — U 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mZ d dlm	Z	m
Z
mZ d dlmZ d dlmZ d dlmZmZ d dlmZ d dlmZ d d	lmZ d d
lmZ erd dlmZ d dlmZ dZde de!fd„Z"de	de!fd„Z#de$de!fd„Z%de&de!fd„Z'de!de!fd„Z( e"d«      Z) e"d«      Z* ed«      Z+de+de+fd„Z,ddd e-e+   ddfd!„Z.d"e$e j^                     ee+   z  d#e dee+   fd$„Z0 ed%«      d&e1e2d'f   de-e1e!e!e2f      fd(„«       Z3 G d)„ d*«      Z4d+Z5 G d,„ d-«      Z6 G d.„ d/«      Z7 ed0«      xs ejp                  jr                  Z:e2e;d1<   ed2e2d3e!e2z  de2fd4„«       Z<d5e2d3e!e2z  de2fd6„Z=y)7é    N)ÚOrderedDictÚabc)ÚCallableÚIteratorÚSequence)Ú	lru_cache)ÚFunctionType)ÚTYPE_CHECKINGÚTypeVar)ÚInvalidArgument)Úint_from_bytes)Únext_up)Ú_function_key)ÚChoiceT)ÚConjectureDatal   ÿÿÿÿ ÚnameÚreturnc                 ó€   — t        j                  | j                  «       «      j                  «       }t	        |d d «      S )Né   )ÚhashlibÚsha384ÚencodeÚdigestr   )r   Úhasheds     úi/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/internal/conjecture/utils.pyÚcalc_label_from_namer   #   s0   € Ü�^‰^˜DŸK™K›MÓ*×1Ñ1Ó3€FÜ˜&  !˜*Ó%Ð%ó    Úfc                 óâ   — t        | t        «      rt        t        | d¬«      «      S t        | t        «      rt        | «      S 	 t        | «      S # t        $ r t        t	        | «      «      cY S w xY w)NT)Úignore_name)Ú
isinstancer	   Úcalc_label_from_hashr   ÚtypeÚcalc_label_from_clsÚ	Exception)r   s    r   Úcalc_label_from_callabler&   (   sa   € Ü�!”\Ô"Ü#¤M°!ÀÔ$FÓGÐGÜ	�A”tÔ	Ü" 1Ó%Ð%ð	0Ü'¨Ó*Ð*øÜò 	0ä&¤t¨A£wÓ/Ò/ð	0ús   Á
A ÁA.Á-A.Úclsc                 ó,   — t        | j                  «      S ©N)r   Ú__qualname__)r'   s    r   r$   r$   6   s   € Ü × 0Ñ 0Ó1Ð1r   Úobjc                 ó<   — t        t        t        | «      «      «      S r)   )r   ÚstrÚhash)r+   s    r   r"   r"   :   s   € Ü¤¤D¨£I£Ó/Ð/r   Úlabelsc                  ó:   — d}| D ]  }|dz  t         z  }||z  }Œ |S )Nr   é   )Ú
LABEL_MASK)r/   ÚlabelÚls      r   Úcombine_labelsr5   >   s4   € Ø€EØò ˆØ˜!‘œzÑ)ˆØ�‰
‰ðð €Lr   za sample() in Samplerzone more from many()ÚTÚvc                 ó   — | S r)   © )r7   s    r   Úidentityr:   M   s   € Ø€Hr   Údatar   Úlsc                 óš   — t        t        |«      dz
  «      D ]1  }| j                  |t        |«      dz
  «      }||   ||   c||<   ||<   Œ3 y)aO  Shuffle ``ls`` in place, drawing from ``data``.

    Reversed Fisher-Yates shuffle: swap each element with itself or with a
    later element.  This shrinks i==j for each element, i.e. towards no change,
    so a shuffled sequence shrinks back to its original order.  We don't
    consider the last element as it's always a no-op.
    r1   N)ÚrangeÚlenÚdraw_integer)r;   r<   ÚiÚjs       r   Úfisher_yates_shufflerC   Q   sU   € ô ”3�r“7˜Q‘;Óò $ˆØ×Ñ˜a¤ R£¨1¡Ó-ˆØ˜!‘u˜b ™eˆˆˆ1‰ˆr�!Šuñ$r   ÚvaluesÚstrategy_namec                 óš  — dt         j                  v r\t        | t         j                  d   j                  «      r5| j                  dk7  rgt        d| j                  › d| j                  › d�«      ‚t        | t        t        j                  t        j                  f«      st        d| ›d|› d�«      ‚t        | t        «      r| S t        | «      S )	NÚnumpyr1   zPOnly one-dimensional arrays are supported for sampling, and the given value has z dimensions (shape z²).  This array would give samples of array slices instead of elements!  Use np.ravel(values) to convert to a one-dimensional array, or tuple(values) if you want to sample slices.zCannot sample from z\ because it is not an ordered collection. Hypothesis goes to some length to ensure that the a”   strategy has stable results between runs. To replay a saved test case, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomization. Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when shrinking a test case, Hypothesis treats earlier values as simpler.)ÚsysÚmodulesr!   ÚndarrayÚndimr   Úshaper   r   r   ÚenumÚEnumMetar>   Útuple)rD   rE   s     r   Úcheck_samplerP   ^   sÇ   € ð ”#—+‘+Ñ¤*¨V´S·[±[ÀÑ5I×5QÑ5QÔ"RØ�;‰;˜!ÒÜ!ð+Ø+1¯;©;¨-Ð7JØ—<‘<�.ð !)ð)óð ô ˜¤¬c¯l©l¼D¿M¹MÐ JÔKÜØ! & ð ,AØANÀð P;ð;ó

ð 
	
ô �&œ%Ô ð ˆÜ�‹=Ðr   é@   Úweights.c                 óô  — t        | «      }t        |«      D �cg c]  }|d d g‘Œ	 }}t        | «      }t        |«      } |d«      } |d«      }g }g }	| D �
cg c]  }
|
|z  ‘Œ	 }}
g }t	        |«      D ]Q  \  }}||z  }|j                  |«       |dk(  r	|||   d<   Œ*|dk  r|j                  |«       ŒA|	j                  |«       ŒS t        j                  |«       t        j                  |	«       |r¹|	r·t        j                  |«      }t        j                  |	«      }||k7  sJ ‚||   |kD  sJ ‚||   d   �J ‚|||   d<   |||   z
  ||   d<   ||   ||   z   |z
  ||<   ||   dk  rt        j                  ||«       n'||   dk(  r	|||   d<   nt        j                  |	|«       |r|	rŒ·|	r|||	j                  «          d<   |	rŒ|r|||j                  «          d<   |rŒg }|D ]x  \  }}}t        |t        «      sJ ‚t        |t        «      s|�J ‚|€J ‚|€|j                  |||f«       ŒH||k  r|j                  ||||z
  f«       Œe|j                  |||f«       Œz |j                  «        |S c c}w c c}
w )Nr   r1   é   )r?   r>   Úsumr#   Ú	enumerateÚappendÚheapqÚheapifyÚheappopÚheappushÚpopr!   ÚintÚsort)rR   ÚnrA   ÚtableÚtotalÚnum_typeÚzeroÚoneÚsmallÚlargeÚwÚprobabilitiesÚscaled_probabilitiesÚalternate_chanceÚscaledÚloÚhiÚ	new_tableÚbaseÚ	alternates                       r   Úcompute_sampler_tablerq   ~   s×  € äˆG‹€AÜFKÈAÃhÖ,OÀ¨a°°tª_Ð,O€EÐ,OÜ�‹L€EÜ�E‹{€Há�A‹;€DÙ
�1‹+€Cà€EØ€Eà(/Ö0 1�Q˜“YÐ0€MÐ0Ø(*Ðä(¨Ó7ò ÑˆÐØ! AÑ%ˆØ×#Ñ# FÔ+Ø�QŠ;ØˆE�!‰H�QŠKØ�aŠZØ�L‰L˜�Oà�L‰L˜�Oðô 
‡M�M�%ÔÜ	‡M�M�%Ôá
‘EÜ�]‰]˜5Ó!ˆÜ�]‰]˜5Ó!ˆà�RŠxˆˆxØ# BÑ'¨#Ò-Ð-Ð-Ø�R‰y˜‰|Ð#Ð#Ð#Øˆˆb‰	�!‰ØÐ1°"Ñ5Ñ5ˆˆb‰	�!‰à  Ñ$Ð';¸BÑ'?Ñ?Øñ$Ð˜RÑ ð   Ñ# aÒ'Ü�N‰N˜5 "Õ%Ø! "Ñ%¨Ò*ØˆE�"‰I�aŠLä�N‰N˜5 "Ô%ñ% ’Eñ& Ø $ˆˆe�i‰i‹kÑ˜1Ñò á
Ø $ˆˆe�i‰i‹kÑ˜1Ñò ð /1€IØ-2ò 	BÑ)ˆˆiÐ)Ü˜$¤Ô$Ð$Ð$Ü˜)¤SÔ)¨YÐ->Ð>Ð>ØÐ+Ð+Ð+ØÐØ×Ñ˜d DÐ*:Ð;Õ<Ø˜ÒØ×Ñ˜i¨¨sÐ5EÑ/EÐFÕGà×Ñ˜d IÐ/?Ð@ÕAð	Bð ‡N�NÔØÐùò{ -Pùò 1s   ™I0ÁI5c                   ój   — e Zd ZU dZeeeeef      ed<   ddœde	e   de
fd„Zdd	œd
ddedz  defd„Zy)ÚSamplera(  Sampler based on Vose's algorithm for the alias method. See
    http://www.keithschwarz.com/darts-dice-coins/ for a good explanation.

    The general idea is that we store a table of triples (base, alternate, p).
    base. We then pick a triple uniformly at random, and choose its alternate
    value with probability p and else choose its base value. The triples are
    chosen so that the resulting mixture has the right distribution.

    We maintain the following invariants to try to produce good shrinks:

    1. The table is in lexicographic (base, alternate) order, so that choosing
       an earlier value in the list always lowers (or at least leaves
       unchanged) the value.
    2. base[i] < alternate[i], so that shrinking the draw always results in
       shrinking the chosen element.
    r`   T)ÚobserverR   rt   c                óD   — || _         t        t        |«      «      | _        y r)   )rt   rq   rO   r`   )ÚselfrR   rt   s      r   Ú__init__zSampler.__init__Õ   s   € ØˆŒÜ*¬5°«>Ó:ˆ�
r   N)Úforcedr;   r   rx   r   c                óÔ  ‡— | j                   r|j                  t        «       ‰€d nt        ˆfd„| j                  D «       «      }|j                  | j                  || j                   ¬«      \  }}}d }‰�‰|k(  xr |dkD  }‰|k(  s|sJ ‚|j                  ||| j                   ¬«      }| j                   r|j                  «        |r‰�|‰k(  s	J ‰|f«       ‚|S ‰�|‰k(  s	J ‰|f«       ‚|S )Nc              3   óN   •K  — | ]  \  }}}‰|k(  s
‰|k(  r|d kD  r|||f–— Œ y­w)r   Nr9   )Ú.0ro   rp   rj   rx   s       €r   ú	<genexpr>z!Sampler.sample.<locals>.<genexpr>ä   s?   øè ø€ ò á7�T˜9Ð&6Ø˜T’> f°	Ò&9Ð>NÐQRÒ>Rð �yÐ"2Ô3ñùs   ƒ"%©rx   rt   r   )rt   Ú
start_spanÚSAMPLE_IN_SAMPLER_LABELÚnextr`   ÚchoiceÚdraw_booleanÚ	stop_span)	rv   r;   rx   Úforced_choicero   rp   rj   Úforced_use_alternateÚuse_alternates	     `      r   ÚsamplezSampler.sampleÙ   s   ø€ ð �<Š<Ø�O‰OÔ3Ô4ð ˆ~ñ äó à;?¿:¹:ôó ð 	ð -1¯K©KØ�J‰JØ Ø—L‘Lð -8ó -
Ñ)ˆˆiÐ)ð
  $ÐØÐð $*¨YÑ#6Ò#OÐ;KÈaÑ;OÐ Ø˜T’>Ñ%9Ð9Ð9à×)Ñ)ØØ'Ø—L‘Lð *ó 
ˆð
 �<Š<Ø�N‰NÔÙØ�> Y°&Ò%8ÐM¸6À9Ð:MÓMÐ8ØÐà�> T¨V¢^ÐC°f¸d°^ÓCÐ3ØˆKr   )Ú__name__Ú
__module__r*   Ú__doc__ÚlistrO   r]   ÚfloatÚ__annotations__r   Úboolrw   r‡   r9   r   r   rs   rs   Á   sc   … ñð" ��c˜3 �oÑ&Ñ'Ó'àDHò ; ¨¡ð ;¸Tó ;ð "ò	*àð*ð �d‘
ð	*ð
 
ô*r   rs   zIteration over many() is interleaved with other draws.  Are you iterating over several many() objects at once, e.g. with zip()?c                   óÌ   — e Zd ZdZdddœdddedeez  d	eez  d
edz  deddfd„Zdd„Zde	dz  de
ddfd„Zded   fd„Zded   fd„Zddedz  ddfd„Zdefd„Zdd„Zdefd„Zy)Úmanyaý  Utility class for collections. Bundles up the logic we use for "should I
    keep drawing more values?" and handles starting and stopping spans in
    the right place.

    Intended usage is something like:

    with many(data, ...) as elements:
        for _ in elements:
            if not add_stuff_to_result():
                elements.reject()

    Leaving the loop early with ``break``, ``return``, or an exception is
    supported, and keeps both the span tree and the choice sequence well-formed.
    NTr}   r;   r   Úmin_sizeÚmax_sizeÚaverage_sizerx   rt   r   c                óF  — d|cxk  r|cxk  r|k  sJ ‚ J ‚|�||cxk  r|k  sJ ‚ J ‚|| _         || _        || _        || _        t	        ||z
  ||z
  «      | _        d| _        d| _        d| _        || _	        d | _
        d| _        d| _        d| _        d| _        d| _        y )Nr   F)r‘   r’   r;   Úforced_sizeÚ_calc_p_continueÚ
p_continueÚcountÚ
rejectionsÚ
force_stoprt   Ú_depthÚ	_iteratedÚ_closedÚ_doneÚ_in_elementÚ	_rejected)rv   r;   r‘   r’   r“   rx   rt   s          r   rw   zmany.__init__  s¾   € ð �HÔ8 Ô8°Ò8Ð8Ñ8Ð8Ð8Øˆ~ ¨VÔ!?°xÒ!?Ð?Ð?Ð!?Ð?Ð?Ø ˆŒØ ˆŒØˆŒ	Ø!ˆÔÜ*¨<¸(Ñ+BÀHÈxÑDWÓXˆŒØˆŒ
ØˆŒØˆŒØˆŒØ"&ˆŒØˆŒØˆŒØˆŒ
Ø ˆÔØˆ�r   c                 ój   — | j                   �t        d«      ‚| j                  j                  | _         | S )NzCannot reuse a many() object.)r›   r   r;   Údepth©rv   s    r   Ú	__enter__zmany.__enter__8  s,   € Ø�;‰;Ð"Ü!Ð"AÓBÐBØ—i‘i—o‘oˆŒØˆr   Úexc_typeÚ_c                 ó   — d| _         | j                  j                  ry | j                  j                  | j	                  «       k7  r|€t        t        «      ‚y | j                  «        |€%| j                  sd| _	        | j                  «        y y y )NT)r�   r;   Úfrozenr¢   Ú_expected_depthr   Ú_INTERLEAVED_MANY_MSGÚ_finish_elementrž   rš   Ú_decide)rv   r¥   r¦   s      r   Ú__exit__zmany.__exit__>  sy   € ØˆŒØ�9‰9×ÒØØ�9‰9�?‰?˜d×2Ñ2Ó4Ò4ØÐÜ%Ô&;Ó<Ð<ØØ×ÑÔØÐ D§J¢Jð #ˆDŒOØ�L‰L�Nð	 %/Ðr   c                 ó¤   — | j                   �| j                  rt        d«      ‚| j                  rt        d«      ‚d| _        | j	                  «       S )Nzmmany() must be used as `with many(...) as elements:` followed by `for _ in elements:`, inside the with-block.z,Cannot iterate over a many() more than once.T)r›   r�   r   rœ   Ú_iterater£   s    r   Ú__iter__zmany.__iter__M  sM   € Ø�;‰;Ð $§,¢,Ü!ðKóð ð �>Š>Ü!Ð"PÓQÐQØˆŒØ�}‰}‹Ðr   c              #   óT  K  — | j                   }	 | j                  rt        d«      ‚|j                  | j	                  «       k7  rt        t
        «      ‚| j                  r| j                  «        | j                  «       sy | xj                  dz  c_	        d| _        d| _
        d –— Œ˜­w)NTz,Cannot iterate over many() after exiting it.r1   F)r;   r�   r   r¢   r©   rª   rŸ   r«   r¬   r˜   r    )rv   r;   s     r   r¯   zmany._iterateX  s‹   è ø€ Ø�y‰yˆØØ�|Š|Ü%Ð&TÓUÐUØ�z‰z˜T×1Ñ1Ó3Ò3Ü%Ô&;Ó<Ð<Ø×ÒØ×$Ñ$Ô&Ø—<‘<”>ØØ�JŠJ˜!‰O�JØ#ˆDÔØ"ˆDŒNÛð ùs   ‚B&B(Úwhyc                 ór  — | j                   r| j                  rt        d«      ‚| xj                  dz  c_        | xj                  dz  c_        d| _        | j                  t        dd| j                  z  «      kD  r=| j                  | j                  k  r| j                  j                  |«       yd| _	        yy)z�Reject the current element (i.e. don't count it towards our budget
        of elements because it's not going to go in the final collection).z>reject() can only be called once per element, inside the loop.r1   Té   rT   N)
rŸ   r    r   r˜   r™   Úmaxr‘   r;   Úmark_invalidrš   )rv   r²   s     r   Úrejectzmany.rejecth  s’   € ð ×Ò 4§>¢>Ü!ØPóð ð 	�
Š
�a‰�
Ø�Š˜1Ñ�ØˆŒð �?‰?œS  A¨¯
©
¡NÓ3Ò3Ø�z‰z˜DŸM™MÒ)Ø—	‘	×&Ñ& sÕ+à"&�•ð	 4r   c                 ól   — | j                   €J ‚| j                   | j                  xr | j                  z   S r)   )r›   rŸ   rt   r£   s    r   r©   zmany._expected_depthz  s0   € Ø�{‰{Ð&Ð&Ð&Ø�{‰{˜d×.Ñ.Ò?°4·<±<Ñ@Ð@r   c                 ó’   — | j                   r;d| _         | j                  r'| j                  j                  | j                  ¬«       y y y )NF)Údiscard)rŸ   rt   r;   rƒ   r    r£   s    r   r«   zmany._finish_element~  s?   € Ø×ÒØ$ˆDÔØ�|Š|ð —	‘	×#Ñ#¨D¯N©NÐ#Õ;ð ð r   c                 óÖ  — | j                   rN| j                  | j                  k  r5| j                  j	                  d| j                  › d| j                  › �«       | j
                  r| j                  j                  t        «       | j                  | j                  k(  r| j                  | j                  k  }�n d }| j                   r*| j                  �| j                  | j                  k(  sJ ‚d}n]| j                  | j                  k  rd}nA| j                  | j                  k\  rd}n%| j                  �| j                  | j                  k  }| j                  j                  dc}| j                  _
        | j                  j                  | j                  || j
                  ¬«      }|| j                  _
        |s-d| _        | j
                  r| j                  j                  «        |S )Nzstopped with z elements, below min_size=FTr   r}   )rš   r˜   r‘   r;   r¶   rt   r~   ÚONE_FROM_MANY_LABELr’   r•   Úunique_element_depthr‚   r—   rž   rƒ   )rv   Úshould_continueÚforced_resultr¢   s       r   r¬   zmany._decide†  s‚  € Ø�?Š?˜tŸz™z¨D¯M©MÒ9Ø�I‰I×"Ñ"Ø §
¡
˜|Ð+EÀdÇmÁmÀ_ÐUôð �<Š<Ø�I‰I× Ñ Ô!4Ô5Ø�=‰=˜DŸM™MÒ)ð #Ÿj™j¨4¯=©=Ñ8ŠOà ˆMØ�Šð ×'Ñ'Ð/°4·:±:À×AQÑAQÒ3QÐQÐQØ %‘Ø—‘˜dŸm™mÒ+Ø $‘Ø—‘˜tŸ}™}Ò,Ø %‘Ø×!Ñ!Ð-Ø $§
¡
¨T×-=Ñ-=Ñ =�ð 59·I±I×4RÑ4RÐTUÐ1ˆE�4—9‘9Ô1Ø"Ÿi™i×4Ñ4Ø—‘Ø$ØŸ™ð 5ó ˆOð
 .3ˆD�I‰IÔ*ÙØˆDŒJØ�|Š|Ø—	‘	×#Ñ#Ô%ØÐr   )r   r�   r)   )r   N)rˆ   r‰   r*   rŠ   r]   rŒ   rŽ   rw   r¤   r#   Úobjectr­   r   r°   r¯   r-   r·   r©   r«   r¬   r9   r   r   r�   r�     sÝ   „ ñð, "Øòàðð ðð ˜‘+ð	ð
 ˜E‘kðð �d‘
ðð ðð 
óó8ð ¨¡ð °&ð ¸Tó ð	˜( 4™.ó 	ð˜( 4™.ó ñ '˜# ™*ð '°ó 'ð$A ó Aó<ð%˜ô %r   r�   c                   óN   — e Zd ZdZdedeez  ddfd„Zded   fd„Zded   fd	„Z	y)
Úinvert_manyab  The inversion counterpart of ``many``: the boolean choices that
    ``many`` would draw around each element. Fixed-size collections draw no
    booleans at all; variable-size ones draw a continuation boolean before
    each element (forced while below min_size, but forced draws still consume
    a choice) and a final False to stop (forced at max_size).r‘   r’   r   Nc                 ó   — ||k7  | _         y r)   ©Ú_variable_size)rv   r‘   r’   s      r   rw   zinvert_many.__init__µ  s   € Ø&¨(Ñ2ˆÕr   )r   .c                 ó"   — | j                   rdS dS )N)Tr9   rÄ   r£   s    r   Úmorezinvert_many.more¸  s   € Ø×-Ò-ˆwÐ5°2Ð5r   c                 ó"   — | j                   rdS dS )N)Fr9   rÄ   r£   s    r   Údonezinvert_many.done»  s   € Ø×.Ò.ˆxÐ6°BÐ6r   )
rˆ   r‰   r*   rŠ   r]   rŒ   rw   rO   rÇ   rÉ   r9   r   r   rÂ   rÂ   ®  sH   „ ñAð3 ð 3°°e±ð 3Àó 3ð6�e˜NÑ+ó 6ð7�e˜NÑ+ô 7r   rÂ   g        ÚSMALLEST_POSITIVE_FLOATÚdesired_avgr’   c                 óP  — | |k  s	J | |f«       ‚| |k(  ryddd| z   z  z
  }|dk(  s|t         j                  k(  rd|cxk  rdk  sJ |«       ‚ J |«       ‚|S d|cxk  rdk  sJ |«       ‚ J |«       ‚t        ||«      | kD  r%|dz  }|t        k  rt        }nt        ||«      | kD  rŒ%d}| t        ||«      z
  dkD  rEd|cxk  r|k  sn J ||f«       ‚||z   dz  }t        ||«      | k  r|}n|}| t        ||«      z
  dkD  rŒEd|cxk  rdk  sJ |«       ‚ J |«       ‚t        ||«      | k  sJ ‚|S )zCReturn the p_continue which will generate the desired average size.ç      ð?r1   r   g-Cëâ6?g{®Gáz„?rT   )ÚmathÚinfÚ_p_continue_to_avgrÊ   )rË   r’   r—   rm   Úmids        r   r–   r–   Â  sŽ  € ð ˜(Ò"Ð; [°(Ð$;Ó;Ð"Ø�hÒØØ�S˜A ™OÑ,Ñ,€JØ�Q‚˜(¤d§h¡hÒ.Ø�JÔ" Ò"Ð. JÓ.Ñ"Ð. JÓ.Ð"ØÐØˆzÔ˜AÒÐ)˜zÓ)ÑÐ)˜zÓ)Ðô ˜Z¨Ó
2°[Ò
@à�fÑˆ
ð
 Ô/Ò/Ü0ˆJØô ˜Z¨Ó
2°[Ó
@ð 
€BØ
Ô*¨:°xÓ@Ñ
@À4Ò
GØ�:Ô" Ô"Ð4 Z°Ð$4Ó4Ð"Ø˜B‰ !Ñ#ˆÜ˜c 8Ó,°Ò;Ø‰JàˆBð Ô*¨:°xÓ@Ñ
@À4Ó
Gð ˆzÔ˜AÒÐ)˜zÓ)ÑÐ)˜zÓ)ÐÜ˜j¨(Ó3°{ÒBÐBÐBØÐr   r—   c                 ó8   — | dk\  r|S dd| z
  z  dz
  d| |z  z
  z  S )zBReturn the average_size generated by this p_continue and max_size.r1   rÍ   r9   )r—   r’   s     r   rÐ   rÐ   é  s1   € à�Q‚ØˆØ�1�z‘>Ñ" QÑ&¨1¨z¸8Ñ/CÑ+CÑDÐDr   )>rM   r   rX   rÎ   rH   Úcollectionsr   r   Úcollections.abcr   r   r   Ú	functoolsr   Útypesr	   Útypingr
   r   Úhypothesis.errorsr   Úhypothesis.internal.compatr   Úhypothesis.internal.floatsr   Ú"hypothesis.internal.lambda_sourcesr   Ú%hypothesis.internal.conjecture.choicer   Ú#hypothesis.internal.conjecture.datar   r2   r-   r]   r   r&   r#   r$   rÀ   r"   r5   r   r¼   r6   r:   r‹   rC   ÚEnumrP   rO   rŒ   rq   rs   rª   r�   rÂ   Ú
float_infoÚminrÊ   r�   r–   rÐ   r9   r   r   ú<module>rá      s  ðô Û Û Û Û 
ß (ß 8Ñ 8Ý Ý ß )å -Ý 5Ý .Ý <áÝ=ÝBð €
ð&˜sð & só &ð
0 ð 0¨Só 0ð2˜Tð 2 có 2ð0˜fð 0¨ó 0ð˜Cð  Có ñ /Ð/FÓGÐ Ù*Ð+AÓBÐ ñ ˆCƒL€ð�ð �aó ð
$Ð/ð 
$°T¸!±Wð 
$Àó 
$ðØ�—‘‰O˜h q™kÑ)ðØ:=ðàˆa�[óñ@ ˆ2ƒð? 5¨°¨Ñ#4ð ?¸¸eÀCÈÈeÀOÑ>TÑ9Uò ?ó ð?÷DBñ BðL<ð ÷_ñ _÷D7ñ 7ñ" ")¨£Ò!C°·±×1CÑ1CÐ ˜Ó Cð ð# %ð #°3¸±;ð #À5ò #ó ð#ðLE 5ð E°C¸%±Kð EÀEô Er   