Ë
    iKêjêñ  ã                   ó   — U 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	 d dl
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mZmZmZmZmZmZmZ d d	lmZmZmZm Z  d d
l!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l0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z: d dl;m<Z< d dl=m>Z>m?Z? d dl@mAZA d dlBmCZCmDZD d dlEmFZF er edde¬«      ZGn
 edd¬«      ZG ed«      ZH ed«      ZI ed«      ZJ ed«      ZK ed«      ZL ed «      ZM ed!«      ZNed"geOf   ZPeeQd#<    eCd$«      ZR e7d%«      ZS e7d&«      ZT e«       ZU eFeD«      ZVeFe   eQd'<   d(eWdz  fd)„ZXd*d"d+eWd,eYd(efd-„ZZ G d.„ d"eeG   «      Z[d/eYd(e\eOe]dz  f   fd0„Z^d/eYd(eOfd1„Z_ G d2„ d3e[eG   «      Z` ejÂ                  «       Zb G d4„ d5e[eG   «      Zced6e	e[eG      d(e[eG   fd7„«       Zded8e[eG   d(e[eG   fd9„«       Zded8e[eI   d:e[eH   d(e[eIeHz     fd;„«       Zded8e[eI   d:e[eH   d<e[eJ   d(e[eIeHz  eJz     fd=„«       Zded8e[eI   d:e[eH   d<e[eJ   d>e[eK   d(e[eIeHz  eJz  eKz     f
d?„«       Zded8e[eI   d:e[eH   d<e[eJ   d>e[eK   d@e[eL   d(e[eIeHz  eJz  eKz  eLz     fdA„«       ZdedBe[e   d(e[e   fdC„«       Zd eAd¬D«      dBe	e[e      e[e   z  d(e[e   fdE„«       Zd G dF„ dGe[eN   eeMeNf   «      Zeed(efdH„«       Zfd(e	e   fdI„Zg eCdJ«      Zh G dK„ dLe[eG   «      Zie:dOdMeYd+eWd(dfdN„«       Zjy)Pé    N)ÚabcÚdefaultdict)ÚCallableÚSequence)Ú	lru_cache)Úshuffle)ÚRLock)Ú	FrameType)
ÚTYPE_CHECKINGÚAnyÚClassVarÚGenericÚLiteralÚ	TypeAliasÚ	TypeGuardÚTypeVarÚcastÚoverload)ÚHealthCheckÚPhaseÚ	VerbosityÚsettings)Ú_current_build_contextÚcurrent_build_context)ÚCannotInvertÚHypothesisExceptionÚHypothesisWarningÚInvalidArgumentÚNonInteractiveExampleWarningÚUnsatisfiedAssumption)Úutils)ÚChoiceT)ÚConjectureData)Úequal_values)Úcalc_label_from_clsÚcalc_label_from_hashÚcalc_label_from_nameÚcombine_labels)Úcheck_function)Úis_hypothesis_file)Úget_pretty_function_descriptionÚis_identity_function)Údefines_strategy)ÚUniqueIdentifierÚnot_set)ÚDynamicVariableÚExT)Ú	covariantÚdefault)r2   ÚTÚT1ÚT3ÚT4ÚT5Ú
MappedFromÚMappedToÚSearchStrategyÚRecurTÚcalculatingz(another attempted draw in MappedStrategyz)single loop iteration in FilteredStrategyÚ_filter_location_overrideÚreturnc                  óN  — t         j                  x} t        ur| S t        j                  d«      }|�Mt        |j                  j                  «      r.|j                  }|� t        |j                  j                  «      rŒ.|€y|j                  j                  › d|j                  › �S )a  The filename:lineno of the nearest enclosing non-hypothesis .filter() call.

    Callers are expected to only call this from within a .filter() implementation. This
    function simply respects _filter_location_override or walks to the nearest non-hypothesis
    frame.
    é   Nú:)
r>   Úvaluer/   ÚsysÚ	_getframer*   Úf_codeÚco_filenameÚf_backÚf_lineno)ÚlocationÚframes     úo/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/strategies/_internal/strategies.pyÚcurrent_filter_call_siterM   ^   sŽ   € ô .×3Ñ3Ð3ˆ¼GÑCØˆÜ!Ÿm™m¨AÓ.€EØ
Ð
Ô 2°5·<±<×3KÑ3KÔ LØ—‘ˆð Ð
Ô 2°5·<±<×3KÑ3KÕ Là€}ØØ�l‰l×&Ñ&Ð' q¨¯©Ð(8Ð9Ð9ó    ÚstrategyÚnamer3   c                 óö  ‡‡‡‡‡‡‡‡‡‡‡— |dv sJ ‚d|z   Šd|z   Šd|z   Šdt         dt        fˆˆfd„Š	  ‰| «      S # t        $ r Y nw xY wi Št        «       ŠdŠd	t         dt        fˆˆˆˆˆˆˆfd
„Š ‰| «       t	        t
        «      Š‰rt        ‰«      ndŠd	t         dt        fˆˆˆˆˆˆfd„}d}t        «       }‰r‘|dz  }|dkD  r7t        ‰j                  «       «      }||vs	J ||f«       ‚|j                  |«       ‰}t        «       Š|D ]<  } t        |‰«       ||«      «      }	|	‰|   k7  sŒ$‰j                  ‰|   «       |	‰|<   Œ> ‰rŒ‘‰j                  «       D ]  \  }
}t        |
‰|«       Œ  ‰| «      S )a,  Handle properties which may be mutually recursive among a set of
    strategies.

    These are essentially lazily cached properties, with the ability to set
    an override: If the property has not been explicitly set, we calculate
    it on first access and memoize the result for later.

    The problem is that for properties that depend on each other, a naive
    calculation strategy may hit infinite recursion. Consider for example
    the property is_empty. A strategy defined as x = st.deferred(lambda: x)
    is certainly empty (in order to draw a value from x we would have to
    draw a value from x, for which we would have to draw a value from x,
    ...), but in order to calculate it the naive approach would end up
    calling x.is_empty in order to calculate x.is_empty in order to etc.

    The solution is one of fixed point calculation. We start with a default
    value that is the value of the property in the absence of evidence to
    the contrary, and then update the values of the property for all
    dependent strategies until we reach a fixed point.

    The approach taken roughly follows that in section 4.2 of Adams,
    Michael D., Celeste Hollenbeck, and Matthew Might. "On the complexity
    and performance of parsing with derivatives." ACM SIGPLAN Notices 51.6
    (2016): 224-236.
    >   Úis_emptyÚis_cacheableÚhas_reusable_valuesÚcached_Úcalc_Úforce_Útargetr?   c                 ó�   •— | j                   }‰|v r|‰   S ‰|v r|‰   S 	 t        | ‰«      S # t        $ r t        | ‰«      cY S w xY w©N)Ú__dict__ÚgetattrÚAttributeError)rX   ÚdÚ	cache_keyÚ	force_keys     €€rL   Úforced_or_cached_valuez2recursive_property.<locals>.forced_or_cached_valueŽ   s^   ø€ ð �O‰OˆØ˜‰>Ø�Y‘<ÐØ˜‰>Ø�Y‘<Ðð	.Ü˜6 9Ó-Ð-øÜò 	.Ü˜6 9Ó-Ò-ð	.ús   ¡- ­AÁAFÚstratc                 óÂ   •— 	  ‰| «      S # t         $ r Y nw xY w‰j                  | ‰«      }|t        u rdŠ‰S |‰u r#t        ‰| <    t        | ‰«      ‰«      ‰| <   ‰|    S |S ©NT)r]   Úgetr=   r\   )	rb   ÚresultÚcalculationr3   ra   Úhit_recursionÚmappingÚrecurÚsentinels	     €€€€€€€rL   rj   z!recursive_property.<locals>.recur¨   s~   ø€ ð	Ù)¨%Ó0Ð0øÜò 	Ùð	úà—‘˜U HÓ-ˆØ”[Ñ Ø ˆMØˆNØ�xÑÜ(ˆG�E‰NØ8œW U¨KÓ8¸Ó?ˆG�E‰NØ˜5‘>Ð!Øˆó   ƒ ‹	–Nc                 ó:   •‡ — dt         dt        fˆˆˆˆˆˆˆ fd„}|S )NÚotherr?   c                 óÄ   •— 	  ‰| «      S # t         $ r Y nw xY w‰|    j                  ‰«       ‰j                  | ‰«      }|‰u r‰€J ‚‰j                  | «       ‰‰| <   ‰S |S rZ   )r]   Úaddre   )	rn   rf   r3   ra   Ú	listenersri   Úneeds_updaterk   rb   s	     €€€€€€€rL   Úrecur_innerz7recursive_property.<locals>.recur2.<locals>.recur_innerÊ   s}   ø€ ðÙ-¨eÓ4Ð4øÜ!ò Ùðúà�eÑ× Ñ  Ô'Ø—[‘[ ¨Ó1ˆFØ˜Ñ!Ø#Ð/Ð/Ð/Ø× Ñ  Ô'Ø!(�˜‘Ø�ØˆMrl   )r;   r   )rb   rs   r3   ra   rq   ri   rr   rk   s   ` €€€€€€rL   Úrecur2z"recursive_property.<locals>.recur2É   s#   ù€ ð	œ~ð 	´#÷ 	ó 	ð ÐrN   r   rA   é2   )r;   r   r]   Úobjectr   ÚsetÚ	frozensetÚitemsrp   r\   ÚupdateÚsetattr)rO   rP   r3   rt   ÚcountÚseenÚkeyÚ	to_updaterb   Ú	new_valueÚkÚvr_   rg   r`   ra   rh   rq   ri   rr   rj   rk   s     `         @@@@@@@@@@rL   Úrecursive_propertyrƒ   o   s²  ÿú€ ð4 ÐFÑFÐFÐFØ˜DÑ €IØ˜D‘.€KØ˜4‘€Ið.¤~ð .¼#ö .ðÙ% hÓ/Ð/øÜò Ùðúð *,€GÜ‹x€HØ€Mð”^ð ¬÷ ó ñ  
