
    sh$                     J   S r SSKJr  SSKJr  SSKJrJrJrJ	r	  SSK
JrJrJrJrJrJrJrJr  S rS rS rS	 rS
 rS rS r\" \\R6                  " \R8                  5      5      S 5       r\" \R<                  S5      S 5       r\" \R<                  S5      S 5       r \" \R<                  S5      S 5       r!\" S\R<                  \RD                  5      S 5       r#S r$\" \R<                  5      S 5       r%\" \RL                  RN                  \R<                  5      S 5       r(g)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                     U R                  SU[        R                  " UR                  S5      5      nU R	                  X5      nU R                  X4U5      $ )zR
Fix negative index by adding *size* to it.  Positive
indices are left untouched.
<r   )icmp_signedr   Constanttypeaddselect)builderidxsizeis_negativewrapped_indexs        i/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/numba/cpython/slicing.py	fix_indexr      sF    
 %%c3DIIq0IJKKK*M>>+c::    c                   ^ ^^^	 [         R                  " TR                  S5      m	[         R                  " TR                  S5      nU UUU	4S jnT R                  [        R
                  " T TR                  5      5       u  pVU   U" ST	T5        U" ST	T5        SSS5        U   UnT R                  TU5      nU" SXx5        U" SXx5        SSS5        SSS5        g! , (       d  f       NH= f! , (       d  f       N(= f! , (       d  f       g= f)z|
Fix *slice* start and stop to be valid (inclusive and exclusive, resp)
indexing bounds for a sequence of the given *size*.
r   c                 t  > [        TU 5      n[        TUT5      n[        TX5        TR                  SUT	5      nTR	                  USS9   [        TX5        S S S 5        TR                  SUT5      nTR	                  USS9   [        TX5        S S S 5        g ! , (       d  f       NG= f! , (       d  f       g = f)Nr   Flikely>=)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E:2 6 &&tUD9__Xe_4E:2 54	 65 54s   
BB)
B&)
B7startstopN)r   r   r   if_elser   
is_neg_intstepr   )
r   r/   r   	minus_oner1   if_neg_stepif_pos_steplowerupperr0   s
   ```      @r   	fix_slicer=      s     ;;tyy!$DDIIr*I3 3 
++GUZZ@	AE_kgtT*fdD)  EKKi0Egu,fe+  
B	A[ [ 
B	As<    C>C
C>$'C-C>
C*	&C>-
C;	7C>>
Dc           	      N   UR                   nUR                  nUR                  n[        R                  " UR
                  S5      n[        R                  " UR
                  S5      n[        R                  " X5      nU R                  X25      nU R                  X5      n	U R                  X5      n
U R                  XzU	5      nU R                  XPR                  X5      5      nU R                  UU R                  SX5      U R                  SX5      5      nU R                  XU5      $ )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   r%   z<=)r3   r4   r7   r   r   r   r   r6   subr   r   sdivr   )r   slicestructr3   r4   r7   oner0   is_step_negativedeltapos_dividendneg_dividenddividendnominal_lengthis_zero_lengths                 r   get_slice_lengthrK   =   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                 >   UR                   nUR                  nUR                  S5      nUR                  S5      nU R                  SUR                  U5      nU R                  UU R                  X55      U5      nU R                  UU R                  X%5      U5      nXx4$ )z7
Return the [lower, upper) indexing bounds of a slice.
r   r?   r   )r3   r4   r   r   r7   r   r   )	r   rB   r3   r4   r0   rC   rD   r;   r<   s	            r   get_slice_boundsrM   i   s     ED::a=D
**Q-C **30@0@$GNN+";;t15:ENN+";;u2D:E<r   c                 :    U R                  UR                  U5      $ )z,
Fix the given stride for the slice's step.
)mulr7   )r   r/   strides      r   
fix_striderQ   {   s     ;;uzz6**r   c                 x    UR                   (       a)  [        R                  " XUR                  [        S45        gg)zH
Guard against *slicestruct* having a zero step (and raise ValueError).
slice step cannot be zeroN)has_stepr   
guard_nullr7   
ValueError)contextr   typrB   s       r   guard_invalid_slicerY      s2     ||7[-=-=&(CD	F r   c                 @    SU R                   S-
  -  S-
  nSXU* S-
  S4$ )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)
r?   r   )address_size)rW   maxints     r   get_defaultsr]      s3     G((1,-2Fvx!|Q//r   c                 D  ^ [        U 5       Vs/ s H"  o@R                  [        R                  U5      PM$     snu  nnnnn	S /S-  m[	        U5      S:X  a)  UR
                  S   [        R                  La	  US   TS'   OE[        [        UR
                  U5      5       H"  u  n
u  pU[        R                  Ld  M  UTU
'   M$     U4S jnU" SU	5      nUR                  SUU R                  [        R                  S5      5      nUR                  UX5      nUR                  UXe5      nU" SU5      nU" SU5      nUR                  nU R                  XR                  5      nUUl        UUl        UUl        UR!                  5       n[#        XUR                  U5      $ s  snf )N   r?   r   c                    > TU    nUc  U$ U$ 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_helperr3   r4   r7   	_getvaluer   )rW   r   sigrm   xdefault_start_posdefault_start_negdefault_stop_posdefault_stop_negdefault_steprc   tyre   rg   r7   rD   default_stopdefault_startr4   r3   sliresrf   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r3   c                 >    U R                  XU5      nUR                  $ ra   )rr   r3   rW   r   rX   valuer~   s        r   slice_start_implr      s    


gE
2C99r   r4   c                 >    U R                  XU5      nUR                  $ ra   )rr   r4   r   s        r   slice_stop_implr      s    


gE
2C88Or   r7   c                     UR                   (       a  U R                  XU5      nUR                  $ U R                  [        R
                  S5      $ )Nr?   )rT   rr   r7   rj   r   rk   r   s        r   slice_step_implr      s;    
||!!'6xx##EJJ22r   zslice.indicesc                 t   US   nU R                  XR                  S   US   5      nUR                  [        R                  " X5      SS9   U R
                  R                  U[        S5        S S S 5        UR                  [        R                  " XR                  5      SS9   U R
                  R                  U[        S5        S S S 5        [        XU5        U R                  UUR                  UR                  UR                  UR                  45      $ ! , (       d  f       N= f! , (       d  f       Ni= f)Nr?   r   Fr#   )zlength should not be negative)rS   )rr   rm   r(   r   r6   	call_convreturn_user_excrV   is_scalar_zeror7   r=   
make_tuplerq   r3   r4   )rW   r   rt   rm   lengthr~   s         r   slice_indicesr      s    !WF


gxx{DG
<C	++G<U	K))Z.	
 
L
 
//B5	Q))Z*	
 
R gF#	CHHchh'  
L	K
 
R	Qs   "D$"D)
D&)
D7c                     U R                  X5      nU R                  [        R                  5      n[	        U 5       Vs/ s H"  o`R                  [        R                  U5      PM$     snu  nnn	n
nUR                  nUc  SnUnOUS:  nU" U5      nUR                  nUc  U(       a  UnOUnOU" U5      nUR                  nUc  U(       a  U
nOU	nOU" U5      nXl        Xl        Xl        UR                  5       $ s  snf )NFr   )
rr   get_value_typer   rk   r]   rj   r7   r3   r4   rs   )rW   r   r{   pyvalr~   ltyru   rv   rw   rx   ry   rz   r7   step_is_negr3   r4   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                 v    [        U[        R                  5      (       a  UR                  nOUn[	        XXC5      $ ra   )
isinstancer   Literalliteral_typer   )rW   r   r{   r   rX   s        r   constant_slicer      s.    "emm$$oo#GcAAr   c                 .    [        XX2R                  5      $ ra   )r   literal_value)rW   r   fromtytotyre   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=   rK   rM   rQ   rY   r]   r/   VarArgAnyr   	SliceTyper   r   r   Integerr   r   r   miscSliceLiteralr   rb   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   