code: def _tile_entity_values(cls, op):
      from ...core.context import get_context
      from ...tensor.base.unique import TensorUnique
      from ..utils import auto_merge_chunks
      from ..arithmetic.bitwise_or import tree_dataframe_or
  
      in_elements = op.input
      out_elements = op.outputs[0]
      # values contains mars objects
      chunks_list = []
      in_chunks = in_elements.chunks
      if any(len(t.chunks) > 4 for t in op.inputs):
          # yield and merge value chunks to reduce graph nodes
          yield_chunks = [c for c in in_chunks]
          unique_values = []
          for value in op.inputs[1:]:
              if len(value.chunks) >= len(in_chunks) * 2:
                  # when value chunks is much more than in_chunks,
                  # we call drop_duplicates to reduce the amount of data.
                  if isinstance(value, TENSOR_TYPE):
                      chunks = [
                          TensorUnique(
                              return_index=False,
                              return_inverse=False,
                              return_counts=False,
                          ).new_chunk(
                              [c],
                              index=c.index,
                              shape=(np.nan,),
                              dtype=c.dtype,
                          )
                          for c in value.chunks
                      ]
                      unique_values.append(
                          TensorUnique(
                              return_index=False,
                              return_inverse=False,
                              return_counts=False,
                          ).new_tensor(
                              [value],
                              chunks=chunks,
                              nsplits=((np.nan,) * len(chunks),),
                              shape=(np.nan,),
                              dtype=value.dtype,
                          )
                      )
                      yield_chunks += chunks
                  else:
                      # is series
                      chunks = [
                          DataFrameDropDuplicates(
                              keep="first",
                              ignore_index=False,
                              method="tree",
                              output_types=[OutputType.series],
                          ).new_chunk(
                              [c],
                              index=c.index,
                              index_value=c.index_value,
                              name=c.name,
                              dtype=c.dtype,
                              shape=(np.nan,),
                          )
                          for c in value.chunks
                      ]
                      unique_values.append(
                          DataFrameDropDuplicates(
                              keep="first",
                              ignore_index=False,
                              method="tree",
                              output_types=[OutputType.series],
                          ).new_series(
                              [value],
                              chunks=chunks,
                              nsplits=((np.nan,) * len(chunks),),
                              index_value=value.index_value,
                              dtype=value.dtype,
                              shape=(np.nan,),
                          )
                      )
                      yield_chunks += chunks
              else:
                  yield_chunks += value.chunks
                  unique_values.append(value)
          yield yield_chunks
          in_elements = auto_merge_chunks(get_context(), op.input)
          in_chunks = in_elements.chunks
          for value in unique_values:
              if isinstance(value, SERIES_TYPE):
                  merged = auto_merge_chunks(get_context(), value)
                  chunks_list.append(merged.chunks)
              elif isinstance(value, ENTITY_TYPE):
                  chunks_list.append(value.chunks)
      else:
          for value in op.inputs[1:]:
              if isinstance(value, ENTITY_TYPE):
                  chunks_list.append(value.chunks)
  
      out_chunks = []
      for in_chunk in in_chunks:
          isin_chunks = []
          for value_chunks in itertools.product(*chunks_list):
              input_chunks = [in_chunk] + list(value_chunks)
              isin_chunks.append(
                  cls._new_chunk(op, in_chunk, input_chunks)
              )
          out_chunk = tree_dataframe_or(
              *isin_chunks, index=in_chunk.index
          )
          out_chunks.append(out_chunk)
  
      new_op = op.copy()
      params = out_elements.params
      params["nsplits"] = in_elements.nsplits
      params["chunks"] = out_chunks
      return new_op.new_tileables(op.inputs, kws=[params])
  
imports: import itertools
  import numpy
  import pandas
  from pandas.api.types import is_list_like
  from ...None import opcodes
  from ...core import ENTITY_TYPE
  from ...serialization.serializables import KeyField, AnyField
  from ...tensor.core import TENSOR_TYPE
  from ..core import DATAFRAME_TYPE, SERIES_TYPE, INDEX_TYPE, OutputType
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from .drop_duplicates import DataFrameDropDuplicates
label_desc: Use image node_id 3 for calling the DataFrameIsin obj's underlying member method code with example usage: obj._tile_entity_values(cls, op) and returns: new_op