code: def _tile(cls, op: "TensorIndexSetValue"):
      from ..base import broadcast_to
      from .getitem import _getitem_nocheck
  
      tensor = op.outputs[0]
      value = op.value
      indexed = yield from recursive_tile(
          _getitem_nocheck(
              op.input, op.indexes, convert_bool_to_fancy=False
          )
      )
      is_value_tensor = isinstance(value, TENSOR_TYPE)
  
      if is_value_tensor and value.ndim > 0:
          if has_unknown_shape(indexed, value):
              exec_chunks = indexed.chunks + op.input.chunks
              for c in indexed.chunks:
                  exec_chunks.extend(c.inputs)
              yield exec_chunks + [indexed]
  
          nsplits = indexed.nsplits
          value = yield from recursive_tile(
              broadcast_to(value, indexed.shape)
              .astype(op.input.dtype, copy=False)
              .rechunk(nsplits)
          )
  
      chunk_mapping = {c.op.input.index: c for c in indexed.chunks}
      out_chunks = []
      for chunk in indexed.op.input.chunks:
          index_chunk = chunk_mapping.get(chunk.index)
          if index_chunk is None:
              out_chunks.append(chunk)
              continue
  
          if is_value_tensor:
              if value.ndim > 0:
                  value_chunk = value.cix[index_chunk.index]
              else:
                  value_chunk = value.chunks[0]
          else:
              # non tensor
              value_chunk = value
          chunk_op = TensorIndexSetValue(
              dtype=op.dtype,
              sparse=op.sparse,
              indexes=tuple(index_chunk.op.indexes),
              value=value_chunk,
          )
          chunk_inputs = filter_inputs(
              [chunk] + index_chunk.op.indexes + [value_chunk]
          )
          out_chunk = chunk_op.new_chunk(
              chunk_inputs,
              shape=chunk.shape,
              index=chunk.index,
              order=tensor.order,
          )
          out_chunks.append(out_chunk)
  
      new_op = op.copy()
      return new_op.new_tensors(
          op.inputs,
          tensor.shape,
          order=tensor.order,
          chunks=out_chunks,
          nsplits=op.input.nsplits,
      )
  
imports: import functools
  import itertools
  import operator
  from numbers import Integral
  from typing import Union
  import numpy
  from ...None import opcodes
  from ...core import ENTITY_TYPE, recursive_tile
  from ...core.context import Context
  from ...core.operand import OperandStage
  from ...serialization.serializables import KeyField, TupleField, AnyField, BoolField
  from ...tensor import tensor
  from ...utils import has_unknown_shape
  from ..base import broadcast_to
  from ..core import TENSOR_TYPE, TensorOrder
  from ..operands import TensorMapReduceOperand, TensorOperandMixin, TensorShuffleProxy
  from ..utils import broadcast_shape, filter_inputs
  from .core import process_index
label_desc: Use image node_id 7 for calling the TensorIndexSetValue obj's underlying member method code with example usage: obj._tile(cls, op) and returns: new_op