ˆ(„Oô <GÄsÓ;K€IÙ#0”3�w”<°d€Lð”nð ¬÷ ò ð" €EÜ‹5€DÙ
Ø�‰
ˆð �2Š:Ü˜GŸM™M›OÓ,ˆCØ˜d‘?Ð/ S¨$ KÓ/�?Ø�H‰H�SŒMØ ˆ	Ü“uˆØò 	+ˆEØ3œ  {Ó3±F¸5³MÓBˆIØ˜G E™NÓ*Ø×#Ñ# I¨eÑ$4Ô5Ø!*�˜’ð		+ò ð0 —‘“ò !‰ˆˆ1Ü��9˜aÕ ð!ñ " (Ó+Ð+s   µ= ½	A	ÁA	c                   ó   — e Zd ZU dZdZeed<   i Zeee	e
f      ed<   dZe
ez  dz  ed<   d)d„Zd	edefd
„Zedefd„«       Zedefd„«       Z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fd„Zdeegef   ddfd„Zdeegdf   ddfd„Ze deege!e   f   ddfd„«       Z"e deegef   ddfd„«       Z"d„ Z"ede#d   fd„«       Z$d*d„Z%defd„Z&d)d „Z'ede
fd!„«       Z(ede
fd"„«       Z)de
fd#„Z*d)d$„Z+d	edefd%„Z,d&ede-e.d'f   fd(„Z/y)+r;   aG  A ``SearchStrategy`` tells Hypothesis how to generate that kind of input.

    This class is only part of the public API for use in type annotations, so that
    you can write e.g. ``-> SearchStrategy[Foo]`` for your function which returns
    ``builds(Foo, ...)``.  Do not inherit from or directly instantiate this class.
    zhypothesis.strategiesÚ
__module__ÚLABELSNÚ_SearchStrategy__labelr?   c                 ó   — i | _         y rZ   )Úvalidate_called©Úselfs    rL   Ú__init__zSearchStrategy.__init__  s
   € Ø02ˆÕrN   Údatac                 ó   — | j                   S )a)  
        Returns whether this strategy is currently empty. Unlike ``empty``,
        which is computed based on static information and cannot change,
        ``is_currently_empty`` may change over time based on choices made
        during the test case.

        This is currently only used for stateful testing, where |Bundle| grows a
        list of values to choose from over the course of a test case.

        ``data`` will only be used for introspection. No values will be drawn
        from it in a way that modifies the choice sequence.
        )rR   ©r‹   r�   s     rL   Úis_currently_emptyz!SearchStrategy.is_currently_empty  s   € ð �}‰}ÐrN   c                 óN   — | j                   }d|v r	d|vr|d   S t        | dd«      S )NÚcached_is_emptyÚforce_is_emptyrR   T)r[   rƒ   )r‹   r^   s     rL   rR   zSearchStrategy.is_empty%  s8   € ð �M‰MˆØ Ñ!Ð&6¸aÑ&?ØÐ&Ñ'Ð'Ü! $¨
°DÓ9Ð9rN   c                 ó   — t        | dd«      S )NrT   T©rƒ   rŠ   s    rL   rT   z"SearchStrategy.has_reusable_values9  s   € ä! $Ð(=¸tÓDÐDrN   c                 ó   — t        | dd«      S )zv
        Whether it is safe to hold on to instances of this strategy in a cache.
        See _STRATEGY_CACHE.
        rS   Tr•   rŠ   s    rL   rS   zSearchStrategy.is_cacheable=  s   € ô " $¨¸Ó=Ð=rN   rj   c                  ó   — yrd   © ©r‹   rj   s     rL   Úcalc_is_cacheablez SearchStrategy.calc_is_cacheableE  s   € ØrN   c                  ó   — y©NFr˜   r™   s     rL   Úcalc_is_emptyzSearchStrategy.calc_is_emptyH  s   € ð rN   c                  ó   — yrœ   r˜   r™   s     rL   Úcalc_has_reusable_valuesz'SearchStrategy.calc_has_reusable_valuesQ  s   € ØrN   c                 ó  ‡ — t        t        dd«      €\t        j                  d   j                  €t        j
                  j                  d«      � t        j                  d‰ ›d�t        d¬«       t        j                  }|�;|j                  �$|j                  j                  d	kD  rt        d
«      ‚t        d«      ‚	 ‰ j                  j!                  «       S # t"        t$        f$ r
 g ‰ _        Y nw xY wd	dlm}  |‰ «      t+        dddt,        j.                  t0        j2                  ft5        t6        «      ¬«      dt8        ddfˆ fd„«       «       } |«        t;        ‰ j                  «       ‰ j                  j!                  «       S )a  Provide an example of the sort of value that this strategy generates.

        This method is designed for use in a REPL, and will raise an error if
        called from inside |@given| or a strategy definition.  For serious use,
        see |@composite| or |st.data|.
        Úps1NÚ__main__ÚPYTEST_CURRENT_TESTa   The `.example()` method is good for exploring strategies, but should only be used interactively.  We recommend using `@given` for tests - it performs better, saves and replays failures to avoid flakiness, and reports minimal failing test cases. (strategy: ú)é   ©Ú
stacklevelr   a�  Using example() inside a strategy definition is a bad idea. Instead consider using hypothesis.strategies.builds() or @hypothesis.strategies.composite to define your strategy. See https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.builds or https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.composite for more details.a  Using example() inside a test function is a bad idea. Instead consider using hypothesis.strategies.data() to draw more values during testing. See https://hypothesis.readthedocs.io/en/latest/reference/strategies.html#hypothesis.strategies.data for more details.)Úgivené
   )ÚdatabaseÚmax_examplesÚdeadlineÚ	verbosityÚphasesÚsuppress_health_checkÚexr?   c                 ó<   •— ‰j                   j                  | «       y rZ   )Ú_SearchStrategy__examplesÚappend)r°   r‹   s    €rL   Ú!example_generating_inner_functionzASearchStrategy.example.<locals>.example_generating_inner_function�  s   ø€ ð �O‰O×"Ñ" 2Õ&rN   )r\   rD   ÚmodulesÚ__spec__ÚosÚenvironre   ÚwarningsÚwarnr   r   rC   r�   Údepthr   r²   Úpopr]   Ú
