+
    :i$                     L   R t ^ RIHt ^ RIHt ^ RIHtHtHtH	t	 ^ RI
HtHtHtHtHtHtHtHt R tR tR tR tR	 tR
 tR t]! ]]P6                  ! ]P8                  4      4      R 4       t]! ]P<                  R4      R 4       t]! ]P<                  R4      R 4       t ]! ]P<                  R4      R 4       t!]! R]P<                  ]PD                  4      R 4       t#R t$]! ]P<                  4      R 4       t%]! ]PL                  PN                  ]P<                  4      R 4       t(R# )z2
Implement slices and various slice computations.
)zip_longest)ir)cgutilstypestypingutils)impl_ret_borrowedimpl_ret_new_refimpl_ret_untrackediternext_impllower_builtin
lower_castlower_constantlower_getattrc                    V P                  RV\        P                  ! VP                  ^ 4      4      pV P	                  W4      pV P                  W4V4      # )zR
Fix negative index by adding *size* to it.  Positive
indices are left untouched.
<)icmp_signedr   Constanttypeaddselect)builderidxsizeis_negativewrapped_indexs   &&&  S/var/www/html/photoedit/myenv/lib/python3.14/site-packages/numba/cpython/slicing.py	fix_indexr      sF    
 %%c3DIIq0IJKKK*M>>+c::    c           	     ^  a aaa	 \         P                  ! SP                  ^ 4      o	\         P                  ! SP                  R4      pV VVV	3R lpS P                  \        P
                  ! S SP                  4      4      ;_uu_ 4       w  rVV;_uu_ 4        V! RS	S4       V! RS	S4       RRR4       V;_uu_ 4        TpS P                  SV4      pV! RWx4       V! RWx4       RRR4       RRR4       R#   + '       g   i     LS; i  + '       g   i     L-; i  + '       g   i     R# ; i)z|
Fix *slice* start and stop to be valid (inclusive and exclusive, resp)
indexing bounds for a sequence of the given *size*.
c                   < \        SV 4      p\        SVS4      p\        SW4       SP                  R VS	4      pSP	                  VRR7      ;_uu_ 4        \        SW4       RRR4       SP                  RVS4      pSP	                  VRR7      ;_uu_ 4        \        SW4       RRR4       R#   + '       g   i     LU; i  + '       g   i     R# ; i)r   FlikelyN>=)getattrr   setattrr   if_then)

bound_name
lower_repl
upper_replbound	underflowoverflowr   r   slicezeros
   &&&   r   	fix_boundfix_slice.<locals>.fix_bound"   s    z*'5$/z)''UD9	__Yu_55E:2 6 &&tUD9__Xe_44E:2 54	 65 544s   B/C/B?	C	startstopN)r   r   r   if_elser   
is_neg_intstepr   )
r   r-   r   	minus_oner/   if_neg_stepif_pos_steplowerupperr.   s
   fff      @r   	fix_slicer<      s     ;;tyy!$DDIIr*I3 3 
