code: def tile(cls, op):
      from .extmath import _safe_accumulator_op
  
      x = op.x
      out = op.outputs[0]
      is_float = x.dtype.kind in "fc"
      combine_size = options.combine_size
  
      is_finite_chunk = check_nan_chunk = None
      if is_float:
          is_finite_chunk = (
              yield from recursive_tile(
                  mt.isfinite(_safe_accumulator_op(mt.sum, x))
              )
          ).chunks[0]
      elif x.dtype == np.dtype(object) and not op.allow_nan:
          check_nan_chunk = (
              yield from recursive_tile((x != x).any())
          ).chunks[0]
  
      map_chunks = []
      for c in x.chunks:
          chunk_op = op.copy().reset_key()
          chunk_op.stage = OperandStage.map
          chunk_op._is_finite = is_finite_chunk
          chunk_op._check_nan = check_nan_chunk
          chunk_inputs = [c]
          if is_finite_chunk is not None:
              chunk_inputs.append(is_finite_chunk)
          if check_nan_chunk is not None:
              chunk_inputs.append(check_nan_chunk)
          chunk_params = c.params
          if op.check_only:
              chunk_params["dtype"] = np.dtype(bool)
              chunk_params["shape"] = ()
              if len(x.chunks) == 1:
                  chunk_params["index"] = ()
          map_chunk = chunk_op.new_chunk(
              chunk_inputs, kws=[chunk_params]
          )
          map_chunks.append(map_chunk)
  
      new_op = op.copy()
      if not op.check_only:
          params = out.params
          params["nsplits"] = x.nsplits
          params["chunks"] = map_chunks
          return new_op.new_tileables(op.inputs, kws=[params])
  
      out_chunks = map_chunks
      # if check only, we use tree reduction to aggregate to one chunk
      while len(out_chunks) > 1:
          size = ceildiv(len(out_chunks), combine_size)
          new_out_chunks = []
          for i in range(size):
              chunk_op = AssertAllFinite(
                  check_only=True,
                  output_types=op.output_types,
                  stage=OperandStage.combine
                  if size > 1
                  else OperandStage.agg,
              )
              chunk_index = (i,) if size > 1 else ()
              out_chunk = chunk_op.new_chunk(
                  out_chunks[combine_size * i : combine_size * (i + 1)],
                  dtype=out.dtype,
                  shape=(),
                  index=chunk_index,
                  order=out.order,
              )
              new_out_chunks.append(out_chunk)
          out_chunks = new_out_chunks
  
      params = out.params
      params["nsplits"] = ()
      params["chunks"] = out_chunks
      return new_op.new_tileables(op.inputs, kws=[params])
  
imports: import numpy
  from ...None import opcodes
  from ...None import tensor
  from ...core import ENTITY_TYPE, get_output_types, recursive_tile
  from ...core.operand import OperandStage
  from ...config import options
  from ...serialization.serializables import KeyField, StringField, BoolField, DataTypeField
  from ...tensor.core import TensorOrder, TENSOR_CHUNK_TYPE
  from ...tensor.array_utils import as_same_device, device, issparse, get_array_module
  from ...utils import ceildiv
  from ..operands import LearnOperand, LearnOperandMixin, OutputType
label_desc: Use image node_id 11 for calling the AssertAllFinite obj's underlying member method code with example usage: obj.tile(cls, op) and returns: new_op, new_op