code: def format(self, node):
      params = self._default_config_params(node)
  
      params["n_vertices"] = node.attributes["n_vertices"]
      params["n_vertices_width"] = int(np.log2(params["n_vertices"]))
      params["distance_width"] = 12
      params["distance_nint"] = min(
          4, params["distance_width"] - 6
      )  # this is tuned
      params["log2_reuse"] = int(np.log2(params["reuse"]))
  
      # Define default precisions for various internal arrays (can be overridden from the config file)
      # We always give 10 digits for the subintegral part
      fwidth = 10
      # Integral precision for aggr_t depends on how large the temporary sum for weighed feature mean will be
      aggr_intw = (
          max(
              params["log2_reuse"],
              params["n_vertices_width"] - params["log2_reuse"],
          )
          + 3
      )  # safety factor 2**3
      aggr_w = aggr_intw + fwidth
      # edge_weight_aggr_t does not need the safety factor
      ew_aggr_intw = aggr_intw - 3
      ew_aggr_w = ew_aggr_intw + fwidth
      # Integral precision for norm is fixed to 4
      norm_intw = 4
      norm_w = norm_intw + fwidth
  
      vspecs = [
          ("edge_weight", FixedPrecisionType(10, 0, signed=False)),
          (
              "edge_weight_aggr",
              FixedPrecisionType(ew_aggr_w, ew_aggr_intw, signed=False),
          ),
          ("aggr", FixedPrecisionType(aggr_w, aggr_intw)),
          ("norm", FixedPrecisionType(norm_w, norm_intw, signed=False)),
      ]
      precision_converter = APTypeConverter()
      for vname, default_precision in vspecs:
          (
              params[f"{vname}_t"],
              type_name,
          ) = node.model.config.get_precision(node, var=vname)
          if type_name.endswith("default_t"):
              params[f"{vname}_t"] = precision_converter.convert(
                  default_precision
              ).definition_cpp()
          else:
              params[f"{vname}_t"] = precision_converter.convert(
                  params[f"{vname}_t"]
              ).definition_cpp()
      params["output_t"] = node.get_output_variable().type.name
  
      if node.attributes["collapse"] in ["mean", "max"]:
          params["collapse_type"] = "collapse_{}".format(
              node.attributes["collapse"]
          )
      else:
          params["collapse_type"] = "no_collapse"
  
      params["mean_by_nvert"] = str(
          node.attributes["mean_by_nvert"]
      ).lower()
  
      self.get_transforms_config(node, params)
  
      return self.template[0].format(**params)
  
imports: import numpy
  from hls4ml.backends.fpga.fpga_types import APTypeConverter
  from hls4ml.backends.template import FunctionCallTemplate, LayerConfigTemplate
  from hls4ml.model.layers import GarNet, GarNetStack
  from hls4ml.model.types import FixedPrecisionType
label_desc: Use image node_id 3 for calling the GarNetConfigTemplate obj's underlying member method code with example usage: obj.format(node) and returns: self