IndexErrorÚhypothesis.corer¨   r   r   Úquietr   ÚgenerateÚlistr   r1   r   )r‹   Úcontextr¨   r´   s   `   rL   ÚexamplezSearchStrategy.exampleT  s{  ø€ ô ”3˜˜tÓ$Ð,ô �K‰K˜
Ñ#×,Ñ,Ð8ô �z‰z�~‰~Ð3Ó4Ð@ô
 �M‰MðFð GKÀXÈQðPô -Øõô )×.Ñ.ˆØÐØ�|‰|Ð'¨G¯L©L×,>Ñ,>ÀÒ,BÜ)ðó	ð 	ô *ðSóð ð	+Ø—?‘?×&Ñ&Ó(Ð(øÜ¤
Ð+ò 	+Ø(*ˆDŽOð	+úõ 	*ñ 
ˆt‹Ü	Øð ØÜ—o‘oÜ—N‘NÐ$Ü"&¤{Ó"3ô


ð	'Üð	'àô	'ó


ó 
ð	'ñ
 	*Ô+Ü�—‘Ô Ø�‰×"Ñ"Ó$Ð$s   Â=C ÃC0Ã/C0ÚpackúSearchStrategy[T]c                 ó6   — t        |«      r| S t        | |¬«      S )zÄReturns a new strategy which generates a value from this one, and
        then returns ``pack(value)``.  For example, ``integers().map(str)``
        could generate ``str(5)`` == ``"5"``.
        ©rÄ   )r,   ÚMappedStrategy)r‹   rÄ   s     rL   ÚmapzSearchStrategy.map¤  s   € ô
   Ô%ØˆKÜ˜d¨Ô.Ð.rN   Úexpandc                 ó"   — ddl m}  || |¬«      S )ad  Old syntax for a special case of |@composite|:

        .. code-block:: python

            @st.composite
            def flatmap_like(draw, base_strategy, expand):
                value = draw(base_strategy)
                new_strategy = expand(value)
                return draw(new_strategy)

        We find that the greater readability of |@composite| usually outweighs
        the verbosity, with a few exceptions for simple cases or recipes like
        ``from_type(type).flatmap(from_type)`` ("pick a type, get a strategy for
        any instance of that type, and then generate one of those").
        r   )ÚFlatMapStrategy)rÊ   )Ú*hypothesis.strategies._internal.flatmappedrÌ   )r‹   rÊ   rÌ   s      rL   ÚflatmapzSearchStrategy.flatmap­  s   € õ$ 	Oá˜t¨FÔ3Ð3rN   Ú	conditionc                  ó   — y rZ   r˜   ©r‹   rÏ   s     rL   ÚfilterzSearchStrategy.filterË  ó   € ð "rN   úSearchStrategy[Ex]c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zSearchStrategy.filterÏ  ó   € ØNQrN   c                 ó2   — t        | |ft        «       f¬«      S )ay  Returns a new strategy that generates values from this strategy
        which satisfy the provided condition.

        Note that if the condition is too hard to satisfy this might result
        in your tests failing with an Unsatisfiable exception.
        A basic version of the filtering logic would look something like:

        .. code-block:: python

            @st.composite
            def filter_like(draw, strategy, condition):
                for _ in range(3):
                    value = draw(strategy)
                    if condition(value):
                        return value
                assume(False)
        ©Ú
conditionsÚcondition_locations)ÚFilteredStrategyrM   rÑ   s     rL   rÒ   zSearchStrategy.filterÑ  s"   € ô$  ØØ!�|Ü!9Ó!;Ð =ô
ð 	
rN   c                 ó   — | gS rZ   r˜   rŠ   s    rL   ÚbrancheszSearchStrategy.branchesé  s	   € àˆvˆrN   c                 ó  — t        |t        «      st        d|›�«      ‚g }|j                  t        | t        «      r| j
                  n| g«       |j                  t        |t        «      r|j
                  n|g«       t	        |«      S )z­Return a strategy which produces values by randomly drawing from one
        of this strategy or the other strategy.

        This method is part of the public API.
        zCannot | a SearchStrategy with )Ú
isinstancer;   Ú
ValueErrorÚextendÚOneOfStrategyÚoriginal_strategies)r‹   rn   Ú
strategiess      rL   Ú__or__zSearchStrategy.__or__í  s€   € ô ˜%¤Ô0ÜÐ>¸u¸iÐHÓIÐIð ,.ˆ
Ø×ÑÜ(2°4¼Ô(GˆD×$Ò$ÈdÈVô	
ð 	×ÑÜ)3°E¼=Ô)IˆE×%Ò%ÐPUÈwô	
ô ˜ZÓ(Ð(rN   c                 óD   — t        j                  d| ›d�t        d¬«       y)Nzbool(z/) is always True, did you mean to draw a value?r¥   r¦   T)r¹   rº   r   rŠ   s    rL   Ú__bool__zSearchStrategy.__bool__  s&   € Ü�‰Ø�D�8ÐJÐKÜØõ	
ð
 rN   c                 ó  — t        j                  «       }| j                  j                  |d«      ry	 d| j                  |<   | j	                  «        | j
                   | j                   y# t        $ r d| j                  |<   ‚ w xY w)a  Throw an exception if the strategy is not valid.

        Strategies should implement ``do_validate``, which is called by this
        method. They should not override ``validate``.

        This can happen due to invalid arguments, or lazy construction.
        FNT)Ú	threadingÚ	get_identr‰   re   Údo_validaterR   rT   Ú	Exception)r‹   Ú	thread_ids     rL   ÚvalidatezSearchStrategy.validate  s~   € ô ×'Ñ'Ó)ˆ	Ø×Ñ×#Ñ# I¨uÔ5Øð"	Ø.2ˆD× Ñ  Ñ+Ø×ÑÔØ�MŠMØ×$Ó$øÜò 	Ø.3ˆD× Ñ  Ñ+Øð	ús   ³7A+ Á+Bc                 ó�   — | j                   }	 |j                  |   S # t        $ r Y nw xY wt        |«      }||j                  |<   |S rZ   )Ú	__class__r†   ÚKeyErrorr%   )r‹   Úclsrf   s      rL   Úclass_labelzSearchStrategy.class_label7  sL   € à�n‰nˆð	Ø—:‘:˜c‘?Ð"øÜò 	Ùð	úä$ SÓ)ˆØ ˆ�
‰
�3‰Øˆs   Ž �	)¨)c                 ó  — t        | j                  x}t        «      r|S t        5  | j                  t        u r
	 d d d «       yt        | _        | j                  «       | _        | j                  cd d d «       S # 1 sw Y   y xY w©Nr   )rß   r‡   ÚintÚ
label_lockr=   Ú
calc_label)r‹   Úlabels     rL   rù   zSearchStrategy.labelB  si   € ä §¡Ð,�u¬sÔ3àˆLäñ 	 Ø�|‰|œ{Ñ*Ø÷	 ð 	 ô 'ˆDŒLØŸ?™?Ó,ˆDŒLØ—<‘<÷	 ÷ 	 ò 	 ús   ¥A7Á+A7Á7B c                 ó   — | j                   S rZ   )ró   rŠ   s    rL   rø   zSearchStrategy.calc_labelO  s   € Ø×ÑÐrN   c                  ó   — y rZ   r˜   rŠ   s    rL   rë   zSearchStrategy.do_validateR  s   € ØrN   c                 óD   — t        t        | «      j                  › d�«      ‚)Nz.do_draw)ÚNotImplementedErrorÚtypeÚ__name__r�   s     rL   Údo_drawzSearchStrategy.do_drawU  s   € Ü!¤T¨$£Z×%8Ñ%8Ð$9¸Ð"BÓCÐCrN   rC   .c                 óD   — t        t        | «      j                  › d�«      ‚)aS  
        Return a choice sequence ``choices`` such that we expect

            data = ConjectureData.for_choices(choices)
            drawn = data.draw(self)

        would produce ``drawn == value``. Inversion is best-effort: it should
        satisfy this property with high probability, but callers must replay
        the returned choices and check the outcome rather than rely on it.

        Raises CannotInvert if we cannot construct such a choice sequence,
        whether because ``value`` is not produced by this strategy or because
        inversion isn't implemented for it.
        z does not support inversion)r   rþ   rÿ   ©r‹   rC   s     rL   Ú_invertzSearchStrategy._invertX  s"   € ô œd 4›j×1Ñ1Ð2Ð2MÐNÓOÐOrN   ©r?   N)rn   rÅ   r?   zSearchStrategy[Ex | T])0rÿ   r…   Ú__qualname__Ú__doc__ÚstrÚ__annotations__r†   r   Údictrþ   rö   r‡   r.   rŒ   r#   Úboolr�   Úpropertyr   rR   rT   rS   r<   rš   r�   rŸ   r1   rÃ   r   r4   rÉ   rÎ   r   r   rÒ   r   rÝ   rå   rç   rî   ró   rù   rø   rë   r   Útupler"   r  r˜   rN   rL   r;   r;     sI  … ñð .€J�Ó-Ø(*€FˆH�T˜$ ˜)‘_Ñ%Ó*ð .2€GˆSÐ#Ñ# dÑ*Ó1ó3ð ~ð ¸$ó ð ð	:˜#ò 	:ó ð	:ð& ðE Sò Eó ðEð ð>˜cò >ó ð>ð vð °$ó ð 6ð ¨dó ð¨fð ¸ó ðN%˜ó N%ð`/˜ "  q Ñ)ð /Ð.Aó /ð4Ø ˜tÐ%8Ð8Ñ9ð4à	ó4ð< ð"Ø! 2 $¨	°!©Ð"4Ñ5ð"à	ò"ó ð"ð ØQ ¨"¨¨s¨Ñ 3ÐQÐ8LÒQó ØQò
ð0 ð˜(Ð#7Ñ8ò ó ðó)ð<˜$ó ó"ðH ð˜Sò ó ðð ð
 �sò 
 ó ð
 ð ˜Có  óðD˜Nð D¨ró DðP˜Sð P U¨7°C¨<Ñ%8ô PrN   rC   c                 ó<   — 	 dt        | «      fS # t        $ r Y yw xY w)NT)FN)ÚhashÚ	TypeError©rC   s    rL   Ú_is_hashabler  j  s(   € ðØ”d˜5“kÐ"Ð"øÜò Ùðús   ‚ �	šc                 ó   — t        | «      d   S rõ   )r  r  s    rL   Úis_hashabler  s  s   € Ü˜Ó˜qÑ!Ð!rN   c                   óÄ  ‡ — e Zd ZU dZdZee   ed<   ddddœdee	   de
dz  d	ee
e
f   dz  d
eeed   ee	gef   e
dz  f   df   fˆ fd„Zdee	gef   dee   fd„Zedee	gee   f   ddfd„«       Zedee	gef   ddfd„«       Zd„ Zd„ Zdefd„Zdedefd„Zdedefd„Zde	dedz  de	ez  fd„Zdede	fd„Zd edede	ez  fd!„Z d"edee!df   fd#„Z"dede	ez  fd$„Z#ˆ xZ$S )%ÚSampledFromStrategyz´A strategy which samples from a set of elements. This is essentially
    equivalent to using a OneOfStrategy over Just strategies but may be more
    efficient and convenient.
    i'  Ú_MAX_FILTER_CALLSNr˜   ©Ú
force_reprÚforce_repr_bracesÚtransformationsÚelementsr  r  r  )rÒ   rÉ   .c                ó¬   •— t         ‰| �  «        t        j                  |d«      | _        | j                  sJ ‚|| _        || _        || _        d | _        y )NÚsampled_from)	ÚsuperrŒ   ÚcuÚcheck_sampler  r  r  Ú_transformationsÚ_cached_repr)r‹   r  r  r  r  rð   s        €rL   rŒ   zSampledFromStrategy.__init__  sM   ø€ ô 	‰ÑÔÜŸ™¨°.ÓAˆŒØ�}Š}Ðˆ}Ø$ˆŒØ!2ˆÔØ /ˆÔà(,ˆÕrN   rÄ   r?   c           	      óº   —  t        | «      | j                  | j                  | j                  g | j                  ¢d|d f‘­¬«      }t        t        t           |«      S )NrÉ   r  )rþ   r  r  r  r!  r   r;   r4   )r‹   rÄ   Úss      rL   rÉ   zSampledFromStrategy.map”  sW   € ØŒD�‹JØ�M‰MØ—‘Ø"×4Ñ4ØI˜d×3Ñ3ÐI°e¸TÀ4Ð5HÑIô	
ˆô ”N¤1Ñ% qÓ)Ð)rN   rÏ   rÅ   c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zSampledFromStrategy.filterž  rÓ   rN   rÔ   c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zSampledFromStrategy.filter¢  rÖ   rN   c           
      óœ   —  t        | «      | j                  | j                  | j                  g | j                  ¢d|t        «       f‘­¬«      S )NrÒ   r  )rþ   r  r  r  r!  rM   rÑ   s     rL   rÒ   zSampledFromStrategy.filter¤  sR   € ØŒt�D‹zØ�M‰MØ—‘Ø"×4Ñ4ðØ×&Ñ&ðà˜9Ô&>Ó&@ÐAñô	
