code: def recursive_tile(
      tileable: TileableType, *tileables: TileableType
  ) -> Generator[
      List[ChunkType],
      List[ChunkType],
      Union[TileableType, List[TileableType]],
  ]:
      from .tileables import handler
  
      return_list = len(tileables) > 0
      if not return_list and isinstance(tileable, (list, tuple)):
          return_list = True
          raw = tileable
          tileable = raw[0]
          tileables = raw[1:]
  
      to_tile = [tileable] + list(tileables)
      q = [t for t in to_tile if t.is_coarse()]
      while q:
          t = q[-1]
          if t.is_coarse():
              # t may be put into q repeatedly,
              # so we check if it's tiled or not
              cs = [c for c in t.inputs if c.is_coarse()]
              if cs:
                  q.extend(cs)
                  continue
              for obj in handler.tile(t.op.outputs):
                  to_update_inputs = []
                  chunks = []
                  for inp in t.op.inputs:
                      chunks.extend(inp.chunks)
                      if has_unknown_shape(inp):
                          to_update_inputs.append(inp)
                  if obj is None:
                      yield chunks + to_update_inputs
                  else:
                      yield obj + to_update_inputs
          q.pop()
  
      if not return_list:
          return tileable
      else:
          return [tileable] + list(tileables)
  
imports: from typing import List, Union, Generator
  from ...typing import TileableType, ChunkType
  from ...utils import has_unknown_shape, calc_nsplits
label_desc: Use image node_id 3 for calling a global function with example usage: recursive_tile(tileable) and returns: tileable, unknown