code: def deserialize_node(node_data, created_layers):
      """Return (args, kwargs) for calling the node layer."""
      if not node_data:
          return [], {}
  
      if isinstance(node_data, list):
          # Legacy case.
          input_tensors = []
          for input_data in node_data:
              inbound_layer_name = input_data[0]
              inbound_node_index = input_data[1]
              inbound_tensor_index = input_data[2]
              if len(input_data) == 3:
                  kwargs = {}
              elif len(input_data) == 4:
                  kwargs = input_data[3]
              else:
                  raise ValueError(
                      "Cannot deserialize the model (invalid config data?)"
                  )
              inbound_layer = created_layers[inbound_layer_name]
  
              # Raise an error if the corresponding layer node
              # has not yet been created
              if (
                  len(inbound_layer._inbound_nodes)
                  <= inbound_node_index
              ):
                  raise IndexError(
                      "Layer node index out of bounds.\n"
                      f"inbound_layer = {inbound_layer}\n"
                      "inbound_layer._inbound_nodes = "
                      f"{inbound_layer._inbound_nodes}\n"
                      f"inbound_node_index = {inbound_node_index}"
                  )
              inbound_node = inbound_layer._inbound_nodes[
                  inbound_node_index
              ]
              input_tensors.append(
                  inbound_node.output_tensors[inbound_tensor_index]
              )
          return [unpack_singleton(input_tensors)], kwargs
  
      args = serialization_lib.deserialize_keras_object(
          node_data["args"]
      )
      kwargs = serialization_lib.deserialize_keras_object(
          node_data["kwargs"]
      )
  
      def convert_revived_tensor(x):
          if isinstance(x, backend.KerasTensor):
              history = x._pre_serialization_keras_history
              if history is None:
                  return x
              layer = created_layers.get(history[0], None)
              if layer is None:
                  raise ValueError(f"Unknown layer: {history[0]}")
              inbound_node_index = history[1]
              inbound_tensor_index = history[2]
              if len(layer._inbound_nodes) <= inbound_node_index:
                  raise ValueError(
                      "Layer node index out of bounds.\n"
                      f"inbound_layer = {layer}\n"
                      f"inbound_layer._inbound_nodes = {layer._inbound_nodes}\n"
                      f"inbound_node_index = {inbound_node_index}"
                  )
              inbound_node = layer._inbound_nodes[inbound_node_index]
              return inbound_node.output_tensors[inbound_tensor_index]
          return x
  
      args = tree.map_structure(convert_revived_tensor, args)
      kwargs = tree.map_structure(convert_revived_tensor, kwargs)
      return args, kwargs
  
imports: import copy
  import inspect
  import warnings
  import tree
  from keras import backend
  from keras import ops
  from keras.backend.common import global_state
  from keras.layers.input_spec import InputSpec
  from keras.layers.layer import Layer
  from keras.legacy.saving import saving_utils
  from keras.legacy.saving import serialization
  from keras.models.model import Model
  from keras.ops.function import Function
  from keras.ops.function import make_node_key
  from keras.saving import serialization_lib
  from keras.utils import tracking
label_desc: Use image node_id 6 for calling a global function with example usage: deserialize_node(node_data, created_layers) and returns: args,  kwargs, list,  dict, list,  kwargs, x, inbound_node, x