ð 	
rN   c                 óÄ  ‡— | j                   €Èt        Št        | j                  «      dkD  r*dj	                  ˆfd„| j                  d d D «       «      dz   n#dj	                  ˆfd„| j                  D «       «      }| j
                  xs d}| j                  xs d|d   › |› |d	   › d
�}dj	                  d„ | j                  D «       «      }||z   }|| _         | j                   S )Ni   ú, c              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrZ   r˜   ©Ú.0r‚   Úreps     €rL   ú	<genexpr>z/SampledFromStrategy.__repr__.<locals>.<genexpr>³  s   øè ø€ Ò> Q™#˜aŸ&Ñ>ùó   ƒz, ...c              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrZ   r˜   r+  s     €rL   r.  z/SampledFromStrategy.__repr__.<locals>.<genexpr>µ  s   øè ø€ Ò=¨!™s 1ŸvÑ=ùr/  )ú(r¤   zsampled_from(r   rA   r¤   Ú c              3   óH   K  — | ]  \  }}}d |› dt        |«      › d�–— Œ y­w)ú.r1  r¤   N©r+   )r,  rP   ÚfÚ_s       rL   r.  z/SampledFromStrategy.__repr__.<locals>.<genexpr>»  s4   è ø€ ò #á�D˜!˜Qð �D�6˜Ô:¸1Ó=Ð>¸aÔ@ñ#ùs   ‚ ")r"  r+   Úlenr  Újoinr  r  r!  )r‹   Ú
elements_sÚbracesÚ
instance_sÚtransforms_sÚrepr_sr-  s         @rL   Ú__repr__zSampledFromStrategy.__repr__¯  sç   ø€ Ø×ÑÐ$Ü1ˆCô �t—}‘}Ó%¨Ò+ð —	‘	Ó>¨$¯-©-¸¸Ð*=Ô>Ó>ÀÒHà—Y‘YÓ=¨t¯}©}Ô=Ó=ð ð
 ×+Ñ+Ò9¨zˆFà—‘ÒV ]°6¸!±9°+¸j¸\È&ÐQRÉ)ÈÐTUÐ#Vð ð Ÿ7™7ñ #à"&×"7Ñ"7ô#ó ˆLð   ,Ñ.ˆFØ &ˆDÔØ× Ñ Ð rN   c                 óÂ  — t        | j                  «      \  }}t        | j                  t        «      s|rDt	        d„ | j                  D «       «      s(t        | j                  t        t        |«      «      «      S | j                  g}| j                  D ]D  }t        |«      sŒ|j                  t        |t        «      r|j                  n
t        |«      «       ŒF t        |Ž S )Nc              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wrZ   ©rß   r;   )r,  Úes     rL   r.  z1SampledFromStrategy.calc_label.<locals>.<genexpr>ã  s   è ø€ ÒM¸!œ
 1¤n×5ÑMùó   ‚)r  r  rß   ÚrangeÚanyr(   ró   r'   r  r  r³   r;   rù   r&   )r‹   Úelements_is_hashableÚ
hash_valueÚlabelsÚelements        rL   rø   zSampledFromStrategy.calc_labelÃ  s¿   € ô: ,8¸¿¹Ó+FÑ(Ð˜jÜ�d—m‘m¤UÔ+Ù ÜÑM¸t¿}¹}ÔMÔMä!Ø× Ñ Ô"6´s¸:³Ó"Góð ð ×"Ñ"Ð#ˆØ—}‘}ò 	ˆGÜ˜wÔ'Øà�M‰Mä˜g¤~Ô6ð —’ä)¨'Ó2õð		ô ˜vÐ&Ð&rN   rj   c                 ó   — | j                    S rZ   )r!  r™   s     rL   rŸ   z,SampledFromStrategy.calc_has_reusable_valuesö  s   € ð
 ×(Ñ(Ð(Ð(rN   c                 ó,   — t        | j                  «      S rZ   )r  r  r™   s     rL   rš   z%SampledFromStrategy.calc_is_cacheableý  s   € Ü˜4Ÿ=™=Ó)Ð)rN   rJ  r�   c                óä   — | j                   D ]`  \  }}}|dk(  r3 ||«      }t        j                  x}r|j                  |||gi ¬«       |}Œ?|dk(  sJ ‚ ||«      rŒO|�	||f|_        t
        c S  |S )NrÉ   ©ÚargsÚkwargsrÒ   )r!  r   rC   Úrecord_callÚ_last_rejected_filterÚfilter_not_satisfied)r‹   rJ  r�   rP   r6  rJ   rf   Úbuild_contexts           rL   Ú
_transformzSampledFromStrategy._transform   s”   € ð "&×!6Ñ!6ò 	0ÑˆD�!�XØ�uŠ}Ù˜7›�Ü$:×$@Ñ$@Ð@�=Ð@Ø!×-Ñ-¨f°a¸w¸iÐPRÐ-ÔSØ ‘à˜xÒ'Ð'Ð'Ù˜•zØÐ'Ø67¸°]˜Ô2Ü/Ò/ð	0ð ˆrN   c                 ó"  — | j                  |«      }t        |t        «      r/t        d„ | j                  D «       «      rd| j                  f|_        |t        u r$|j                  d| ›�|j                  «       ¬«       t        |t        «      rJ ‚|S )Nc              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wrZ   rB  )r,  Úxs     rL   r.  z.SampledFromStrategy.do_draw.<locals>.<genexpr>  s   è ø€ ò 6
Ø./ŒJ�qœ.×)ñ6
ùrD  zMsampled_from was given a collection of strategies: {!r}. Was one_of intended?ú'Aborted test because unable to satisfy ©rJ   )
Údo_filtered_drawrß   r;   Úallr  Ú-_sampled_from_all_strategies_elements_messagerS  Úmark_invalidÚlast_rejected_filter_locationr.   ©r‹   r�   rf   s      rL   r   zSampledFromStrategy.do_draw  s™   € Ø×&Ñ& tÓ,ˆÜ�fœnÔ-´#ñ 6
Ø37·=±=ô6
ô 3
ð
1ð —‘ðBˆDÔ>ð Ô)Ñ)à×ÑØ9¸$¸ÐBØ×;Ñ;Ó=ð ô ô ˜fÔ&6Ô7Ð7Ð7ØˆrN   Úic                 óB   — | j                  | j                  |   |¬«      S )N©r�   )rU  r  )r‹   ra  r�   s      rL   Úget_elementzSampledFromStrategy.get_element.  s   € Ø�‰˜tŸ}™}¨QÑ/°dˆÓ;Ð;rN   rC   c                 óÞ   — 	 t        | j                  «      D ]'  \  }}t        | j                  |d ¬«      |«      sŒ$|fc S  	 t        |›d| ›�«      ‚# t        $ r t        d| ›d�«      d ‚w xY w)Nrc  ztransforming elements of z erroredz is not produced by )Ú	enumerater  r$   rU  rì   r   )r‹   rC   ra  rJ  s       rL   r  zSampledFromStrategy._invert1  s†   € ð	WÜ'¨¯©Ó6ò  ‘
��7Ü §¡°¸d Ó CÀUÕKØ˜4’Kñ ô ˜e˜YÐ&:¸4¸(ÐCÓDÐDøô ò 	WäÐ!:¸4¸(À(ÐKÓLÐRVÐVð	Wús   ‚8A »A Á A ÁA,c                 óÐ  — t        «       }t        d«      D ]s  }|j                  dt        | j                  «      dz
  «      }||vsŒ0| j                  ||«      }|t        ur|c S |sd|j                  d| ›d�<   |j                  |«       Œu t        | j                  «      t        |«      z
  }|st        S t        || j                  dz
  «      }|j                  d|dz
  «      }g }t        t        t        | j                  «      | j                  dz
  «      «      D ]ƒ  }||vsŒ| j                  ||«      }|t        usŒ#t        |t        «      rJ ‚|j                  ||f«       t        |«      |kD  sŒW|j                  dt        | j                  «      dz
  |¬«       |c S  |r@|j                  |«      \  }}|j                  dt        | j                  «      dz
  |¬«       |S t        S )Né   r   rA   r2  úRetried draw from ú to satisfy filter)Úforced)rw   rE  Údraw_integerr8  r  rd  rS  Úeventsrp   Úminr  rß   r.   r³   Úchoice)	r‹   r�   Úknown_bad_indicesr7  ra  rJ  Úmax_good_indicesÚspeculative_indexÚalloweds	            rL   r[  z$SampledFromStrategy.do_filtered_draw>  sæ  € ô '*£eÐô �q“ò 	)ˆAØ×!Ñ! !¤S¨¯©Ó%7¸!Ñ%;Ó<ˆAØÐ)Ò)Ø×*Ñ*¨1¨dÓ3�ØÔ"6Ñ6Ø"’NÙ(ØSU�D—K‘KÐ"4°T°HÐ<NÐ OÑPØ!×%Ñ% aÕ(ð	)ô ˜tŸ}™}Ó-´Ð4EÓ0FÑFÐÙÜ'Ð'ô Ð/°×1GÑ1GÈ!Ñ1KÓLÐð
 !×-Ñ-¨aÐ1AÀAÑ1EÓFÐð )+ˆÜ”sœ3˜tŸ}™}Ó-¨t×/EÑ/EÈÑ/IÓJÓKò 
	'ˆAØÐ)Ò)Ø×*Ñ*¨1¨dÓ3�ØÔ"6Ò6Ü)¨'Ô3CÔDÐDÐDØ—N‘N A w <Ô0Ü˜7“|Ð&7Ó7ð ×)Ñ)¨!¬S°·±Ó-?À!Ñ-CÈAÐ)ÔNØ&šð
	'ñ ØŸ™ WÓ-‰JˆAˆwØ×Ñ˜a¤ T§]¡]Ó!3°aÑ!7ÀÐÔBØˆNä#Ð#rN   )%rÿ   r…   r  r  r  r   rö   r  r   r1   r  r  r   r   r   rŒ   r4   r;   rÉ   r   r   rÒ   r?  rø   r<   r
  rŸ   rš   r#   r.   rU  r   rd  r"   r  r[  Ú__classcell__©rð   s   @rL   r  r  w  sé  ø… ñð
 (.Ð�x ‘}Ó-ð "&Ø48ð
 ò-à˜2‘,ð-ð ˜$‘Jð	-ð
 !  c ™?¨TÑ1ð-ð Ø�'˜/Ñ*¨H°b°T¸3°YÑ,?ÀÀtÁÐKÑLØðñ
õ-ð**˜ "  q Ñ)ð *¨n¸QÑ.?ó *ð ð"Ø! 2 $¨	°!©Ð"4Ñ5ð"à	ò"ó ð"ð ØQ ¨"¨¨s¨Ñ 3ÐQÐ8LÒQó ØQò	
ò!ð(1'˜Có 1'ðf)¨fð )¸ó )ð* vð *°$ó *ðð
 ðð ˜tÑ#ðð 
ÐÑ	óð2˜Nð ¨ró ð*<˜Sð <¨ð <¸2Ð@PÑ;Pó <ðE˜Sð E U¨7°C¨<Ñ%8ó Eð7$ ^ð 7$¸Ð=MÑ8M÷ 7$rN   r  c                   óJ  ‡ — e Zd ZdZdeee      fˆ 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eee      fd	„«       Zdefd
„Zdedefd„Zdedeedf   fd„Zdefd„Zdd„Zedeee      fd„«       Zedeegee   f   ddfd„«       Zedeegef   ddfd„«       Zd„ Zˆ xZ S )râ   a;  Implements a union of strategies. Given a number of strategies this
    generates values which could have come from any of them.

    The conditional distribution draws uniformly at random from some
    non-empty subset of these strategies and then draws from the
    conditional distribution of that strategy.
    rä   c                 óŠ   •— t         ‰| �  «        t        |«      | _        d | _        d| _        d | _        t        «       | _        y rœ   )	r  rŒ   r  rã   Ú"_OneOfStrategy__element_strategiesÚ_OneOfStrategy__in_branchesÚ_OneOfStrategy__branch_samplerr	   Ú_branches_lock)r‹   rä   rð   s     €rL   rŒ   zOneOfStrategy.__init__†  s=   ø€ Ü‰ÑÔÜ#(¨Ó#4ˆÔ ØIMˆÔ!Ø"ˆÔØMQˆÔÜ#›gˆÕrN   rj   r?   c                 ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrZ   r˜   ©r,  rC  rj   s     €rL   r.  z.OneOfStrategy.calc_is_empty.<locals>.<genexpr>�  ó   øè ø€ Ò> ‘5˜—8Ñ>ùr/  ©r\  rã   r™   s    `rL   r�   zOneOfStrategy.calc_is_emptyŽ  ó   ø€ ÜÓ> T×%=Ñ%=Ô>Ó>Ð>rN   c                 ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrZ   r˜   r~  s     €rL   r.  z9OneOfStrategy.calc_has_reusable_values.<locals>.<genexpr>’  r  r/  r€  r™   s    `rL   rŸ   z&OneOfStrategy.calc_has_reusable_values‘  r�  rN   c                 ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3   ó.   •K  — | ]  } ‰|«      –— Œ y ­wrZ   r˜   r~  s     €rL   r.  z2OneOfStrategy.calc_is_cacheable.<locals>.<genexpr>•  r  r/  r€  r™   s    `rL   rš   zOneOfStrategy.calc_is_cacheable”  r�  rN   c                 ó&  — | j                   €z| h}g }| j                  D ]_  }t        |«       |j                  rŒ|j                  D ]6  }||vsŒ|j                  rŒ|j                  |«       |j                  |«       Œ8 Œa || _         | j                   S rZ   )rx  rã   Úcheck_strategyrR   rÝ   rp   r³   )r‹   r}   rä   Úargr$  s        rL   Úelement_strategiesz OneOfStrategy.element_strategies—  s�   € à×$Ñ$Ð,ð  *.¨ˆDØ/1ˆJØ×/Ñ/ò 1�Ü˜sÔ#Ø—|“|Ø Ÿ\™\ò 1˜Ø Dš=°·³Ø ŸH™H QœKØ&×-Ñ-¨aÕ0ñ1ð1ð )3ˆDÔ%Ø×(Ñ(Ð(rN   c                 óP   — t        | j                  gd„ | j                  D «       ¢­Ž S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wrZ   )rù   )r,  Úps     rL   r.  z+OneOfStrategy.calc_label.<locals>.<genexpr>·  s   è ø€ ÒJ¨A §¥ÑJùs   ‚)r(   ró   rã   rŠ   s    rL   rø   zOneOfStrategy.calc_labelµ  s+   € ÜØ×Ñð
