code: def init_lstm(self, layer):
      reuse_factor = layer.model.config.get_reuse_factor(layer)
      layer.set_attr("recurrent_reuse_factor", reuse_factor)
  
      # We don't use RF yet
      if (
          True
      ):  # layer.model.config.is_resource_strategy(layer): ... Quartus only supports Dense resource multiplication
          n_in, n_out, n_in_recr, n_out_recr = self.get_layer_mult_size(
              layer
          )
          self.set_closest_reuse_factor(layer, n_in, n_out)
          self.set_closest_reuse_factor(
              layer,
              n_in_recr,
              n_out_recr,
              attribute="recurrent_reuse_factor",
          )
          layer.set_attr("strategy", "resource")
  
      # Split weights for easier storage in on-chip memory and implementation in HLS
      weights_data = layer.weights["weight"].data
      rec_weights_data = layer.weights["recurrent_weight"].data
      bias_data = layer.weights["bias"].data
  
      weight_types = ["i", "f", "c", "o"]
      for i in range(0, 4):
          layer.add_weights_variable(
              name=f"weight_{weight_types[i]}",
              var_name=f"kernel_{weight_types[i]}_{{index}}",
              data=weights_data[
                  0 : layer.get_attr("n_in"),
                  i
                  * layer.get_attr("n_out") : (i + 1)
                  * layer.get_attr("n_out"),
              ],
              quantizer=layer.get_attr("weight_quantizer"),
              compression=None,
          )
          layer.add_weights_variable(
              name=f"recurrent_weight_{weight_types[i]}",
              var_name=f"recurrent_kernel_{weight_types[i]}_{{index}}",
              data=rec_weights_data[
                  0 : layer.get_attr("n_out"),
                  i
                  * layer.get_attr("n_out") : (i + 1)
                  * layer.get_attr("n_out"),
              ],
              quantizer=layer.get_attr("weight_quantizer"),
              compression=None,
          )
          layer.add_weights_variable(
              name=f"bias_{weight_types[i]}",
              var_name=f"bias_{weight_types[i]}_{{index}}",
              data=bias_data[
                  i
                  * layer.get_attr("n_out") : (i + 1)
                  * (layer.get_attr("n_out"))
              ],
              quantizer=layer.get_attr("weight_quantizer"),
              compression=None,
          )
  
imports: import os
  from contextlib import contextmanager
  import numpy
  from hls4ml.backends import FPGABackend
  from hls4ml.model.attributes import ConfigurableAttribute, TypeAttribute
  from hls4ml.model.flow import register_flow
  from hls4ml.model.layers import GRU, LSTM, Activation, Conv1D, Conv2D, Dense, Embedding, Layer, SimpleRNN, Softmax
  from hls4ml.model.optimizer import get_backend_passes, layer_optimizer
  from hls4ml.model.types import FixedPrecisionType, IntegerPrecisionType, NamedType
  from hls4ml.report import parse_quartus_report
label_desc: Use image node_id 16 for calling the QuartusBackend obj's underlying member method code with example usage: obj.init_lstm(layer) without return types