code: def zeros_like(
      a, dtype=None, order="C", chunks=None, name=None, shape=None
  ):
      """
      Return an array of zeros with the same shape and type as a given array.
  
      Parameters
      ----------
      a : array_like
          The shape and data-type of `a` define these same attributes of
          the returned array.
      dtype : data-type, optional
          Overrides the data type of the result.
      order : {'C', 'F'}, optional
          Whether to store multidimensional data in C- or Fortran-contiguous
          (row- or column-wise) order in memory.
      chunks : sequence of ints
          The number of samples on each block. Note that the last block will have
          fewer samples if ``len(array) % chunks != 0``.
      name : str, optional
          An optional keyname for the array. Defaults to hashing the input
          keyword arguments.
      shape : int or sequence of ints, optional.
          Overrides the shape of the result.
  
      Returns
      -------
      out : ndarray
          Array of zeros with the same shape and type as `a`.
  
      See Also
      --------
      ones_like : Return an array of ones with shape and type of input.
      empty_like : Return an empty array with shape and type of input.
      zeros : Return a new array setting values to zero.
      ones : Return a new array setting values to one.
      empty : Return a new uninitialized array.
      """
  
      a = asarray(a, name=False)
      shape, chunks = _get_like_function_shapes_chunks(a, chunks, shape)
  
      # if shape is nan we cannot rely on regular zeros function, we use
      # generic map_blocks.
      if np.isnan(shape).any():
          return a.map_blocks(
              partial(np.zeros_like, dtype=(dtype or a.dtype))
          )
  
      return zeros(
          shape,
          dtype=(dtype or a.dtype),
          order=order,
          chunks=chunks,
          name=name,
          meta=a._meta,
      )
  
imports: from __future__ import annotations
  import itertools
  from collections.abc import Sequence
  from functools import partial
  from itertools import product
  from numbers import Integral, Number
  import numpy
  from tlz import sliding_window
  from dask.array import chunk
  from dask.array.backends import array_creation_dispatch
  from dask.array.core import Array, asarray, block, blockwise, broadcast_arrays, broadcast_to, concatenate, normalize_chunks, stack
  from dask.array.numpy_compat import AxisError
  from dask.array.ufunc import greater_equal, rint
  from dask.array.utils import meta_from_array
  from dask.array.wrap import empty, full, ones, zeros
  from dask.base import tokenize
  from dask.highlevelgraph import HighLevelGraph
  from dask.utils import cached_cumsum, derived_from, is_cupy_type
label_desc: Use image node_id 4 for calling a global function with example usage: zeros_like(a, dtype, order, chunks, name, shape) and returns: zeros, a