ÙJ°×1IÑ1IÔJò
ð 	
rN   r�   c                 ó¶  ‡— | j                   }t        |«      dk(  r‰j                  |d   «      S | j                  €*t	        d„ |D «       «      rd| _        nt        |«      | _        | j                  dur*‰j                  ‰j                  | j                  «      «      S ‰j                  t        |«      j                  ˆfd„«      «      }‰j                  |«      S )NrA   r   c              3   óf   K  — | ])  }t        |«      j                  t        j                  u–— Œ+ y ­wrZ   )rþ   r�   r;   )r,  r$  s     rL   r.  z(OneOfStrategy.do_draw.<locals>.<genexpr>Æ  s-   è ø€ ò àô �Q“×*Ñ*´.×2SÑ2SÔSñùs   ‚/1Fc                 ó(   •— | j                  ‰«       S rZ   )r�   )r$  r�   s    €rL   ú<lambda>z'OneOfStrategy.do_draw.<locals>.<lambda>Ò  s   ø€ ˜a×2Ñ2°4Ó8Ð8€ rN   )r‰  r8  Údrawrz  rF  r  rÒ   )r‹   r�   rä   rO   s    `  rL   r   zOneOfStrategy.do_drawº  sÊ   ø€ Ø×,Ñ,ˆ
Üˆz‹?˜aÒð —9‘9˜Z¨™]Ó+Ð+à× Ñ Ð(ô
 ñ à#ôô ð ).�Õ%ä(;¸JÓ(G�Ô%Ø× Ñ ¨Ñ-Ø—9‘9˜TŸY™Y t×'<Ñ'<Ó=Ó>Ð>à—9‘9Ü 
Ó+×2Ñ2Û8óó
ˆð
 �y‰y˜Ó"Ð"rN   rC   .c                 ó¢  — t        | j                  «      dk(  r| j                  d   j                  |«      S t        t        dd «      }|€t        «       x}t        _        t        | «      |v rt        d| ›�«      ‚|j                  t        | «      «       	 d }t        | j                  «      D ]F  \  }}	 |g|j                  |«      ¢­}|�t        |«      t        |«      k  r|}t        |«      dk  sŒF n |j                  t        | «      «       |€t        |›d| ›�«      ‚|S # t        $ r Y Œ‚w xY w# |j                  t        | «      «       w xY w)NrA   r   Úidszrecursive inversion of r¥   z" is not produced by any branch of )r8  r‰  r  r\   Ú_inverting_one_ofsrw   r“  Úidr   rp   rf  Údiscard)r‹   rC   ÚactiveÚbestra  ÚbranchÚ	candidates          rL   r  zOneOfStrategy._invert×  sN  € ô ˆt×&Ñ&Ó'¨1Ò,Ø×*Ñ*¨1Ñ-×5Ñ5°eÓ<Ð<äÔ+¨U°DÓ9ˆØˆ>Ü.1«eÐ3ˆFÔ'Ô+Üˆd‹8�vÑÜÐ!8¸¸ÐAÓBÐBØ�
‰
”2�d“8Ôð	%Ø/3ˆDÜ& t×'>Ñ'>Ó?ò ‘	��6ðØ!"Ð ; V§^¡^°EÓ%:Ñ ;�Ið �<¤3 y£>´C¸³IÒ#=Ø$�DÜ�t“9 “>ñ
 ðð �N‰Nœ2˜d›8Ô$Øˆ<Ü % Ð*LÈTÈHÐUÓVÐVØˆøô $ò Ùðûð �N‰Nœ2˜d›8Õ$ús6   ÂD2 Â3D#Ã)D2 Ã2D2 Ä#	D/Ä,D2 Ä.D/Ä/D2 Ä2Ec                 ór   — dj                  dj                  t        t        | j                  «      «      «      S )Nz
one_of({})r)  )Úformatr9  rÉ   Úreprrã   rŠ   s    rL   r?  zOneOfStrategy.__repr__   s)   € Ø×"Ñ" 4§9¡9¬S´°t×7OÑ7OÓ-PÓ#QÓRÐRrN   c                 óF   — | j                   D ]  }|j                  «        Œ y rZ   )r‰  rî   )r‹   rC  s     rL   rë   zOneOfStrategy.do_validate  s    € Ø×(Ñ(ò 	ˆAØ�J‰J�Lñ	rN   c                 óô   — | j                   �| j                  S | j                  5  | j                  s$	 d| _        | j                  d| _        cd d d «       S | gcd d d «       S # d| _        w xY w# 1 sw Y   y xY w)NTF)rx  r‰  r{  ry  rŠ   s    rL   rÝ   zOneOfStrategy.branches  s�   € à×$Ñ$Ð0à×*Ñ*Ð*à× Ñ ñ 	Ø×%Ò%ð/Ø)-�DÔ&Ø×2Ñ2à).�DÔ&÷	ñ 	ð �v÷	ñ 	øð */�DÕ&ú÷	ð 	ús(   ¥A.³A"ÁA.ÁA.Á"	A+Á+A.Á.A7rÏ   rÅ   c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zOneOfStrategy.filter  rÓ   rN   rÔ   c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zOneOfStrategy.filter  rÖ   rN   c           
      ó†   — t        t        | j                  D �cg c]  }|j                  |«      ‘Œ c}«      d¬«      S c c}w )Nr˜   )rÙ   )rÛ   râ   rã   rÒ   )r‹   rÏ   r$  s      rL   rÒ   zOneOfStrategy.filter  s7   € ÜÜ¸×8PÑ8PÖQ°1˜1Ÿ8™8 IÕ.ÒQÓRØô