++GUZZ@	A	AE_k[gtT*fdD)  [EKKi0Egu,fe+  
B	A[ [ 
B	A	As<   DC5	*D<'D	#D5D DDDD,	c           	     N   VP                   pVP                  pVP                  p\        P                  ! VP
                  ^4      p\        P                  ! VP
                  ^ 4      p\        P                  ! W4      pV P                  W24      pV P                  W4      p	V P                  W4      p
V P                  WzV	4      pV P                  WPP                  W4      4      pV P                  VV P                  RW4      V P                  RW4      4      pV P                  WV4      # )a  
Given a slice, compute the number of indices it spans, i.e. the
number of iterations that for_range_slice() will execute.

Pseudo-code:
    assert step != 0
    if step > 0:
        if stop <= start:
            return 0
        else:
            return (stop - start - 1) // step + 1
    else:
        if stop >= start:
            return 0
        else:
            return (stop - start + 1) // step + 1

(see PySlice_GetIndicesEx() in CPython)
r#   z<=)r1   r2   r6   r   r   r   r   r5   subr   r   sdivr   )r   slicestructr1   r2   r6   oner.   is_step_negativedeltapos_dividendneg_dividenddividendnominal_lengthis_zero_lengths   &&            r   get_slice_lengthrI   =   s    ( EDD
++ejj!
$C;;uzz1%D))'8KK$E ;;u*L;;u*L/|LH[[ll8&BCN ^^$4$+$7$7e$J$+$7$7e$JLN
 >>.??r   c                >   VP                   pVP                  pVP                  ^ 4      pVP                  ^4      pV P                  RVP                  V4      pV P                  VV P                  W54      V4      pV P                  VV P                  W%4      V4      pWx3# )z7
Return the [lower, upper) indexing bounds of a slice.
r   )r1   r2   r   r   r6   r   r   )	r   r@   r1   r2   r.   rA   rB   r:   r;   s	   &&       r   get_slice_boundsrK   i   s     ED::a=D
**Q-C **30@0@$GNN+";;t15:ENN+";;u2D:E<r   c                :    V P                  VP                  V4      # )z,
Fix the given stride for the slice's step.
)mulr6   )r   r-   strides   &&&r   
fix_striderO   {   s     ;;uzz6**r   c                ~    VP                   '       d+   \        P                  ! WVP                  \        R34       R# R# )zH
Guard against *slicestruct* having a zero step (and raise ValueError).
slice step cannot be zeroN)has_stepr   
guard_nullr6   
ValueError)contextr   typr@   s   &&&&r   guard_invalid_slicerW      s4     |||7[-=-=&(CD	F r   c                `    ^V P                   ^,
          ,          ^,
          p^ WV) ^,
          ^3# )z
Get the default values for a slice's members:
(start for positive step, start for negative step,
 stop for positive step, stop for negative step, step)
)address_size)rU   maxints   & r   get_defaultsr[      s3     G((1,-2Fvx!|Q//r   c                 `  a \        V 4       Uu. uF"  q@P                  \        P                  V4      NK$  	  upw  ppppp	R .^,          o\	        V4      ^8X  d3   VP
                  ^ ,          \        P                  Jd   V^ ,          S^&   MF\        \        VP
                  V4      4       F#  w  p
w  rV\        P                  Jg   K  VSV
&   K%  	  V3R lpV! ^V	4      pVP                  RVV P                  \        P                  ^ 4      4      pVP                  VW4      pVP                  VWe4      pV! ^V4      pV! ^ V4      pVP                  pV P                  WP                  4      pVVn        VVn        VVn        VP!                  4       p\#        WVP                  V4      # u upi )Nc                 &   < SV ,          pVf   V# V# N )idefaultval
slice_argss   && r   get_arg_value-slice_constructor_impl.<locals>.get_arg_value   s    m;NJr   r   )r[   get_constantr   intplenargsnone	enumeratezipr   r   return_typemake_helperr1   r2   r6   	_getvaluer
   )rU   r   sigri   xdefault_start_posdefault_start_negdefault_stop_posdefault_stop_negdefault_stepr`   tyrb   rd   r6   rB   default_stopdefault_startr2   r1   sliresrc   s   &&&&                  @r   slice_constructor_implr|      s    7C76KL6K		ejj!	,6KL !J 4yA~#((1+UZZ7Q
1%c#((D&9:LAy# #
1 ;
 L)D**3+2+?+?

A+NP>>"2"2FLNN#3#4IML)D!]+E	B


g
7CCICHCH
--/CgEEK 	Ms   (F+r1   c                 >    V P                  WV4      pVP                  # r^   )rn   r1   rU   r   rV   valuerz   s   &&&& r   slice_start_implr      s    


gE
2C99r   r2   c                 >    V P                  WV4      pVP                  # r^   )rn   r2   r~   s   &&&& r   slice_stop_implr      s    


gE
2C88Or   r6   c                     VP                   '       d   V P                  WV4      pVP                  # V P                  \        P
                  ^4      # )   )rR   rn   r6   rf   r   rg   r~   s   &&&& r   slice_step_implr      s=    
|||!!'6xx##EJJ22r   zslice.indicesc                    V^,          pV P                  WP                  ^ ,          V^ ,          4      pVP                  \        P                  ! W4      RR7      ;_uu_ 4        V P
                  P                  V\        R4       RRR4       VP                  \        P                  ! WP                  4      RR7      ;_uu_ 4        V P
                  P                  V\        R4       RRR4       \        WV4       V P                  VVP                  VP                  VP                  VP                  34      #   + '       g   i     L; i  + '       g   i     Lm; i)r   Fr!   N)zlength should not be negative)rQ   )rn   ri   r&   r   r5   	call_convreturn_user_excrT   is_scalar_zeror6   r<   
make_tuplerm   r1   r2   )rU   r   rp   ri   lengthrz   s   &&&&  r   slice_indicesr      s   !WF


gxx{DG
<C	++G<U	K	K))Z.	
 
L
 
//B5	Q	Q))Z*	
 
R gF#	CHHchh'  
L	K
 
R	Qs   #"D:"E:E
	E	c                    V P                  W4      pV P                  \        P                  4      p\	        V 4       Uu. uF"  q`P                  \        P                  V4      NK$  	  upw  ppp	p
pVP                  pVf   RpTpMV^ 8  pV! V4      pVP                  pVf   V'       d   TpMTpMV! V4      pVP                  pVf   V'       d   T
pMT	pMV! V4      pWn        Wn        Wn        VP                  4       # u upi )NF)
rn   get_value_typer   rg   r[   rf   r6   r1   r2   ro   )rU   r   rw   pyvalrz   ltyrq   rr   rs   rt   ru   rv   r6   step_is_negr1   r2   s   &&&&            r   make_slice_from_constantr      s    


g
*C

 
 
,C 7C76KL6K		ejj!	,6KL ::D|Qh4yKKE}%E%EE
::D|#D#D4yIHH==?A 	Ms   (C?c                 x    \        V\        P                  4      '       d   VP                  pMTp\	        WWC4      # r^   )
isinstancer   Literalliteral_typer   )rU   r   rw   r   rV   s   &&&& r   constant_slicer      s.    "emm$$oo#GcAAr   c                 .    \        WW2P                  4      # r^   )r   literal_value)rU   r   fromtytotyrb   s   &&&&&r   cast_from_literalr   *  s    #$ 4 4 r   N))__doc__	itertoolsr   llvmliter   
numba.corer   r   r   r   numba.core.imputilsr   r	   r
   r   r   r   r   r   r   r<   rI   rK   rO   rW   r[   r-   VarArgAnyr|   	SliceTyper   r   r   Integerr   r   r   miscSliceLiteralr   r_   r   r   <module>r      sJ   "  4 40 0 0;!,H)@X$+F0 uell599-.,F /,F^ u( ) u' ( u'3 (3 ? @0*Z  B !B EJJ##U__5 6r   