code: def tile(cls, op):
      inp = op.input
      out = op.outputs[0]
      is_window_int = op.win_type != "freq"
      axis = op.axis
      input_ndim = inp.ndim
      output_ndim = out.ndim
  
      # check if can be tiled
      inp = yield from cls._check_can_be_tiled(op, is_window_int)
  
      if inp.ndim == 1 and out.ndim == 1:
          # input series, output series
          other_iter = [None]
      elif inp.ndim == 1:
          # input series, output dataframe
          other_iter = [0]
      else:
          other_iter = range(inp.chunk_shape[1 - axis])
  
      out_chunks = []
      for i in other_iter:
          for j in range(inp.chunk_shape[axis]):
              chunk_op = op.copy().reset_key()
  
              if inp.ndim == 1:
                  chunk_index = (j,)
              else:
                  chunk_index = [None, None]
                  chunk_index[1 - axis] = i
                  chunk_index[axis] = j
                  chunk_index = tuple(chunk_index)
  
              inp_chunk = inp.cix[chunk_index]
              if is_window_int:
                  (
                      pred_chunks,
                      succ_chunks,
                  ) = cls._find_extra_chunks_for_int_window(
                      op, inp, chunk_index
                  )
              else:
                  (
                      pred_chunks,
                      succ_chunks,
                  ) = cls._find_extra_chunks_for_offset_window(
                      op, inp, chunk_index
                  )
  
              out_chunk_index = [None] * output_ndim
              out_chunk_index[axis] = j
              if output_ndim == 2:
                  out_chunk_index[1 - axis] = i
              out_chunk_index = tuple(out_chunk_index)
  
              chunk_params = {"index": out_chunk_index}
              if input_ndim == 1 and output_ndim == 1:
                  chunk_params["shape"] = inp_chunk.shape
                  chunk_params["dtype"] = out.dtype
                  chunk_params["index_value"] = inp_chunk.index_value
                  chunk_params["name"] = inp_chunk.name
              elif input_ndim == 1 and output_ndim == 2:
                  chunk_params["shape"] = (
                      inp_chunk.shape[0],
                      out.shape[1],
                  )
                  chunk_params["dtypes"] = out.dtypes
                  chunk_params["index_value"] = inp_chunk.index_value
                  chunk_params["columns_value"] = out.columns_value
              else:
                  if axis == 0:
                      out_shape = list(out.shape)
                      out_shape[axis] = inp_chunk.shape[axis]
                      chunk_params["shape"] = tuple(out_shape)
                  else:
                      chunk_params["shape"] = inp_chunk.shape
                  chunk_params["index_value"] = (
                      inp_chunk.index_value
                      if axis == 0
                      else out.index_value
                  )
                  chunk_params["dtypes"] = (
                      out.dtypes if axis == 0 else inp_chunk.dtypes
                  )
                  chunk_params["columns_value"] = (
                      out.columns_value
                      if axis == 0
                      else inp_chunk.columns_value
                  )
  
              if len(pred_chunks) > 0:
                  chunk_op._preds = pred_chunks
              if len(succ_chunks) > 0:
                  chunk_op._succs = succ_chunks
              out_chunk = chunk_op.new_chunk(
                  [inp_chunk] + pred_chunks + succ_chunks,
                  kws=[chunk_params],
              )
              out_chunks.append(out_chunk)
  
      params = out.params
      params["chunks"] = out_chunks
      if out.ndim == 1:
          params["shape"] = (inp.shape[0],)
      else:
          params["shape"] = (inp.shape[0], params["shape"][1])
      params["nsplits"] = calc_nsplits(
          {c.index: c.shape for c in out_chunks}
      )
      new_op = op.copy()
      return new_op.new_tileables([inp], kws=[params])
  
imports: import numpy
  import pandas
  from ....None import opcodes
  from ....core import recursive_tile
  from ....serialization.serializables import FieldTypes, AnyField, Int64Field, BoolField, StringField, Int32Field, KeyField, TupleField, DictField, ListField
  from ....utils import lazy_import, has_unknown_shape, pd_release_version, calc_nsplits
  from ...operands import DataFrameOperand, DataFrameOperandMixin
  from ...core import DATAFRAME_TYPE
  from ...utils import build_empty_df, build_empty_series, parse_index
label_desc: Use image node_id 20 for calling the DataFrameRollingAgg obj's underlying member method code with example usage: obj.tile(cls, op) and returns: new_op