code: def bincount(x, weights=None, minlength=0, chunk_size_limit=None):
      """
      Count number of occurrences of each value in array of non-negative ints.
  
      The number of bins (of size 1) is one larger than the largest value in
      `x`. If `minlength` is specified, there will be at least this number
      of bins in the output array (though it will be longer if necessary,
      depending on the contents of `x`).
      Each bin gives the number of occurrences of its index value in `x`.
      If `weights` is specified the input array is weighted by it, i.e. if a
      value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
      of ``out[n] += 1``.
  
      Parameters
      ----------
      x : tensor or array_like, 1 dimension, nonnegative ints
          Input array.
      weights : tensor or array_like, optional
          Weights, array of the same shape as `x`.
      minlength : int, optional
          A minimum number of bins for the output array.
  
      Returns
      -------
      out : tensor of ints
          The result of binning the input array.
          The length of `out` is equal to ``np.amax(x)+1``.
  
      Raises
      ------
      ValueError
          If the input is not 1-dimensional, or contains elements with negative
          values, or if `minlength` is negative.
      TypeError
          If the type of the input is float or complex.
  
      See Also
      --------
      histogram, digitize, unique
  
      Examples
      --------
      >>> import mars.tensor as mt
      >>> mt.bincount(mt.arange(5)).execute()
      array([1, 1, 1, 1, 1])
      >>> mt.bincount(mt.tensor([0, 1, 1, 3, 2, 1, 7])).execute()
      array([1, 3, 1, 1, 0, 0, 0, 1])
  
      The input array needs to be of integer dtype, otherwise a
      TypeError is raised:
  
      >>> mt.bincount(mt.arange(5, dtype=float)).execute()
      Traceback (most recent call last):
        ....execute()
      TypeError: Cannot cast array data from dtype('float64') to dtype('int64')
      according to the rule 'safe'
  
      A possible use of ``bincount`` is to perform sums over
      variable-size chunks of an array, using the ``weights`` keyword.
  
      >>> w = mt.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
      >>> x = mt.array([0, 1, 1, 2, 2, 2])
      >>> mt.bincount(x,  weights=w).execute()
      array([ 0.3,  0.7,  1.1])
      """
      x = astensor(x)
      weights = astensor(weights) if weights is not None else None
  
      if not np.issubdtype(x.dtype, np.int_):
          raise TypeError(
              f"Cannot cast array data from {x.dtype} to {np.dtype(np.int_)}"
          )
      if x.ndim != 1:
          raise ValueError("'x' must be 1 dimension")
      if minlength < 0:
          raise ValueError("'minlength' must not be negative")
  
      chunk_size_limit = (
          chunk_size_limit
          if chunk_size_limit is not None
          else options.bincount.chunk_size_limit
      )
      op = TensorBinCount(
          minlength=minlength, chunk_size_limit=chunk_size_limit
      )
      return op(x, weights=weights)
  
imports: import itertools
  import functools
  from typing import Optional
  import numpy
  import pandas
  from ...None import opcodes, options, get_context
  from ...core import recursive_tile, OutputType
  from ...core.operand import OperandStage
  from ...serialization.serializables import Int64Field, ReferenceField
  from ...utils import ceildiv, has_unknown_shape
  from ..datasource import tensor
  from ..operands import TensorOperandMixin, TensorMapReduceOperand
label_desc: Use image node_id 1 for calling a global function with example usage: bincount(x, weights, minlength, chunk_size_limit) and returns: op