ð 	
ùÚQs   ™>r  )!rÿ   r…   r  r  r   r;   r1   rŒ   r<   r
  r�   rŸ   rš   r  r‰  rö   rø   r#   r   r   r  r"   r  r  r?  rë   rÝ   r   r   r   r4   rÒ   rt  ru  s   @rL   râ   râ   }  sO  ø„ ñð& 8¨N¸2Ñ,>Ñ#?õ &ð? 6ð ?¨dó ?ð?¨fð ?¸ó ?ð? vð ?°$ó ?ð ð) H¨^¸BÑ-?Ñ$@ò )ó ð)ð:
˜Có 
ð
#˜Nð #¨ró #ð:'˜Sð ' U¨7°C¨<Ñ%8ó 'ðRS˜#ó Sóð ð˜( >°"Ñ#5Ñ6ò ó ðð ð"Ø! 2 $¨	°!©Ð"4Ñ5ð"à	ò"ó ð"ð ØQ ¨"¨¨s¨Ñ 3ÐQÐ8LÒQó ØQö
rN   râ   Ú__argsc                  ó   — y rZ   r˜   )r£  s    rL   Úone_ofr¥  $  s   € ð rN   Ú__a1c                  ó   — y rZ   r˜   )r¦  s    rL   r¥  r¥  *  s   € Ø<?rN   Ú__a2c                  ó   — y rZ   r˜   )r¦  r¨  s     rL   r¥  r¥  .  s   € ð !rN   Ú__a3c                  ó   — y rZ   r˜   )r¦  r¨  rª  s      rL   r¥  r¥  4  s   € ð #&rN   Ú__a4c                  ó   — y rZ   r˜   )r¦  r¨  rª  r¬  s       rL   r¥  r¥  :  s   € ð (+rN   Ú__a5c                  ó   — y rZ   r˜   )r¦  r¨  rª  r¬  r®  s        rL   r¥  r¥  C  s   € ð -0rN   rO  c                   ó   — y rZ   r˜   ©rO  s    rL   r¥  r¥  M  s   € Ø?BrN   )Úeagerc                  ód  — t        | «      dk(  r"t        | d   t        «      s	 t        | d   «      } t        | «      dk(  rt        | d   t        «      r| d   S | r*t        d„ | D «       «      st        dt        | «      ›d�«      ‚t        t        t        t           | «      «      S # t        $ r Y Œ}w xY w)aR  Return a strategy which generates values from any of the argument
    strategies.

    This may be called with one iterable argument instead of multiple
    strategy arguments, in which case ``one_of(x)`` and ``one_of(*x)`` are
    equivalent.

    Examples from this strategy will generally shrink to ones that come from
    strategies earlier in the list, then shrink according to behaviour of the
    strategy that produced them. In order to get good shrinking behaviour,
    try to put simpler strategies first. e.g. ``one_of(none(), text())`` is
    better than ``one_of(text(), none())``.

    This is especially important when using recursive strategies. e.g.
    ``x = st.deferred(lambda: st.none() | st.tuples(x, x))`` will shrink well,
    but ``x = st.deferred(lambda: st.tuples(x, x) | st.none())`` will shrink
    very badly indeed.
    rA   r   c              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wrZ   rB  )r,  Úas     rL   r.  zone_of.<locals>.<genexpr>u  s   è ø€ ÒD¸!œ
 1¤n×5ÑDùrD  zDid you mean st.sampled_from(z\)?  st.one_of() is used to combine strategies, but all of the arguments were of other types.)r8  rß   r;   r  r  rF  r   rÁ   râ   r   r   r±  s    rL   r¥  r¥  Q  s¶   € ô4 ˆ4ƒy�A‚~œj¨¨a©´.ÔAð	Ü˜˜a™“>ˆDô ˆ4ƒy�A‚~œ* T¨!¡W¬nÔ=ð �A‰wˆÙ”CÑD¸tÔDÔDô Ø+¬D°«J¨>ð :Sð Só
ð 	
ô œœh¤~Ñ6¸Ó=Ó>Ð>øô# ò 	Ùð	ús   £B# Â#	B/Â.B/c                   ó  ‡ — e Zd ZdZdee   deegef   ddfˆ fd„Zde	de
fd„Zde	de
fd	„Zdefd
„Zdd„Zdedefd„Zdedeedf   fd„Zedeee      fd„«       Zedeegee   f   ddfd„«       Zedeegef   ddfd„«       Zˆ fd„Zˆ xZS )rÈ   zšA strategy which is defined purely by conversion to and from another
    strategy.

    Its parameter and distribution come from that other strategy.
    rO   rÄ   r?   Nc                 ó>   •— t         ‰| �  «        || _        || _        y rZ   )r  rŒ   Úmapped_strategyrÄ   )r‹   rO   rÄ   rð   s      €rL   rŒ   zMappedStrategy.__init__‰  s   ø€ ô
 	‰ÑÔØ'ˆÔØˆ�	rN   rj   c                 ó&   —  || j                   «      S rZ   ©r¸  r™   s     rL   r�   zMappedStrategy.calc_is_empty’  ó   € Ù�T×)Ñ)Ó*Ð*rN   c                 ó&   —  || j                   «      S rZ   rº  r™   s     rL   rš   z MappedStrategy.calc_is_cacheable•  r»  rN   c                 ó†   — t        | d«      s*| j                  ›dt        | j                  «      › d�| _        | j                  S )Nr"  z.map(r¤   )Úhasattrr¸  r+   rÄ   r"  rŠ   s    rL   r?  zMappedStrategy.__repr__˜  sC   € Ü�t˜^Ô,Ø#'×#7Ñ#7Ð":¸%Ô@_Ð`d×`iÑ`iÓ@jÐ?kÐklÐ mˆDÔØ× Ñ Ð rN   c                 ó8   — | j                   j                  «        y rZ   )r¸  rî   rŠ   s    rL   rë   zMappedStrategy.do_validate�  s   € Ø×Ñ×%Ñ%Õ'rN   r�   c                 óè  — t        j                  «       5  t        | j                  t        «      rNt        | j                  t        j                  t        j                  f«      rt        j                  dt        «       t        d«      D ]�  }|j                  t        «       d}	 |j                  | j                  «      }| j                  |«      }	 |j#                  |¬«       t%        «       j'                  || j                  |gi ¬«       |c cd d d «       S  	 d d d «       ‚# t         $ r }|}d}Y d }~|j#                  |¬«       Œ¿d }~ww xY w# |j#                  |¬«       w xY w# 1 sw Y   ‚xY w)NÚignorerh  FT©r–  rN  )r¹   Úcatch_warningsrß   rÄ   rþ   Ú
issubclassr   ÚMappingÚSetÚsimplefilterÚBytesWarningrE  Ú
start_spanÚ$MAPPED_SEARCH_STRATEGY_DO_DRAW_LABELr‘  r¸  r    Ú	stop_spanr   rQ  )r‹   r�   r7  r–  rX  rf   ÚerrÚfailed_assumptions           rL   r   zMappedStrategy.do_draw   s=  € Ü×$Ñ$Ó&ñ 	Ü˜$Ÿ)™)¤TÔ*¬zØ—	‘	œCŸK™K¬¯©Ð1ô0ô ×%Ñ% h´Ô=Ü˜1“Xò �Ø—‘Ô DÔEØ�ð4ØŸ	™	 $×"6Ñ"6Ó7�AØ!ŸY™Y q›\‘Fð —N‘N¨7�NÔ3Ü%Ó'×3Ñ3Ø˜DŸI™I¨Q¨C¸ð 4ô ð ‘÷7	ñ 	ñ
÷	ð8  Ðøô# -ò 
ð ),Ð%Ø"�GÛà—N‘N¨7�NÕ3ûð
ûð —N‘N¨7�NÕ3ú÷/	ð8  ÐúsN   •BE'Â$,D$Ã=E'ÄE'Ä$	EÄ-EÄ1EÄ5E'ÅEÅEÅE$Å$E'Å'E1rC   .c                 ó2  — t        | j                  t        «      rlt        | j                  t        j
                  «      rHt        || j                  «      r2| j                  j                  t        |j                  «       «      «      S t        d| ›d|›d�«      ‚)Nzcannot invert z (value=r¤   )rß   rÄ   rþ   rÄ  r   rÅ  r¸  r  rÁ   ry   r   r  s     rL   r  zMappedStrategy._invert¿  sn   € ô
 �t—y‘y¤$Ô'Ü˜4Ÿ9™9¤c§k¡kÔ2Ü˜5 $§)¡)Ô,à×'Ñ'×/Ñ/´°U·[±[³]Ó0CÓDÐDÜ˜^¨D¨8°8¸E¸9ÀAÐFÓGÐGrN   c                 ó~   — | j                   j                  D �cg c]  }t        || j                  ¬«      ‘Œ c}S c c}w )NrÇ   )r¸  rÝ   rÈ   rÄ   ©r‹   rO   s     rL   rÝ   zMappedStrategy.branchesË  s;   € ð !×0Ñ0×9Ñ9ö
