code: def modulo(lhs, rhs):
      
      # pylint: disable= no-member, protected-access
      return _ufunc_helper(
          lhs,
          rhs,
          op.broadcast_mod,
          operator.mod,
          _internal._mod_scalar,
          _internal._rmod_scalar)
docs: Returns element-wise modulo of the input arrays with broadcasting.
  
      Equivalent to ``lhs % rhs`` and ``mx.nd.broadcast_mod(lhs, rhs)``.
  
      .. note::
  
         If the corresponding dimensions of two arrays have the same size or one of them has size 1,
         then the arrays are broadcastable to a common shape.
  
      Parameters
      ----------
      lhs : scalar or mxnet.ndarray.array
          First array in modulo.
      rhs : scalar or mxnet.ndarray.array
           Second array in modulo.
          The arrays to be taken modulo. If ``lhs.shape != rhs.shape``, they must be
          broadcastable to a common shape.
  
      Returns
      -------
      NDArray
          The element-wise modulo of the input arrays.
  
      Examples
      --------
      >>> x = mx.nd.ones((2,3))*6
      >>> y = mx.nd.ones((2,1))*4
      >>> x.asnumpy()
      array([[ 6.,  6.,  6.],
             [ 6.,  6.,  6.]], dtype=float32)
      >>> y.asnumpy()
      array([[ 4.],
             [ 4.]], dtype=float32)
      >>> x%5
      <NDArray 2x3 @cpu(0)>
      >>> (x%5).asnumpy()
      array([[ 1.,  1.,  1.],
             [ 1.,  1.,  1.]], dtype=float32)
      >>> (x%y).asnumpy()
      array([[ 2.,  2.,  2.],
             [ 2.,  2.,  2.]], dtype=float32)
      >>> mx.nd.modulo(x,y).asnumpy()
      array([[ 2.,  2.,  2.],
             [ 2.,  2.,  2.]], dtype=float32)