code: def _register_flows(self):
      initializers = self._get_layer_initializers()
      init_flow = register_flow(
          "init_layers",
          initializers,
          requires=["optimize"],
          backend=self.name,
      )
  
      streaming_passes = [
          "quartus:reshape_stream",
          "quartus:clone_output",
      ]
      streaming_flow = register_flow(
          "streaming",
          streaming_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      quartus_types = [
          "quartus:transform_types",
          "quartus:register_bram_weights",
          "quartus:apply_resource_strategy",
          "quartus:apply_winograd_kernel_transformation",
      ]
      quartus_types_flow = register_flow(
          "specific_types",
          quartus_types,
          requires=[init_flow],
          backend=self.name,
      )
  
      quantization_passes = [
          "quartus:merge_batch_norm_quantized_tanh",
          "quartus:quantize_dense_output",
          "fuse_consecutive_batch_normalization",
          "quartus:xnor_pooling",
      ]
      quantization_flow = register_flow(
          "quantization",
          quantization_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      optimization_passes = [
          "quartus:remove_final_reshape",
          "quartus:optimize_pointwise_conv",
          "quartus:inplace_parallel_reshape",
          "quartus:inplace_stream_flatten",
          "quartus:skip_softmax",
          "quartus:fix_softmax_table_size",
      ]
      optimization_flow = register_flow(
          "optimize",
          optimization_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      templates = self._get_layer_templates()
      template_flow = register_flow(
          "apply_templates",
          self._get_layer_templates,
          requires=[init_flow],
          backend=self.name,
      )
  
      writer_passes = ["make_stamp", "quartus:write_hls"]
  
      self._writer_flow = register_flow(
          "write",
          writer_passes,
          requires=["quartus:ip"],
          backend=self.name,
      )
  
      all_passes = get_backend_passes(self.name)
  
      extras = [
          # Ideally this should be empty
          opt_pass
          for opt_pass in all_passes
          if opt_pass
          not in initializers
          + streaming_passes
          + quartus_types
          + quantization_passes
          + templates
          + optimization_passes
          + writer_passes
      ]
  
      if len(extras) > 0:
          extras_flow = register_flow(
              "extras", extras, requires=[init_flow], backend=self.name
          )
      else:
          extras_flow = None
  
      ip_flow_requirements = [
          "optimize",
          init_flow,
          streaming_flow,
          quantization_flow,
          optimization_flow,
          quartus_types_flow,
          extras_flow,
          template_flow,
      ]
      ip_flow_requirements = list(filter(None, ip_flow_requirements))
  
      self._default_flow = register_flow(
          "ip", None, requires=ip_flow_requirements, backend=self.name
      )
  
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 3 for calling the QuartusBackend obj's underlying member method code with example usage: obj._register_flows() without return types