code: def nonzero(a):
      """
      Return the indices of the elements that are non-zero.
  
      Returns a tuple of tensors, one for each dimension of `a`,
      containing the indices of the non-zero elements in that
      dimension. The values in `a` are always tested and returned.
      The corresponding non-zero
      values can be obtained with::
  
          a[nonzero(a)]
  
      To group the indices by element, rather than dimension, use::
  
          transpose(nonzero(a))
  
      The result of this is always a 2-D array, with a row for
      each non-zero element.
  
      Parameters
      ----------
      a : array_like
          Input tensor.
  
      Returns
      -------
      tuple_of_arrays : tuple
          Indices of elements that are non-zero.
  
      See Also
      --------
      flatnonzero :
          Return indices that are non-zero in the flattened version of the input
          tensor.
      Tensor.nonzero :
          Equivalent tensor method.
      count_nonzero :
          Counts the number of non-zero elements in the input tensor.
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> x = mt.array([[1,0,0], [0,2,0], [1,1,0]])
      >>> x.execute()
      array([[1, 0, 0],
             [0, 2, 0],
             [1, 1, 0]])
      >>> mt.nonzero(x).execute()
      (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
  
      >>> x[mt.nonzero(x)].execute()  # TODO(jisheng): accomplish this after fancy indexing is supported
  
      >>> mt.transpose(mt.nonzero(x)).execute() # TODO(jisheng): accomplish this later
  
      A common use for ``nonzero`` is to find the indices of an array, where
      a condition is True.  Given an array `a`, the condition `a` > 3 is a
      boolean array and since False is interpreted as 0, np.nonzero(a > 3)
      yields the indices of the `a` where the condition is true.
  
      >>> a = mt.array([[1,2,3],[4,5,6],[7,8,9]])
      >>> (a > 3).execute()
      array([[False, False, False],
             [ True,  True,  True],
             [ True,  True,  True]])
      >>> mt.nonzero(a > 3).execute()
      (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
  
      The ``nonzero`` method of the boolean array can also be called.
  
      >>> (a > 3).nonzero().execute()
      (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
  
      """
      a = astensor(a)
      op = TensorNonzero(dtype=np.dtype(np.intp))
      return op(a)
  
file_path: mars/mars/tensor/indexing/nonzero.py
imports: import numpy
  from ...None import opcodes
  from ...core import ExecutableTuple, recursive_tile
  from ...serialization.serializables import KeyField
  from ..operands import TensorHasInput, TensorOperandMixin
  from ..datasource import tensor
  from ..core import TensorOrder
  from .unravel_index import unravel_index
label_desc: Use image node_id 1 for calling a global function with example usage: nonzero(a) and returns: op