àô ˜8¨$¯)©)Ö4ò
ð 	
ùò 
s   ™:rÏ   rÅ   c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zMappedStrategy.filterÒ  rÓ   rN   zSearchStrategy[MappedTo]c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zMappedStrategy.filterÖ  s   € ð &)rN   c                 óö  •— t        «       }t        | j                  |«      rTt        | j                  t        «      r$t        | j                  t        j                  «      s%| j                  t        «       v st        ‰| �)  |«      S |j                  | j                  |«      }t        |dd «      | j                  u rt        ‰| �)  |«      S t         t	        | «      || j                  «      |ft        «       f¬«      S )NÚfiltered_strategyrØ   )Ú_list_strategy_typerß   r¸  rÄ   rþ   rÄ  r   Ú
CollectionÚ_collection_ish_functionsr  rÒ   r\   rÛ   rM   )r‹   rÏ   ÚListStrategyÚnewrð   s       €rL   rÒ   zMappedStrategy.filterÚ  sÍ   ø€ ô +Ó,ˆÜ˜$×.Ñ.°Ô=Ü˜Ÿ	™	¤4Ô(¬Z¸¿	¹	Ä3Ç>Á>Ô-RØ�y‰yÔ5Ó7Ñ7ä‘7‘> )Ó,Ð,ð ×!Ñ! $×"6Ñ"6¸	ÓBˆÜ�3Ð+¨TÓ2°d×6JÑ6JÑJÜ‘7‘> )Ó,Ð,ô  ØŒD�‹J�s˜DŸI™IÓ&Ø!�|Ü!9Ó!;Ð =ô
ð 	
rN   r  )rÿ   r…   r  r  r;   r9   r   r:   rŒ   r<   r
  r�   rš   r  r?  rë   r#   r   r   r  r"   r  r  r   rÝ   r   r   r4   rÒ   rt  ru  s   @rL   rÈ   rÈ   ‚  s5  ø„ ñðà  Ñ,ðð ˜
�| XÐ-Ñ.ðð 
õ	ð+ 6ð +¨dó +ð+ vð +°$ó +ð!˜#ó !ó
(ð ˜Nð  ¨xó  ð>
H˜Sð 
H U¨7°C¨<Ñ%8ó 
Hð ð
˜( >°(Ñ#;Ñ<ò 
ó ð
ð ð"Ø! 8 *¨i¸©lÐ":Ñ;ð"à	ò"ó ð"ð ð)Ø! 8 *¨c /Ñ2ð)à	#ò)ó ð)÷
ð 
rN   rÈ   c                  ó   — ddl m}  | S )Nr   ©rØ  )Ú+hypothesis.strategies._internal.collectionsrØ  rÛ  s    rL   rÕ  rÕ  ó  s   € åHàÐrN   c                  ó  — t         g} t        j                  j                  d«      x}rÞ| |j                  |j
                  |j                  |j                  |j                  |j                  |j                  |j                  |j                  |j                  |j                  |j                  j                  |j                  j                   |j                  j"                  |j$                  |j&                  |j(                  gz  } | S )NÚnumpy)ÚsortedrD   rµ   re   Ú
empty_likeÚeyeÚidentityÚ	ones_likeÚ
zeros_likeÚarrayÚasarrayÚ
asanyarrayÚascontiguousarrayÚasmatrixÚcopyÚrecÚ
fromarraysÚfromrecordsÚdiagÚasarray_chkfiniteÚasfortranarray)ÚfuncsÚnps     rL   r×  r×  ú  sÆ   € ÜˆH€EÜ�[‰[�_‰_˜WÓ%Ð%€rÐ%ð 	Ø�M‰MØ�F‰FØ�K‰KØ�L‰LØ�M‰MØ�H‰HØ�J‰JØ�M‰MØ× Ñ Ø�K‰KØ�G‰GØ�F‰F�L‰LØ�F‰F×ÑØ�F‰F×ÑØ�G‰Gà× Ñ Ø×Ñð%
ñ 	
ˆð* €LrN   zfilter not satisfiedc            	       ór  ‡ — e Zd Z	 ddee   deeegef   df   deedz  df   dz  fˆ fd„Z	de
defd	„Zde
defd
„Zdefd„Zdd„Zedeegee   f   ddfd„«       Zedeegef   ddfd„«       Zd„ Zedeegef   fd„«       Zdedefd„Zdedeez  fd„Zdedeedf   fd„Zedeee      fd„«       Zˆ xZS )rÛ   NrO   rÙ   .rÚ   c                 ó°  •— t         ‰| �  «        |€dt        |«      z  }t        |«      t        |«      k(  sJ ‚t        |t        «      r:|j
                  |z   | _        |j                  |z   | _        |j                  | _        n|| _        || _        || _        t        | j
                  t        «      sJ ‚t        | j                  t        «      rJ ‚d | _	        y )NrZ   )
r  rŒ   r8  rß   rÛ   Úflat_conditionsrÚ   rÔ  r  Ú_FilteredStrategy__condition)r‹   rO   rÙ   rÚ   rð   s       €rL   rŒ   zFilteredStrategy.__init__  s×   ø€ ô 	‰ÑÔàÐ&Ø")¬C°
«OÑ";ÐÜÐ&Ó'¬3¨z«?Ò:Ð:Ð:Ü�hÔ 0Ô1ð ×(Ñ(¨:Ñ5ð Ô ð ×,Ñ,Ð/BÑBð Ô$ð :B×9SÑ9SˆDÕ"à#-ˆDÔ Ø':ˆDÔ$Ø%-ˆDÔ"ä˜$×.Ñ.´Ô6Ð6Ð6Ü˜d×4Ñ4Ô6FÔGÐGÐGà7;ˆÕrN   rj   r?   c                 ó&   —  || j                   «      S rZ   ©rÔ  r™   s     rL   r�   zFilteredStrategy.calc_is_empty:  ó   € Ù�T×+Ñ+Ó,Ð,rN   c                 ó&   —  || j                   «      S rZ   rø  r™   s     rL   rš   z"FilteredStrategy.calc_is_cacheable=  rù  rN   c                 ó´   — t        | d«      sAdj                  | j                  dj                  d„ | j                  D «       «      «      | _        | j
                  S )Nr"  z{!r}{}r2  c              3   ó:   K  — | ]  }d t        |«      › d�–— Œ y­w)z.filter(r¤   Nr5  )r,  Úconds     rL   r.  z,FilteredStrategy.__repr__.<locals>.<genexpr>D  s(   è ø€ ò àð Ô>¸tÓDÐEÀQÔGñùs   ‚)r¾  rœ  rÔ  r9  rõ  r"  rŠ   s    rL   r?  zFilteredStrategy.__repr__@  sS   € Ü�t˜^Ô,Ø (§¡Ø×&Ñ&Ø—‘ñ à $× 4Ñ 4ôó ó!ˆDÔð × Ñ Ð rN   c                 óÖ  — | j                   j                  «        | j                   }t        | j                  | j                  d¬«      D ]4  \  }}t
        j                  |«      5  |j                  |«      }d d d «       Œ6 t        |t        «      r7t        j                  | |j                   |j                  |j                  «       y t        j                  | |d«       y # 1 sw Y   ŒŸxY w)NT©Ústrictr˜   )rÔ  rî   Úziprõ  rÚ   r>   Ú
with_valuerÒ   rß   rÛ   rŒ   )r‹   Úfreshrý  rJ   s       rL   rë   zFilteredStrategy.do_validateK  sÕ   € ð 	×Ñ×'Ñ'Ô)ð ×&Ñ&ˆÜ!Ø× Ñ  $×":Ñ":À4ô
ò 	+‰NˆD�(ô +×5Ñ5°hÓ?ñ +ØŸ™ TÓ*�÷+ð +ð	+ô
 �eÔ-Ô.ô ×%Ñ%ØØ×'Ñ'Ø×%Ñ%Ø×)Ñ)õ	ô ×%Ñ% d¨E°2Õ6÷+ð +ús   Á$CÃC(	rÏ   zFilteredStrategy[T]c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zFilteredStrategy.filterg  s   € ð !$rN   zFilteredStrategy[Ex]c                  ó   — y rZ   r˜   rÑ   s     rL   rÒ   zFilteredStrategy.filterk  s   € ØPSrN   c                 ó$  — | j                   j                  |«      }t        |t        «      rEt        |j                   | j                  |j                  z   | j
                  |j
                  z   «      S t        || j                  | j
                  «      S rZ   )rÔ  rÒ   rß   rÛ   rõ  rÚ   )r‹   rÏ   Úouts      rL   rÒ   zFilteredStrategy.filterm  s‚   € ð
 ×$Ñ$×+Ñ+¨IÓ6ˆô �cÔ+Ô,Ü#Ø×%Ñ%Ø×$Ñ$ s×':Ñ':Ñ:Ø×(Ñ(¨3×+BÑ+BÑBóð ô    T×%9Ñ%9¸4×;SÑ;SÓTÐTrN   c                 óÈ   ‡ — ‰ j                   x}�|S t        ‰ j                  «      dk(  r‰ j                  d   }n!t        ‰ j                  «      dk(  rd„ }nˆ fd„}|‰ _         |S )NrA   r   c                  ó   — yrd   r˜   )r7  s    rL   r�  z,FilteredStrategy.condition.<locals>.<lambda>‹  s   � rN   c                 óB   •‡ — t        ˆ fd„‰j                  D «       «      S )Nc              3   ó.   •K  — | ]  } |‰«      –— Œ y ­wrZ   r˜   )r,  rý  rX  s     €rL   r.  z?FilteredStrategy.condition.<locals>.<lambda>.<locals>.<genexpr>�  s   øè ø€ Ò%O°$¡d¨1§gÑ%Oùr/  )r\  rõ  )rX  r‹   s   `€rL   r�  z,FilteredStrategy.condition.<locals>.<lambda>�  s   ù€ ¤#Ó%O¸$×:NÑ:NÔ%OÓ"O€ rN   )rö  r8  rõ  rÑ   s   ` rL   rÏ   zFilteredStrategy.condition~  sj   ø€ ð
 ×)Ñ)Ð)ˆIÐ6ØÐäˆt×#Ñ#Ó$¨Ò)à×,Ñ,¨QÑ/‰IÜ�×%Ñ%Ó&¨!Ò+á&‰IãOˆIØ$ˆÔØÐrN   r�   c                 óž   — | j                  |«      }|t        urt        t        |«      S |j	                  d| ›�|j                  «       ¬«       y )NrY  rZ  )r[  rS  r   r1   r^  r_  r`  s      rL   r   zFilteredStrategy.do_draw‘  sS   € Ø×&Ñ& tÓ,ˆØÔ-Ñ-Üœ˜FÓ#Ð#ð 	×ÑØ5°d°XÐ>Ø×7Ñ7Ó9ð 	õ 	
