code: def searchsorted(a, v, side="left", sorter=None, combine_size=None):
      """
      Find indices where elements should be inserted to maintain order.
  
      Find the indices into a sorted tensor `a` such that, if the
      corresponding elements in `v` were inserted before the indices, the
      order of `a` would be preserved.
  
      Assuming that `a` is sorted:
  
      ======  ============================
      `side`  returned index `i` satisfies
      ======  ============================
      left    ``a[i-1] < v <= a[i]``
      right   ``a[i-1] <= v < a[i]``
      ======  ============================
  
      Parameters
      ----------
      a : 1-D array_like
          Input tensor. If `sorter` is None, then it must be sorted in
          ascending order, otherwise `sorter` must be an array of indices
          that sort it.
      v : array_like
          Values to insert into `a`.
      side : {'left', 'right'}, optional
          If 'left', the index of the first suitable location found is given.
          If 'right', return the last such index.  If there is no suitable
          index, return either 0 or N (where N is the length of `a`).
      sorter : 1-D array_like, optional
          Optional tensor of integer indices that sort array a into ascending
          order. They are typically the result of argsort.
      combine_size: int, optional
          The number of chunks to combine.
  
      Returns
      -------
      indices : tensor of ints
          Array of insertion points with the same shape as `v`.
  
      See Also
      --------
      sort : Return a sorted copy of a tensor.
      histogram : Produce histogram from 1-D data.
  
      Notes
      -----
      Binary search is used to find the required insertion points.
  
      This function is a faster version of the builtin python `bisect.bisect_left`
      (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
      which is also vectorized in the `v` argument.
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> mt.searchsorted([1,2,3,4,5], 3).execute()
      2
      >>> mt.searchsorted([1,2,3,4,5], 3, side='right').execute()
      3
      >>> mt.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]).execute()
      array([0, 5, 1, 2])
  
      """
  
      if (
          not isinstance(a, TENSOR_TYPE)
          and sorter is not None
          and not isinstance(sorter, TENSOR_TYPE)
      ):
          a = astensor(np.asarray(a)[sorter])
      else:
          a = astensor(a)
          if sorter is not None:
              a = a[sorter]
  
      if a.ndim != 1:
          raise ValueError("`a` should be 1-d tensor")
      if a.issparse():
          # does not support sparse tensor
          raise ValueError("`a` should be a dense tensor")
      if side not in {"left", "right"}:
          raise ValueError(
              f"'{side}' is an invalid value for keyword 'side'"
          )
  
      if not np.isscalar(v):
          v = astensor(v)
  
      op = TensorSearchsorted(
          v=v,
          side=side,
          dtype=np.dtype(np.intp),
          combine_size=combine_size,
      )
      return op(a, v)
  
imports: import itertools
  from typing import Any, List, Tuple, Type
  import numpy
  from ...None import opcodes
  from ...core import TILEABLE_TYPE
  from ...core.operand import OperandStage
  from ...serialization.serializables import StringField, AnyField, Int64Field, Int32Field
  from ...typing import TileableType, ChunkType
  from ...config import options
  from ...utils import has_unknown_shape
  from ..operands import TensorOperand, TensorOperandMixin
  from ..core import TENSOR_TYPE, TensorOrder
  from ..datasource.array import tensor
  from ..array_utils import as_same_device, device
label_desc: Use image node_id 1 for calling a global function with example usage: searchsorted(a, v, side, sorter, combine_size) and returns: op