code: def dot(a, b, out=None):
      """
      dot(a, b, out=None)
  
      Dot product of two arrays. Specifically,
  
      - If both `a` and `b` are 1-D arrays, it is inner product of vectors
        (without complex conjugation).
  
      - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
        but using :func:`matmul` or ``a @ b`` is preferred.
  
      - If either `a` or `b` is 0-D (scalar), it is equivalent to
        :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is
        preferred.
  
      - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
        the last axis of `a` and `b`.
  
      - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
        sum product over the last axis of `a` and the second-to-last axis of
        `b`::
  
          dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
  
      It uses an optimized BLAS library when possible (see `numpy.linalg`).
  
      Parameters
      ----------
      a : array_like
          First argument.
      b : array_like
          Second argument.
      out : ndarray, optional
          Output argument. This must have the exact kind that would be returned
          if it was not used. In particular, it must have the right type, must be
          C-contiguous, and its dtype must be the dtype that would be returned
          for `dot(a,b)`. This is a performance feature. Therefore, if these
          conditions are not met, an exception is raised, instead of attempting
          to be flexible.
  
      Returns
      -------
      output : ndarray
          Returns the dot product of `a` and `b`.  If `a` and `b` are both
          scalars or both 1-D arrays then a scalar is returned; otherwise
          an array is returned.
          If `out` is given, then it is returned.
  
      Raises
      ------
      ValueError
          If the last dimension of `a` is not the same size as
          the second-to-last dimension of `b`.
  
      See Also
      --------
      vdot : Complex-conjugating dot product.
      tensordot : Sum products over arbitrary axes.
      einsum : Einstein summation convention.
      matmul : '@' operator as method with out parameter.
      linalg.multi_dot : Chained dot product.
  
      Examples
      --------
      >>> np.dot(3, 4)
      12
  
      Neither argument is complex-conjugated:
  
      >>> np.dot([2j, 3j], [2j, 3j])
      (-13+0j)
  
      For 2-D arrays it is the matrix product:
  
      >>> a = [[1, 0], [0, 1]]
      >>> b = [[4, 1], [2, 2]]
      >>> np.dot(a, b)
      array([[4, 1],
             [2, 2]])
  
      >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
      >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
      >>> np.dot(a, b)[2,3,2,1,2,2]
      499128
      >>> sum(a[2,3,2,:] * b[1,2,:,2])
      499128
  
      """
      return (a, b, out)
  
imports: import functools
  from .None import overrides
  from .None import _multiarray_umath
  from ._multiarray_umath import *
  from ._multiarray_umath import fastCopyAndTranspose, _flagdict, from_dlpack, _place, _reconstruct, _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version, _get_madvise_hugepage, _set_madvise_hugepage, _get_promotion_state, _set_promotion_state, _using_numpy2_behavior
label_desc: Use image node_id 9 for calling a global function with example usage: dot(a, b, out) and returns: a,  b,  out