code: def format(self, node):
      # Input has shape (n_timesteps, inp_dimensionality)
      # Output / hidden units has shape (1 if !return_sequences else n_timesteps , n_units)
      params = self._default_config_params(node)
      params["n_units"] = node.get_attr("n_out")
      params["n_outputs"] = (
          node.get_attr("n_timesteps")
          if node.get_attr("return_sequences", False)
          else "1"
      )
      params["return_sequences"] = (
          "true"
          if node.get_attr("return_sequences", False)
          else "false"
      )
      params["config_mult_x"] = f"config{node.index}_x_mult"
      params["config_mult_h"] = f"config{node.index}_h_mult"
      params["act_t"] = "{}_config{}".format(
          node.get_attr("activation"), str(node.index) + "_act"
      )
      params["act_recurrent_t"] = "{}_config{}".format(
          node.get_attr("recurrent_activation"),
          str(node.index) + "_rec_act",
      )
      gru_config = self.gru_template.format(**params)
  
      # Activation is on candidate hidden state, dimensionality (1, n_units)
      act_params = self._default_config_params(node)
      act_params["type"] = node.get_attr("activation")
      act_params["n_in"] = node.get_attr("n_out")
      act_params["index"] = str(node.index) + "_act"
      act_config = self.act_template.format(**act_params)
  
      # Recurrent activation is on reset and update gates (therefore x2), dimensionality (1, n_units)
      recr_act_params = self._default_config_params(node)
      recr_act_params["type"] = node.get_attr("recurrent_activation")
      recr_act_params["n_in"] = str(node.get_attr("n_out")) + " * 2"
      recr_act_params["index"] = str(node.index) + "_rec_act"
      recr_act_config = self.recr_act_template.format(**recr_act_params)
  
      # Multiplication config for matrix multiplications of type Wx (reset, update and candidate states)
      mult_params_x = self._default_config_params(node)
      mult_params_x["n_in"] = node.get_attr("n_in")
      mult_params_x["n_out"] = str(node.get_attr("n_out")) + " * 3"
      mult_params_x["product_type"] = get_backend(
          "quartus"
      ).product_type(
          node.get_input_variable().type.precision,
          node.get_weights("weight").type.precision,
      )
      mult_params_x["index"] = str(node.index) + "_x"
      mult_config_x = self.mult_x_template.format(**mult_params_x)
  
      # Multiplication config for matrix multiplications of type Wh (reset, update and candidate states)
      mult_params_h = self._default_config_params(node)
      mult_params_h["n_in"] = node.get_attr("n_out")
      mult_params_h["n_out"] = str(node.get_attr("n_out")) + " * 3"
      mult_params_h["reuse_factor"] = params["recurrent_reuse_factor"]
      mult_params_h["product_type"] = get_backend(
          "quartus"
      ).product_type(
          node.get_input_variable().type.precision,
          node.get_weights("recurrent_weight").type.precision,
      )
      mult_params_h["index"] = str(node.index) + "_h"
      mult_config_h = self.mult_h_template.format(**mult_params_h)
  
      return (
          mult_config_x
          + "\n"
          + mult_config_h
          + "\n"
          + recr_act_config
          + "\n"
          + act_config
          + "\n"
          + gru_config
      )
  
imports: from hls4ml.backends.backend import get_backend
  from hls4ml.backends.template import FunctionCallTemplate, LayerConfigTemplate
  from hls4ml.model.layers import GRU, LSTM, SimpleRNN
label_desc: Use image node_id 2 for calling the GRUConfigTemplate obj's underlying member method code with example usage: obj.format(node) and returns: unknown