code: def _tile_chunks(cls, op, chunk_size):
      if has_unknown_shape(*op.inputs):
          yield
      out = op.outputs[0]
  
      checks_input = yield from cls._gen_checks_input(op)
  
      map_chunks = []
      cum_sizes = [
          [0] + np.cumsum(ns).tolist() for ns in op.input.nsplits
      ]
      to_vec = op.input.ndim == 2
      for in_chunk in op.input.chunks:
          if to_vec and in_chunk.index[0] > in_chunk.index[1]:
              # if apply squareform to 2-d tensor which is symmetric,
              # we don't need to calculate for lower triangle chunks
              continue
          map_chunk_op = TensorSquareform(
              stage=OperandStage.map,
              checks_input=checks_input,
              reduce_sizes=chunk_size,
              x_shape=op.input.shape,
              start_positions=tuple(
                  cum_sizes[ax][j]
                  for ax, j in enumerate(in_chunk.index)
              ),
              dtype=out.dtype,
              gpu=out.op.gpu,
          )
          chunk_inputs = [in_chunk]
          if checks_input is not None:
              chunk_inputs.append(checks_input)
          map_chunk = map_chunk_op.new_chunk(
              chunk_inputs,
              shape=(2, np.nan),
              index=in_chunk.index,
              order=out.order,
          )
          map_chunks.append(map_chunk)
  
      proxy_chunk = TensorShuffleProxy(dtype=out.dtype).new_chunk(
          map_chunks, shape=()
      )
  
      reduce_chunks = []
      out_shape_iter = itertools.product(*chunk_size)
      out_indices = list(
          itertools.product(*(range(len(cs)) for cs in chunk_size))
      )
      for out_idx, out_shape in zip(out_indices, out_shape_iter):
          reduce_chunk_op = TensorSquareform(
              stage=OperandStage.reduce,
              dtype=out.dtype,
              n_reducers=len(out_indices),
          )
          reduce_chunk = reduce_chunk_op.new_chunk(
              [proxy_chunk],
              shape=out_shape,
              index=out_idx,
              order=out.order,
          )
          reduce_chunks.append(reduce_chunk)
  
      new_op = op.copy()
      return new_op.new_tensors(
          op.inputs,
          shape=out.shape,
          order=out.order,
          nsplits=chunk_size,
          chunks=reduce_chunks,
      )
  
imports: import itertools
  import numpy
  from ....None import opcodes
  from ....core import recursive_tile
  from ....core.operand import OperandStage
  from ....serialization.serializables import FieldTypes, KeyField, BoolField, TupleField
  from ....config import options
  from ....utils import has_unknown_shape, require_module
  from ...core import TensorOrder
  from ...operands import TensorMapReduceOperand, TensorOperandMixin, TensorShuffleProxy
  from ...datasource import ascontiguousarray, array, zeros
  from ...arithmetic import equal
  from ...utils import decide_chunk_sizes
  from ...array_utils import as_same_device, device, cp
label_desc: Use image node_id 13 for calling the TensorSquareform obj's underlying member method code with example usage: obj._tile_chunks(cls, op, chunk_size) and returns: new_op