code: def integer_array_indices(
      shape: Shape,
      *,
      result_shape: st.SearchStrategy[Shape] = array_shapes(),
      dtype: D = np.dtype(int),
  ) -> "st.SearchStrategy[Tuple[NDArray[D], ...]]":
      """Return a search strategy for tuples of integer-arrays that, when used
      to index into an array of shape ``shape``, given an array whose shape
      was drawn from ``result_shape``.
  
      Examples from this strategy shrink towards the tuple of index-arrays::
  
          len(shape) * (np.zeros(drawn_result_shape, dtype), )
  
      * ``shape`` a tuple of integers that indicates the shape of the array,
        whose indices are being generated.
      * ``result_shape`` a strategy for generating tuples of integers, which
        describe the shape of the resulting index arrays. The default is
        :func:`~hypothesis.extra.numpy.array_shapes`.  The shape drawn from
        this strategy determines the shape of the array that will be produced
        when the corresponding example from ``integer_array_indices`` is used
        as an index.
      * ``dtype`` the integer data type of the generated index-arrays. Negative
        integer indices can be generated if a signed integer type is specified.
  
      Recall that an array can be indexed using a tuple of integer-arrays to
      access its members in an arbitrary order, producing an array with an
      arbitrary shape. For example:
  
      .. code-block:: pycon
  
          >>> from numpy import array
          >>> x = array([-0, -1, -2, -3, -4])
          >>> ind = (array([[4, 0], [0, 1]]),)  # a tuple containing a 2D integer-array
          >>> x[ind]  # the resulting array is commensurate with the indexing array(s)
          array([[-4,  0],
                 [0, -1]])
  
      Note that this strategy does not accommodate all variations of so-called
      'advanced indexing', as prescribed by NumPy's nomenclature.  Combinations
      of basic and advanced indexes are too complex to usefully define in a
      standard strategy; we leave application-specific strategies to the user.
      Advanced-boolean indexing can be defined as ``arrays(shape=..., dtype=bool)``,
      and is similarly left to the user.
      """
      check_type(tuple, shape, "shape")
      check_argument(
          shape and all(isinstance(x, int) and x > 0 for x in shape),
          f"{shape=} must be a non-empty tuple of integers > 0",
      )
      check_strategy(result_shape, "result_shape")
      check_argument(
          np.issubdtype(dtype, np.integer),
          f"{dtype=} must be an integer dtype",
      )
      signed = np.issubdtype(dtype, np.signedinteger)
  
      def array_for(index_shape, size):
          return arrays(
              dtype=dtype,
              shape=index_shape,
              elements=st.integers(-size if signed else 0, size - 1),
          )
  
      return result_shape.flatmap(
          lambda index_shape: st.tuples(
              *(array_for(index_shape, size) for size in shape)
          )
      )
  
imports: import importlib
  import math
  from typing import TYPE_CHECKING, Any, Literal, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union
  import numpy
  from hypothesis import strategies
  from hypothesis._settings import note_deprecation
  from hypothesis.errors import HypothesisException, InvalidArgument
  from hypothesis.extra._array_helpers import NDIM_MAX, BasicIndex, BasicIndexStrategy, BroadcastableShapes, Shape, array_shapes, broadcastable_shapes, check_argument, check_valid_dims, mutually_broadcastable_shapes, order_check, valid_tuple_axes
  from hypothesis.internal.conjecture import utils
  from hypothesis.internal.coverage import check_function
  from hypothesis.internal.reflection import proxies
  from hypothesis.internal.validation import check_type
  from hypothesis.strategies._internal.numbers import Real
  from hypothesis.strategies._internal.strategies import Ex, T, check_strategy
  from hypothesis.strategies._internal.utils import defines_strategy
label_desc: Use image node_id 24 for calling a global function with example usage: integer_array_indices(shape) and returns: result_shape, arrays