code: def strided_slice(
      data, begin, end, strides=None, axes=None, slice_mode="end"
  ):
      """Strided slice of an array.
  
      Parameters
      ----------
      data : relay.Expr
          The source array to be sliced.
  
      begin : relay.Expr, Tuple[int], or List[int]
          The indices to begin with in the slicing.
  
      end : relay.Expr, Tuple[int], or List[int]
          Indices indicating end of the slice.
  
      strides : relay.Expr, Tuple[int], or List[int], optional
          Specifies the stride values. It can be negative. In that case,
          the input tensor will be reversed in that particular axis.
  
      axes : Tuple[int] or List[int], optional
          Axes along which slicing is applied. When it is specified, the length of begin, end,
          strides, and axes must be equal. Moreover, begin, end, strides, and axes must be
          static (cannot be relay.Expr). Axes argument for dynamic parameter slicing is
          not supported yet.
  
      slice_mode : str, optional
          The slice mode [end, size].
          end: The ending indices for the slice [default].
          size: The input strides will be ignored. Input end in this mode indicates
          the size of a slice starting at the location specified by begin. If end[i]
          is -1, all remaining elements in that dimension are included in the slice.
  
      Returns
      -------
      ret : relay.Expr
          The computed result.
      """
      strides = strides or [1]
      if isinstance(begin, Constant):
          begin = list(begin.data.numpy())
      if isinstance(end, Constant):
          end = list(end.data.numpy())
      if isinstance(strides, Constant):
          strides = list(strides.data.numpy())
      if (
          isinstance(begin, Expr)
          or isinstance(end, Expr)
          or isinstance(strides, Expr)
      ):
          if isinstance(begin, (tuple, list)):
              begin = const(list(begin))
          if isinstance(end, (tuple, list)):
              end = const(list(end))
          if isinstance(strides, (tuple, list)):
              strides = const(list(strides))
  
          ishape = cast_like(shape_of(data), begin)
          ishape_slice = slice_like(ishape, begin)
          begin = _make.where(
              begin < cast_like(const(0), begin),
              begin + ishape_slice,
              begin,
          )
          begin = _make.where(
              begin >= ishape_slice, ishape_slice, begin
          )
          # TODO(masahi): Support axes argument in dynamic strided slice
          assert (
              axes is None
          ), "Axes argument for dynamic parameter slicing is not supported yet."
          return _dyn_make.strided_slice(
              data, begin, end, strides, slice_mode
          )
      return _make.strided_slice(
          data, begin, end, strides, slice_mode, axes
      )
  
imports: from ...tir import expr
  from ..expr import Constant, Expr, Tuple, TupleWrapper, const
  from .None import _make
  from .dyn import _make
  from .tensor import shape_of
label_desc: Use image node_id 28 for calling a global function with example usage: strided_slice(data, begin, end, strides, axes, slice_mode) and returns: _make, _dyn_make