
    sh                     l    S SK rS SKJr  S SKJr  S r " S S\5      rS r	S r
S	 rS
 rS rS r/ SQrg)    N)typeof)as_numba_typec                  (    [         R                  " U 6 $ )zProvides an n-dimensional parallel iterator that generates index tuples
for each iteration point. Sequentially, pndindex is identical to np.ndindex.
)npndindexargss    f/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/numba/misc/special.pypndindexr      s     ::t    c                       \ rS rSrSrS rSrg)prange   zProvides a 1D parallel iterator that generates a sequence of integers.
In non-parallel contexts, prange is identical to range.
c                     [        U6 $ N)range)clsr	   s     r
   __new__prange.__new__   s    d|r    N)__name__
__module____qualname____firstlineno____doc__r   __static_attributes__r   r   r
   r   r      s    r   r   c                     SS K n[        X 5      nSR                  U Vs/ s H  nSPM     sn5      U-  nSU < SU< S3n0 n[        X`U0U5        UR	                  US   5      $ s  snf )Nr   ,z"%s"zdef _gdb_func_injection():
	(z)

    _gdb_func_injection)numbagetattrjoinexecnjit)	func_namer	   r!   fn_argstrdefnls           r
   _gdb_python_call_genr,      sl     		"BXXt,t!vt,-4FfD
A2"::a-.// -s   A$c                  &    [        S/U Q76 " 5         g)z
Calling this function will invoke gdb and attach it to the current process
at the call site. Arguments are strings in the gdb command language syntax
which will be executed by gdb once initialisation has occurred.
gdbNr,   r   s    r
   r.   r.   #   s     &&(r   c                  $    [        S5      " 5         g)a   
Calling this function will inject a breakpoint at the call site that is
recognised by both `gdb` and `gdb_init`, this is to allow breaking at
multiple points. gdb will stop in the user defined code just after the frame
employed by the breakpoint returns.
gdb_breakpointNr/   r   r   r
   r1   r1   ,   s     )*,r   c                  &    [        S/U Q76 " 5         g)a  
Calling this function will invoke gdb and attach it to the current process
at the call site, then continue executing the process under gdb's control.
Arguments are strings in the gdb command language syntax which will be
executed by gdb once initialisation has occurred.
gdb_initNr/   r   s    r
   r3   r3   6   s     +d+-r   c                     U $ )a  Forces Numba to interpret *obj* as an Literal value.

*obj* must be either a literal or an argument of the caller function, where
the argument must be bound to a literal. The literal requirement
propagates up the call stack.

This function is intercepted by the compiler to alter the compilation
behavior to wrap the corresponding function parameters as ``Literal``.
It has **no effect** outside of nopython-mode (interpreter, and objectmode).

The current implementation detects literal arguments in two ways:

1. Scans for uses of ``literally`` via a compiler pass.
2. ``literally`` is overloaded to raise ``numba.errors.ForceLiteralArg``
   to signal the dispatcher to treat the corresponding parameter
   differently. This mode is to support indirect use (via a function call).

The execution semantic of this function is equivalent to an identity
function.

See :ghfile:`numba/tests/test_literal_dispatch.py` for examples.
r   )objs    r
   	literallyr6   @   s	    . Jr   c                     U $ r   r   )	containers    r
   literal_unrollr9   Z   s    r   )	r   r   r   r   r.   r1   r3   r6   r9   )numpyr   numba.core.typing.typeofr   numba.core.typing.asnumbatyper   r   objectr   r,   r.   r1   r3   r6   r9   __all__r   r   r
   <module>r?      sD     + 7V 
0)-.4
r   