code: def execute_map(cls, ctx, op):
      # TODO(QIN): add GPU support here
      df = ctx[op.inputs[0].key]
  
      filters = [[], []]
  
      chunk = op.outputs[0]
      if op.index_shuffle_size == -1:
          # no shuffle and no min-max filter on index
          filters[0].append(slice(None, None, None))
      elif op.index_shuffle_size is None:
          # no shuffle on index
          comp_op = operator.ge if op.index_min_close else operator.gt
          index_cond = comp_op(df.index, op.index_min)
          comp_op = operator.le if op.index_max_close else operator.lt
          index_cond = index_cond & comp_op(df.index, op.index_max)
          filters[0].append(index_cond)
      else:
          # shuffle on index
          shuffle_size = op.index_shuffle_size
          filters[0].extend(hash_index(df.index, shuffle_size))
  
      if chunk.ndim == 1:
          if len(filters[0]) == 1:
              # no shuffle
              ctx[chunk.key] = df.loc[filters[0][0]]
          else:
              for index_idx, index_filter in enumerate(filters[0]):
                  ctx[chunk.key, (index_idx,)] = (
                      ctx.get_current_chunk().index,
                      df.loc[index_filter],
                  )
          return
  
      if op.column_shuffle_size == -1:
          # no shuffle and no min-max filter on columns
          filters[1].append(slice(None, None, None))
      if op.column_shuffle_size is None:
          # no shuffle on columns
          comp_op = operator.ge if op.column_min_close else operator.gt
          columns_cond = comp_op(df.columns, op.column_min)
          comp_op = operator.le if op.column_max_close else operator.lt
          columns_cond = columns_cond & comp_op(
              df.columns, op.column_max
          )
          filters[1].append(columns_cond)
      else:
          # shuffle on columns
          shuffle_size = op.column_shuffle_size
          filters[1].extend(hash_index(df.columns, shuffle_size))
  
      if all(len(it) == 1 for it in filters):
          # no shuffle
          ctx[chunk.key] = df.loc[filters[0][0], filters[1][0]]
      elif len(filters[0]) == 1:
          # shuffle on columns
          for column_idx, column_filter in enumerate(filters[1]):
              shuffle_index = (chunk.index[0], column_idx)
              ctx[chunk.key, shuffle_index] = (
                  ctx.get_current_chunk().index,
                  df.loc[filters[0][0], column_filter],
              )
      elif len(filters[1]) == 1:
          # shuffle on index
          for index_idx, index_filter in enumerate(filters[0]):
              shuffle_index = (index_idx, chunk.index[1])
              ctx[chunk.key, shuffle_index] = (
                  ctx.get_current_chunk().index,
                  df.loc[index_filter, filters[1][0]],
              )
      else:
          # full shuffle
          shuffle_index_size = op.index_shuffle_size
          shuffle_column_size = op.column_shuffle_size
          out_idxes = itertools.product(
              range(shuffle_index_size), range(shuffle_column_size)
          )
          out_index_columns = itertools.product(*filters)
          for out_idx, out_index_column in zip(
              out_idxes, out_index_columns
          ):
              index_filter, column_filter = out_index_column
              ctx[chunk.key, out_idx] = (
                  ctx.get_current_chunk().index,
                  df.loc[index_filter, column_filter],
              )
  
imports: import itertools
  import operator
  import numpy
  import pandas
  from ..None import opcodes
  from ..core import OutputType
  from ..core.operand import OperandStage, MapReduceOperand
  from ..serialization.serializables import FieldTypes, AnyField, BoolField, Int32Field, KeyField, ListField
  from .core import SERIES_CHUNK_TYPE
  from .utils import hash_dtypes, filter_dtypes
  from .operands import DataFrameOperandMixin, DataFrameShuffleProxy
  from .utils import parse_index, split_monotonic_index_min_max, build_split_idx_to_origin_idx, filter_index_value, hash_index, is_index_value_identical, validate_axis
label_desc: Use image node_id 7 for calling the DataFrameIndexAlign obj's underlying member method code with example usage: obj.execute_map(cls, ctx, op) without return types