rN   c           	      ó¦  ‡— t        d«      D ]¤  }|j                  t        «       d }	 |j                  | j                  «      Št        ˆfd„t        | j                  | j                  d¬«      D «       d «      }|j                  |d u¬«       |€‰c S ||_
        |dk(  sŒ’d|j                  d| ›d	�<   Œ¦ t        S # |j                  |d u¬«       w xY w)
Nrh  c              3   ó<   •K  — | ]  \  }} |‰«      s||f–— Œ y ­wrZ   r˜   )r,  rý  rJ   rC   s      €rL   r.  z4FilteredStrategy.do_filtered_draw.<locals>.<genexpr>¥  s+   øè ø€ ò á*˜D (ñ  $ Eœ{ð	 ˜xÔ(ñùs   ƒTrÿ  rÂ  r   r2  ri  rj  )rE  rÉ  Ú&FILTERED_SEARCH_STRATEGY_DO_DRAW_LABELr‘  rÔ  Únextr  rõ  rÚ   rË  rR  rm  rS  )r‹   r�   ra  ÚfailingrC   s       @rL   r[  z!FilteredStrategy.do_filtered_drawœ  sà   ø€ Ü�q“ò 	RˆAØ�O‰OÔBÔCØˆGð<ØŸ	™	 $×"8Ñ"8Ó9�ô óä.1Ø ×0Ñ0°$×2JÑ2JÐSWô/ôð ó	�ð —‘ w°dÐ':�Ô;ØˆØ’Ø)0ˆDÔ&Ø�A‹vØOQ�—‘Ð0°°Ð8JÐKÒLð/	Rô2 $Ð#øð —‘ w°dÐ':�Õ;ús   ¨AB:Â:CrC   c                 ó¼   — 	 | j                  |«      }|st        |›d| ›�«      ‚| j                  j	                  |«      S # t        $ r t        |›d| ›�«      d ‚w xY w)Nz errored in filter z does not satisfy filter )rÏ   rì   r   rÔ  r  )r‹   rC   Ú	satisfieds      rL   r  zFilteredStrategy._invert¸  su   € ð	RØŸ™ uÓ-ˆIñ Ü % Ð*CÀDÀ8ÐLÓMÐMØ×%Ñ%×-Ñ-¨eÓ4Ð4øô ò 	Rä % Ð*=¸d¸XÐFÓGÈTÐQð	Rús   ‚A  Á Ac                 ó’   — | j                   j                  D �cg c]#  }t        || j                  | j                  «      ‘Œ% c}S c c}w rZ   )rÔ  rÝ   rÛ   rõ  rÚ   rÐ  s     rL   rÝ   zFilteredStrategy.branchesÄ  sE   € ð !×2Ñ2×;Ñ;ö
àô ˜X t×';Ñ';¸T×=UÑ=UÕVò
ð 	
ùò 
s   ™(ArZ   r  )rÿ   r…   r  r;   r1   r  r   r   r  rŒ   r<   r
  r�   rš   r?  rë   r   r   r4   rÒ   r  rÏ   r#   r   r.   r[  r"   r  r   rÝ   rt  ru  s   @rL   rÛ   rÛ     s€  ø„ ð
 >Bñ	<à  Ñ$ð<ð ˜( B 4¨ 9Ñ-¨sÐ2Ñ3ð<ð # 3¨¡:¨s ?Ñ3°dÑ:õ	<ð<- 6ð -¨dó -ð- vð -°$ó -ð	!˜#ó 	!ó7ð8 ð$Ø! 2 $¨	°!©Ð"4Ñ5ð$à	ò$ó ð$ð ØS ¨"¨¨s¨Ñ 3ÐSÐ8NÒSó ØSòUð" ð˜8 R D¨# IÑ.ò ó ðð$	
˜Nð 	
¨ró 	
ð$ ^ð $¸Ð=MÑ8Mó $ð8
5˜Sð 
5 U¨7°C¨<Ñ%8ó 
5ð ð
˜( >°"Ñ#5Ñ6ò 
ó ô
rN   rÛ   rˆ  c                 ó  — t        |t        «      sJ ‚t        | t        «      s^d}t        | t        t        f«      rdj                  |xs d«      }|r|dz  }t        d|› d|› | ›dt        | «      j                  › d�«      ‚y )	Nr2  z, such as st.sampled_from({}),z...ú=zExpected a SearchStrategyz	 but got z (type=r¤   )	rß   r  r;   rÁ   r  rœ  r   rþ   rÿ   )rˆ  rP   Úhints      rL   r‡  r‡  Ì  s�   € ä�dœCÔ Ð Ð Ü�cœ>Ô*ØˆÜ�cœD¤%˜=Ô)Ø3×:Ñ:¸4º=À5ÓIˆDÙØ�C‰KˆDÜØ'¨ v¨Y°t°f¸S¸Gð DÜ˜#“Y×'Ñ'Ð(¨ð+ó
ð 	
ð +rN   )r2  )kr·   rD   ré   r¹   Úcollectionsr   r   Úcollections.abcr   r   Ú	functoolsr   Úrandomr   r	   Útypesr
   Útypingr   r   r   r   r   r   r   r   r   r   Úhypothesis._settingsr   r   r   r   Úhypothesis.controlr   r   Úhypothesis.errorsr   r   r   r   r   r    Úhypothesis.internal.conjecturer!   r  Ú%hypothesis.internal.conjecture.choicer"   Ú#hypothesis.internal.conjecture.datar#   Ú)hypothesis.internal.conjecture.junkdrawerr$   Ú$hypothesis.internal.conjecture.utilsr%   r&   r'   r(   Úhypothesis.internal.coverager)   Úhypothesis.internal.escalationr*   Úhypothesis.internal.reflectionr+   r,   Ú%hypothesis.strategies._internal.utilsr-   Úhypothesis.utils.conventionsr.   r/   Ú!hypothesis.utils.dynamicvariablesr0   r1   r4   r5   r6   r7   r8   r9   r:   r
  r<   r  r=   rÊ  r  r÷   r>   r  rM   rv   rƒ   r;   r  rö   r  r  r  Úlocalr”  râ   r¥  rÈ   rÕ  r×  rS  rÛ   r‡  r˜   rN   rL   ú<module>r-     s¼  ðô 
Û 
Û Û ß (ß .Ý Ý Ý Ý ÷÷ ÷ ÷ IÓ Hß L÷÷ õ 7Ý 9Ý >Ý B÷ó õ 8Ý =÷õ Cß BÝ =áÙ	� ¨sÔ	3�Bá	� Ô	&€BáˆCƒL€ÙˆTƒ]€ÙˆTƒ]€ÙˆTƒ]€ÙˆTƒ]€Ù�\Ó"€
Ù�:Ó€ØÐ.Ð/°Ð5Ñ6€ˆ	Ó 6Ù˜}Ó-€á';Ø.ó(Ð $ñ *>Ø/ó*Ð &ñ ‹W€
ñ 3BÀ'Ó2JÐ ˜?¨3Ñ/Ó Jð: #¨¡*ó :ð"R,Ð!1ð R,¸ð R,Àvð R,ÐRUó R,ôjcP�W˜R‘[ô cPðL˜ð  5¨¨s°T©zÐ)9Ñ#:ó ð"�vð " $ó "ô~$˜.¨Ñ,ô ~$ðF %�Y—_‘_Ó&Ð ôd
�N 2Ñ&ô d
ðN 
ðØ�^ BÑ'Ñ(ðà�BÑòó 
ðð
 
Ø ?� Ñ#Ð ?¨°rÑ(:Ò ?ó 
Ø ?ð 
ð!Ø
˜Ñ
ð!Ø$2°1Ñ$5ð!à�B˜‘FÑò!ó 
ð!ð
 
ð&Ø
˜Ñ
ð&Ø$2°1Ñ$5ð&Ø=KÈBÑ=Oð&à�B˜‘F˜R‘KÑ ò&ó 
ð&ð
 
ð+Ø
˜Ñ
ð+à
˜Ñ
ð+ð ˜Ñ
ð+ð ˜Ñ
ð	+ð
 �B˜‘F˜R‘K "Ñ$Ñ%ò+ó 
ð+ð 
ð0Ø
˜Ñ
ð0à
˜Ñ
ð0ð ˜Ñ
ð0ð ˜Ñ
ð	0ð
 ˜Ñ
ð0ð �B˜‘F˜R‘K "Ñ$ rÑ)Ñ*ò0ó 
ð0ð 
Ø B�. Ñ%Ð B¨.¸Ñ*=Ò Bó 
Ø Bñ ˜Ôð-?Ø�N 3Ñ'Ñ(¨>¸#Ñ+>Ñ>ð-?à�CÑò-?ó ð-?ô`n
�^ HÑ-¨w°zÀ8Ð7KÑ/Lô n
ðb ð˜Sò ó ðð 8¨C¡=ó ñ< (Ð(>Ó?Ð ôn
�~ bÑ)ô n
ðb ñ
˜ð 
 cð 
°4ò 
ó ñ
rN   