def METHOD_NAME(node: Node, preds: List[Node]) -> List[Any]:
    """
    Construct the lookup table for an Operation.Generic node.
    Args:
        node (Node):
            Operation.Generic to construct the table
        preds (List[Node]):
            ordered predecessors to `node`
    Returns:
        List[Any]:
            lookup table corresponding to `node` and its input value
    """
    variable_input_index = -1
    for index, pred in enumerate(preds):
        if pred.operation != Operation.Constant:
            variable_input_index = index
            break
    assert_that(variable_input_index != -1)
    variable_input_dtype = node.inputs[variable_input_index].dtype
    variable_input_shape = node.inputs[variable_input_index].shape
    assert_that(isinstance(variable_input_dtype, Integer))
    variable_input_dtype = deepcopy(cast(Integer, variable_input_dtype))
    variable_input = preds[variable_input_index]
    if (
        variable_input.operation == Operation.Generic
        and variable_input.properties["name"] == "round_bit_pattern"
    ):
        resulting_bit_width = variable_input.properties["resulting_bit_width"]
        expected_number_of_elements = 2**resulting_bit_width
        overflow_protection = variable_input.properties["overflow_protection"]
        overflow_detected = variable_input.properties["overflow_detected"]
        variable_input_dtype.bit_width = variable_input.properties["original_input_bit_width"]
        if overflow_protection and overflow_detected:
            variable_input_dtype.bit_width += 1
        step = (2**variable_input_dtype.bit_width) // expected_number_of_elements
    else:
        step = 1
    values = chain(
        range(0, variable_input_dtype.max() + 1, step),
        range(variable_input_dtype.min(), 0, step),
    )
    np.seterr(divide="ignore")
    inputs: List[Any] = [pred() if pred.operation == Operation.Constant else None for pred in preds]
    table: List[Optional[Union[np.bool_, np.integer, np.floating, np.ndarray]]] = []
    for value in values:
        try:
            inputs[variable_input_index] = np.ones(variable_input_shape, dtype=np.int64) * value
            table.append(node(*inputs))
        except Exception:  # pylint: disable=broad-except
            # here we try our best to fill the table
            # if it fails, we append None and let flooding algoritm replace None values below
            table.append(None)
    np.seterr(divide="warn")
    flood_replace_none_values(table)
    return table