
    i~m                        S SK r S SKJr  S SKJr  S SKJrJr  S SK	J
r
  S SKJr  S SKJr  S SKJrJr  S S	KJr  S S
KJrJr  / SQr\\S4   r\\-  S-  \-  r\\-  S-  r\\-  \-  r\\-  r\\\S4   -  r  " S S\5      r!\S 5       r"\S 5       r#Sr$\S 5       r%\" 5       SSSSS.S\S\S-  S\S\S-  S\RL                  \   4
S jj5       r'\" 5       S SS.S\S\S\S-  S\RL                  \\S4      4S jj5       r(\" 5       S SSSS.S \S\S\S-  S\S\S-  S\RL                  \   4S! jj5       r)S"r*S#\* S$\* S%3r+\+ S$\+ S&3r,S'\, S(\+ S)3r-S'\, S(\, S)3r. " S* S+\5      r/S, r0\" 5       \\S-S SSSS..S/\\-  S0\\1-  S1\S\S\S-  S\S\S-  S\RL                  \!   4S2 jj5       r2 " S3 S4\RL                  5      r3 " S5 S6\RL                  5      r4g)7    N)EllipsisType)
NamedTuple)assume
strategiesInvalidArgument)_calc_p_continue)check_function)
check_typecheck_valid_interval)defines_strategy)UniqueIdentifiernot_set)NDIM_MAX_BIE
BasicIndexBasicIndexStrategyBroadcastableShapes#MutuallyBroadcastableShapesStrategyShape_BIENoEllipsis_BIENoEllipsisNoNewaxis_BIENoNewaxisarray_shapesbroadcastable_shapescheck_argumentcheck_valid_dimsmutually_broadcastable_shapesorder_checkvalid_tuple_axes.c                   4    \ rS rSr% \\S4   \S'   \\S'   Srg)r   8   .input_shapesresult_shape N__name__
__module____qualname____firstlineno__tupler   __annotations____static_attributes__r%       ^/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/hypothesis/extra/_array_helpers.pyr   r   8       s
##r.   r   c                 H    U (       d  [        UR                  " U0 UD65      eg N)r   format)	conditionfail_messagef_argsf_kwargss       r/   r   r   =   s%    l116FXFGG r.   c           
      n    X:  a  [        SU  SU SU 35      eX#:  a  [        SU  SU SU  SU 35      eg )Nmin_z must be at least z	 but was =z is larger than max_r   )namefloorr9   max_s       r/   r   r   C   sU    |TF*<UG9TFSTT{TF!D61EdV1TFSTT r.       c                 H    U [         :  a  [        U SU  S[          S35      eg )Nr:   z8, but Hypothesis does not support arrays with more than z dimensions)r   r   )dimsr;   s     r/   r   r   S   s7    hfAdV !
+/
 	
 r.      min_dimsmax_dimsmin_sidemax_siderC   rD   rE   rF   returnc                    [        [        U S5        [        [        US5        [        U S5        Uc  [        U S-   [        5      n[        [        US5        [        US5        Uc  US-   n[        [        US5        [        SSX5        [        S	SX#5        [        R                  " [        R                  " X#5      XS
9R                  [        5      $ )a  Return a strategy for array shapes (tuples of int >= 1).

* ``min_dims`` is the smallest length that the generated shape can possess.
* ``max_dims`` is the largest length that the generated shape can possess,
  defaulting to ``min_dims + 2``.
* ``min_side`` is the smallest size that a dimension can possess.
* ``max_side`` is the largest size that a dimension can possess,
  defaulting to ``min_side + 5``.
rC   rE      rD      rF   r@   r   sidemin_sizemax_size)r   intr   minr   r   stlistsintegersmapr+   rB   s       r/   r   r   \   s    " sHj)sHj)Xz*x!|X.sHj)Xz*a<sHj)8.8.88
H'(	c%jr.   rL   ndimrM   rN   c                x  ^  [        [        T S5        [        [        US5        Uc  T n[        [        US5        [        SSX5        [        UT SS5        [        R
                  " S[        SST -  S-
  5      5      R                  U 4S j5      n[        R                  " X1UU 4S	 jS
9R                  [        5      $ )a  
All tuples will have a length >= ``min_size`` and <= ``max_size``. The default
value for ``max_size`` is ``ndim``.

Examples from this strategy shrink towards an empty tuple, which render most
sequential functions as no-ops.

The following are some examples drawn from this strategy.

.. code-block:: pycon

  >>> [valid_tuple_axes(3).example() for i in range(4)]
  [(-3, 1), (0, 1, -1), (0, 2), (0, -2, 2)]

``valid_tuple_axes`` can be joined with other strategies to generate
any type of valid axis object, i.e. integers, tuples, and ``None``:

.. code-block:: python

  any_axis_strategy = none() | integers(-ndim, ndim - 1) | valid_tuple_axes(ndim)
rU   rM   rN   sizer   rI   rA   c                 $   > U T:  a  U $ U ST-  -
  $ )NrI   r%   xrU   s    r/   <lambda>"valid_tuple_axes.<locals>.<lambda>   s    q4x!1QT\1r.   c                    > U T-  $ r2   r%   rY   s    r/   r[   r\      s	    Dr.   )rM   rN   	unique_by)
r   rO   r   r   rQ   rS   maxrT   rR   r+   )rU   rM   rN   axess   `   r/   r    r       s    8 sD&!sHj)sHj)8.4V<;;q#aTA./331D 88(>P	c%jr.   shapec                  ^^ [        [        U S5        [        [        TS5        [        [        US5        [        US5        TSL =(       d    USL nUc&  [	        [        [        U 5      U5      S-   [        5      n[        [        US5        [        US5        Tc  [        X* S T4-   5      S-   m[        [        TS5        [        SS	X5        [        S
S	TT5        U(       a  UnSnOUnSn[        U4S jU SSS2   SU  5       5      (       d  [        SU  SU SU ST 35      eTSs=::  a  T::  d?  O  [        U4S jU SSS2   SU  5       5      (       d  [        SU  SU SU ST ST 3
5      eU(       dN  [        [        U5      U SSS2   SS9 H0  u  pU	T:  a
  U	S:w  a  Un  OTSs=::  a  T::  a  M$  O  U	T::  a  M.  Un  O   [        SU UUTTS9R                  S 5      $ )a  Return a strategy for shapes that are broadcast-compatible with the
provided shape.

Examples from this strategy shrink towards a shape with length ``min_dims``.
The size of an aligned dimension shrinks towards size ``1``. The size of an
unaligned dimension shrink towards ``min_side``.

* ``shape`` is a tuple of integers.
* ``min_dims`` is the smallest length that the generated shape can possess.
* ``max_dims`` is the largest length that the generated shape can possess,
  defaulting to ``max(len(shape), min_dims) + 2``.
* ``min_side`` is the smallest size that an unaligned dimension can possess.
* ``max_side`` is the largest size that an unaligned dimension can possess,
  defaulting to 2 plus the size of the largest aligned dimension.

The following are some examples drawn from this strategy.

.. code-block:: pycon

    >>> [broadcastable_shapes(shape=(2, 3)).example() for i in range(5)]
    [(1, 3), (), (2, 3), (2, 1), (4, 1, 3), (3, )]

ra   rE   rC   NrI   rD   rF   r@   r   rK   c              3   <   >#    U  H  oS :w  d  M
  TU:*  v   M     g7frA   Nr%   .0srE   s     r/   	<genexpr>'broadcastable_shapes.<locals>.<genexpr>   s     C&8F}x1}&8   	zGiven shape=9, there are no broadcast-compatible shapes that satisfy: r:    and min_side=rA   c              3   ,   >#    U  H	  oT:*  v   M     g 7fr2   r%   rf   rg   rF   s     r/   rh   ri      s     (S@R1h@R   Given base_shape=?, there are no broadcast-compatible shapes that satisfy all of , min_side=, and max_side=Fstrict)
num_shapes
base_shaperC   rD   rE   rF   c                      U R                   S   $ )Nr   )r#   )rZ   s    r/   r[   &broadcastable_shapes.<locals>.<lambda>  s    ANN1%r.   )r   r+   rO   r   rP   r_   lenr   r   allr   zipranger   rT   )
ra   rC   rD   rE   rF   strict_checkr@   
bound_namenrg   s
      ``     r/   r   r      s   @ ueW%sHj)sHj)Xz*t#7x4'7Ls3u:x014h?sHj)Xz*uYZ(H;67!;sHj)8.8X.

 CeDbDk%4&8CCC5' "$$.<qnXJP
 	
 	A!!S(SddET@R(S%S%Sw '**4Qtf = z
<
 	
 httUCDA8|Q-X-h D / 
c
%&'r.   z\w+\??z\((?:z(?:,z){0,31})?\)z)*^->$c                   4    \ rS rSr% \\S4   \S'   \\S'   Srg)
_GUfuncSigi(  .r#   r$   r%   Nr&   r%   r.   r/   r   r   (  r0   r.   r   c                 Z   [         R                  " [        U 5      (       dr  [         R                  " [        U 5      (       a  [	        SU < S35      e[         R                  " SU 5      (       a  [	        SU < S[
         S35      e[	        U < S35      eS U R                  S	5       5       u  p[        U5      S
:X  d   eUS   n/ UQUP7 HA  nU H8  n [        UR                  S5      5        SU;   a  [	        SU< SU < S35      eM:     MC     [        XS9$ ! [         a    U VVs1 s H  of  H  owR                  S5      iM     M     Os  snnf nnnU Vs1 s H  owR                  S5      iM     Os  snf n	nUR                  S5      X-
  ;   a  [	        SU< SU < S35      S e M  f = f)NzHypothesis does not yet support generalised ufunc signatures with multiple output arrays - mostly because we don't know of anyone who uses them!  Please get in touch with us to fix that.
 (signature=)zd^\((?:\w+(?:,\w+)*)?\)(?:,\((?:\w+(?:,\w+)*)?\))*->\((?:\w+(?:,\w+)*)?\)(?:,\((?:\w+(?:,\w+)*)?\))*$z
signature=zQ matches Numpy's regex for gufunc signatures, but contains shapes with more than z  dimensions and is thus invalid.z  is not a valid gufunc signaturec              3   x   #    U  H0  n[        S  [        R                  " [        U5       5       5      v   M2     g7f)c              3   j   #    U  H)  n[        [        R                  " [        U5      5      v   M+     g 7fr2   )r+   refindall
_DIMENSION)rf   as     r/   rh   ?_hypothesis_parse_gufunc_signature.<locals>.<genexpr>.<genexpr>E  s%     U8T1eBJJz1-..8Ts   13N)r+   r   r   _SHAPE)rf   arg_lists     r/   rh   5_hypothesis_parse_gufunc_signature.<locals>.<genexpr>D  s0      #-H 	U

688TUUU-s   8:r   rA   r   ?zGot dimension z, but handling of frozen optional dimensions is ambiguous.  If you known how this should work, please contact us to get this fixed and documented (signature=z).zThe zi dimension only appears in the output shape, and is not frozen, so the size is not determined (signature=r#   r$   )r   match
_SIGNATURE_SIGNATURE_MULTIPLE_OUTPUTr   r   splitr{   rO   strip
ValueErrorr   )
	signaturer#   output_shapesr$   ra   r;   shpr   names_in	names_outs
             r/   "_hypothesis_parse_gufunc_signaturer   -  s   88J	**88.	::!" !l!%  88E 
 
 "9, 66>Z?_a  -MNOO#!-#L }""" #L /<..D DJJsO$$;)( 1SHQ|SUW    /$ <KK   4@NLS#QGGCL#LLNN3?@<aWWS\<@	@::c?y';<)th 'QFO\QSU    = s*   4DF*'#E
F*E3
24F*)F*r%   rw   r   rx   rC   rD   rE   rF   rw   r   rx   c                   ^^ SnU [         La?  [        U[         L U5        [        [        U S5        [	        U [        5      (       d   eSnSn	O~[        U[         LU5        Uc  [        S5      e[        [        US5        [        U5      n/ UR                  QUR                  P7n
[        S U
 5       5      n	[        UR                  5      n U S:  a  [        S	U  S
35      e[        [        US5        [        [        TS5        [        [        US5        [        US5        USLnUc)  [        [        [        U5      U5      S-   [        U	-
  5      n[        [        US5        [        US5        Tc  [        X$* S T4-   5      S-   m[        [        TS5        [!        SSX45        [!        SSTT5        Ub'  U[        U	-
  :  a  [        SU< S[         SU< 35      eU(       a  UnSnOUnSn[#        U4S jUSSS2   SU  5       5      (       d  [        SU SU SU ST 35      eTSs=::  a  T::  d?  O  [#        U4S jUSSS2   SU  5       5      (       d  [        SU SU SU ST ST 3
5      eU(       dN  [%        ['        U5      USSS2   S S!9 H0  u  pUT:  a
  US:w  a  Un  OTSs=::  a  T::  a  M$  O  UT::  a  M.  Un  O   [)        U UUUUTTS"9$ )#a  
Return a strategy for a specified number of shapes N that are
mutually-broadcastable with one another and with the provided base shape.

* ``num_shapes`` is the number of mutually broadcast-compatible shapes to generate.
* ``base_shape`` is the shape against which all generated shapes can broadcast.
  The default shape is empty, which corresponds to a scalar and thus does
  not constrain broadcasting at all.
* ``min_dims`` is the smallest length that the generated shape can possess.
* ``max_dims`` is the largest length that the generated shape can possess,
  defaulting to ``max(len(shape), min_dims) + 2``.
* ``min_side`` is the smallest size that an unaligned dimension can possess.
* ``max_side`` is the largest size that an unaligned dimension can possess,
  defaulting to 2 plus the size of the largest aligned dimension.

The strategy will generate a :obj:`python:typing.NamedTuple` containing:

* ``input_shapes`` as a tuple of the N generated shapes.
* ``result_shape`` as the resulting shape produced by broadcasting the N shapes
  with the base shape.

The following are some examples drawn from this strategy.

.. code-block:: pycon

    >>> # Draw three shapes where each shape is broadcast-compatible with (2, 3)
    ... strat = mutually_broadcastable_shapes(num_shapes=3, base_shape=(2, 3))
    >>> for _ in range(5):
    ...     print(strat.example())
    BroadcastableShapes(input_shapes=((4, 1, 3), (4, 2, 3), ()), result_shape=(4, 2, 3))
    BroadcastableShapes(input_shapes=((3,), (1, 3), (2, 3)), result_shape=(2, 3))
    BroadcastableShapes(input_shapes=((), (), ()), result_shape=())
    BroadcastableShapes(input_shapes=((3,), (), (3,)), result_shape=(3,))
    BroadcastableShapes(input_shapes=((1, 2, 3), (3,), ()), result_shape=(1, 2, 3))
zGPass either the `num_shapes` or the `signature` argument, but not both.rw   Nr   zjExpected a string, but got invalid signature=None.  (maybe .signature attribute of an element-wise ufunc?)r   c              3   8   #    U  H  n[        U5      v   M     g 7fr2   )r{   rf   rg   s     r/   rh   0mutually_broadcastable_shapes.<locals>.<genexpr>  s     2z!s1vvz   rA   znum_shapes=z must be at least 1rx   rE   rC   rI   rD   rF   r@   rK   z	max_dims=z would exceed the zD-dimensionlimit Hypothesis imposes on array shapes, given signature=c              3   <   >#    U  H  oS :w  d  M
  TU:*  v   M     g7frd   r%   re   s     r/   rh   r     s     H&=a}x1}&=rj   rk   rq   rl   r:   rm   c              3   ,   >#    U  H	  oT:*  v   M     g 7fr2   r%   ro   s     r/   rh   r     s     (X@W1h@Wrp   rr   rs   rt   Fru   r   )r   r   r   rO   
isinstancer   strr   r#   r$   rP   r{   r+   r   r_   r   r   r|   r}   r~   r   )rw   r   rx   rC   rD   rE   rF   arg_msgparsed_signaturesig_dims
all_shapesr   r@   r   r   rg   s        ``         r/   r   r   d  s6   \ XG yG+W53
L1*c****y/9!I  	3	;/=iHT'44T6F6S6ST
2z22)667
A~J<7JKLLuj,/sHj)sHj)Xz*4'Ls3z?H598h;NOsHj)Xz*z)*-;<q@sHj)8.8X.Hx,?!?	}$6xj A/24
 	
 

 Hj2&6u&=HHH
| ,$$.<qnXJP
 	
 	A!!S(X
4R4@PQVRV@W(X%X%X
| ,**4Qtf = z
<
 	
 hDbD)9%HDA8|Q-X-h I /" r.   c                   N   ^  \ rS rSr      SU 4S jjrS rS rSS jrSrU =r	$ )	r   i  c                   > [         TU ]  5         X0l        [        R                  " Xg5      U l        Xl        X l        X@l        XPl	        X`l
        Xpl        U R                  Ss=:*  =(       a    U R                  :*  U l        g s  U l        g )NrA   )super__init__rx   rQ   rS   
side_stratrw   r   rC   rD   rE   rF   size_one_allowed)	selfrw   r   rx   rC   rD   rE   rF   	__class__s	           r/   r   ,MutuallyBroadcastableShapesStrategy.__init__  sh     	$++h9$"     $ C Cdmm C Cr.   c                   ^ U R                   c  U R                  U5      $ U R                  U5      u  p#U Vs/ s H  nS U;  PM
     nnU R                  XS9u  pgS m[        [	        U4S j[        XbSS9 5       5      T" Xs5      S9$ s  snf )N)usec                 :    [        S X-   [        * S   5       5      $ )Nc              3   .   #    U  H  oc  M  Uv   M     g 7fr2   r%   rf   rZ   s     r/   rh   QMutuallyBroadcastableShapesStrategy.do_draw.<locals>.add_shape.<locals>.<genexpr>  s     O$=q$=s   	)r+   r   )loopcores     r/   	add_shape>MutuallyBroadcastableShapesStrategy.do_draw.<locals>.add_shape  s    OT[8)*$=OOOr.   c              3   8   >#    U  H  u  pT" X5      v   M     g 7fr2   r%   )rf   l_incr   s      r/   rh   >MutuallyBroadcastableShapesStrategy.do_draw.<locals>.<genexpr>  s      2Twt	$""2Ts   Tru   r   )r   _draw_loop_dimensions_draw_core_dimensionsr   r+   r}   )	r   datacore_incore_resr   r   loop_inloop_resr   s	           @r/   do_draw+MutuallyBroadcastableShapesStrategy.do_draw  s    >>!--d33 !66t< +22'3t3'2 66t6E	P # 25gt2T  #86	
 	
 3s   Bc                 X   0 n/ n/ U R                   R                  QU R                   R                  P7 H  nUR                  / 5        U H  nUR	                  5       (       a  US   R                  [        U5      5        M7  XR;  ae  UR                  S5      nUR                  U R                  5      X&'   U R                  S:X  a  UR                  S5      (       d  S X&S-   '   O	X&   X&S-   '   US   R                  X%   5        M     M     [        S US S  5       5      [        US   5      4$ )Nrk   r   r   g      ?c              3   8   #    U  H  n[        U5      v   M     g 7fr2   )r+   r   s     r/   rh   LMutuallyBroadcastableShapesStrategy._draw_core_dimensions.<locals>.<genexpr>6  s     3{!U1XX{r   )r   r#   r$   appendisdigitrO   r   drawr   rC   draw_booleanr+   )r   r   r@   shapesra   r;   dims          r/   r   9MutuallyBroadcastableShapesStrategy._draw_core_dimensions"  s    Pt~~22PDNN4O4OPEMM"<<>>2J%%c$i0#**S/C $		$// :DI}})$2C2CE2J2J*.3Y*.)3Yr
!!$*-  Q 3vcr{33U6":5FFFr.   c           	        ^  T R                   S S S2   n[        U5      n[        T R                  5       Vs/ s H  n/ PM     nnUc&  [        T R                  5       Vs/ s H  nSPM     nnO4[	        U5      T R                  :X  d   e[        S U 5       5      (       d   eT R                  T R                  -
  n[        US-  US9n[        ST R                  S-   5       GHa  n	U	S-
  n
[	        U5      U	:  d  X:   S:X  a  UR                  T R                  5      nOX:   T R                  ::  a  X:   nOSn[        SU/5      n[        U5       H  u  pU
[	        U5      ::  a7  T R                  (       a&  UR                  [        R                   " U5      5      nOUnT R                  U	:  a  X-==   UR#                  U5      -  ss'   X-   (       d  M  UR%                  U5        [	        U5      [	        U5      :  a  UR%                  US   5        M  US   S:w  d  M  XJ   S:X  d  M  US   XJ'   M     ['        U5      (       a  GMb    O   US [)        [+        [        T R                   /UQ5      5       n[	        U5      T R                  :X  d   e[        U 4S jU 5       5      (       d   e[        U 4S jU 5       5      (       d   e[-        [/        S	 U 5       5      [/        [1        U5      5      S
9$ s  snf s  snf )Nrk   Tc              3   B   #    U  H  n[        U[        5      v   M     g 7fr2   )r   boolr   s     r/   rh   LMutuallyBroadcastableShapesStrategy._draw_loop_dimensions.<locals>.<genexpr>A  s     8Cqz!T**C   rI   )desired_avgrN   rA   c              3      >#    U  H7  nTR                   [        U5      s=:*  =(       a    TR                  :*  Os  v   M9     g 7fr2   )rC   r{   rD   )rf   rg   r   s     r/   rh   r   v  s-     LV4==CF;;dmm;;V   ?Ac              3      >#    U  H7  o  H.  nTR                   Us=:*  =(       a    TR                  :*  Os  v   M0     M9     g 7fr2   )rE   rF   )rf   rK   rg   r   s      r/   rh   r   w  s4     X64SWa4==A6666SW66r   c              3   J   #    U  H  n[        [        U5      5      v   M     g 7fr2   )r+   reversed)rf   ra   s     r/   rh   r   z  s     J6%uXe_556s   !#r   )rx   listr~   rw   r{   r|   rD   rC   r	   r   r   rF   sorted	enumerater   rQ   sampled_fromr   r   anyr_   rT   r   r+   r   )r   r   r   rx   r$   _r   _gapp_keep_extending_shape	dim_countr   dim_sideallowed_sidesshape_idra   rK   s   `               r/   r   9MutuallyBroadcastableShapesStrategy._draw_loop_dimensions8  s   __TrT*
J'#DOO454"45;!&t!78!7A4!7C8Cs8t...8C88888}}t}},!1dQhQU!Vq$--!"34Ia-C :*jo.B99T__5DMM1%? "Ax=1M#,V#4 #l++0E0E99R__]%CDD#D ==9,MT%6%67M%NNM==LL&<(3u:5$++E"I6raL,=,B,1"I)/ $50 s88W 5Z $$Oc#cDOO3Mf3M*N&OP6{doo---LVLLLLLX6XXXXX"J6JJx56
 	
{ 68s   K.K3)	rx   rD   rF   rC   rE   rw   r   r   r   )Nr%   r   NrA   Nr2   )
r'   r(   r)   r*   r   r   r   r   r-   __classcell__r   s   @r/   r   r     s4     D,
6G,D
 D
r.   r   c                   .   ^  \ rS rSrU 4S jrS rSrU =r$ )r   i  c                 j   > [         TU ]  5         Xl        X l        X0l        X@l        XPl        X`l        g r2   )r   r   ra   rC   rD   allow_ellipsisallow_newaxisallow_fewer_indices_than_dims)r   ra   rC   rD   r   r   r   r   s          r/   r   BasicIndexStrategy.__init__  s4     	
  ,* .K*r.   c                 N   / nU R                    Hw  nUS:X  a  UR                  [        S 5      5        M%  [        R                  " U* US-
  5      [        R
                  " U5      -  nUR                  UR                  U5      5        My     [        S U 5       5      nU R                  (       a  XPR                  :  a  XPR                  :  d)  UR                  [        R                  " 5       5      (       a  UR                  [        R                  " S[        U5      5      5      nUR                  US 5        US-  nU R                  (       aK  XPR                  :  a<  XPR                  :  a  Mw  UR                  [        R                  " 5       5      (       a  M  [        U R                  Us=:*  =(       a    U R                  :*  Os  5        U R                  (       a  UR                  [        R                  " 5       5      (       a  UR                  [        R                  " S[        U5      5      5      =pgUS:  a5  X&S-
     [        S 5      :X  a!  US-  nUS:  a  X&S-
     [        S 5      :X  a  M!  U[        U5      :  a8  X'   [        S 5      :X  a'  US-  nU[        U5      :  a  X'   [        S 5      :X  a  M'  [         /X&U& OU R"                  (       a  USS  [        S S 5      /:X  a|  UR                  [        R                  " SS5      5      (       aQ  UR%                  5         USS  [        S S 5      /:X  a-  UR                  [        R                  " SS5      5      (       a  MQ  [        U5      S:X  a.  UR                  [        R                  " 5       5      (       a  US   $ ['        U5      $ )Nr   rA   c              3   B   #    U  H  n[        U[        5      v   M     g 7fr2   )r   slice)rf   idxs     r/   rh   -BasicIndexStrategy.do_draw.<locals>.<genexpr>  s     CFS*S%00Fr   rk      )ra   r   r   rQ   rS   slicesr   sumr   rD   rC   booleansr{   insertr   r   Ellipsisr   popr+   )r   r   resultdim_sizestrategyresult_dimsijs           r/   r   BasicIndexStrategy.do_draw  s    

H1}eDk*{{H9hl;bii>QQHMM$))H-. # CFCCmm+}},		"++-0H0H		"++aV56AMM!T"1K mm+}},		"++-0H0H 	t}}<<t}}<= 499R[[]#;#;IIbkk!S[9::Aa%Fq5MU4[8Q a%Fq5MU4[8c&k/fi5;&>Q c&k/fi5;&>#*FQK//+%d"3!442;;qRSCT9U9U

 +%d"3!442;;qRSCT9U9Uv;!		"++- 8 8!9V}r.   )r   r   r   rD   rC   ra   )r'   r(   r)   r*   r   r   r-   r   r   s   @r/   r   r     s    K(( (r.   r   )5r   typesr   typingr   
hypothesisr   r   rQ   hypothesis.errorsr   $hypothesis.internal.conjecture.utilsr	   hypothesis.internal.coverager
   hypothesis.internal.validationr   r   %hypothesis.strategies._internal.utilsr   hypothesis.utils.conventionsr   r   __all__r+   rO   r   r   r   r   r   r   r   r   r   r   r   r   SearchStrategyr   r    r   r   r   _ARGUMENT_LISTr   r   r   r   r   r   r   r   r%   r.   r/   <module>r     sU   
   / - A 7 K B B* 	c3h U{TL(ut#el*+ E$)$$
* 
 H H
 U U  
 
  "" Dj" 	"
 Dj" u" "J  	)
) ) Dj	)
 uS#X') )X  ['[' [' Dj	['
 [' Dj[' u[' ['b 
*T*]	;84xr*.!F81-
 !.!1N3C1E  
4Ln  *1(/H 3&H  #%H 	H
 H DjH H DjH *+H HVL
"*;*; L
^=** =r.   