code: def _register_flows(self):
      initializers = self._get_layer_initializers()
      init_flow = register_flow(
          "init_layers",
          initializers,
          requires=["optimize"],
          backend=self.name,
      )
  
      streaming_passes = [
          "vivado:reshape_stream",
          "vivado:clone_output",
          "vivado:insert_zero_padding_before_conv1d",
          "vivado:insert_zero_padding_before_conv2d",
          "vivado:broadcast_stream",
      ]
      streaming_flow = register_flow(
          "streaming",
          streaming_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      quantization_passes = [
          "vivado:merge_batch_norm_quantized_tanh",
          "vivado:quantize_dense_output",
          "fuse_consecutive_batch_normalization",
          "vivado:xnor_pooling",
      ]
      quantization_flow = register_flow(
          "quantization",
          quantization_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      optimization_passes = [
          "vivado:remove_final_reshape",
          "vivado:optimize_pointwise_conv",
          "vivado:inplace_parallel_reshape",
          "vivado:inplace_stream_flatten",
          "vivado:skip_softmax",
          "vivado:fix_softmax_table_size",
      ]
      optimization_flow = register_flow(
          "optimize",
          optimization_passes,
          requires=[init_flow],
          backend=self.name,
      )
  
      vivado_types = [
          "vivado:transform_types",
          "vivado:register_bram_weights",
          "vivado:generate_conv_streaming_instructions",
          "vivado:apply_resource_strategy",
          "vivado:generate_conv_im2col",
      ]
      vivado_types_flow = register_flow(
          "specific_types",
          vivado_types,
          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", "vivado:write_hls"]
      self._writer_flow = register_flow(
          "write",
          writer_passes,
          requires=["vivado:ip"],
          backend=self.name,
      )
  
      fifo_depth_opt_passes = [
          "vivado:fifo_depth_optimization"
      ] + writer_passes  # After optimization, a new project will be written
  
      register_flow(
          "fifo_depth_optimization",
          fifo_depth_opt_passes,
          requires=["vivado: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
          + quantization_passes
          + optimization_passes
          + vivado_types
          + templates
          + writer_passes
          + fifo_depth_opt_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,
          vivado_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
  import sys
  import numpy
  from hls4ml.backends import FPGABackend
  from hls4ml.backends.fpga.fpga_types import APTypeConverter, HLSTypeConverter, VivadoArrayVariableConverter
  from hls4ml.model.attributes import ChoiceAttribute, ConfigurableAttribute, TypeAttribute
  from hls4ml.model.flow import register_flow
  from hls4ml.model.layers import GRU, LSTM, Conv1D, Conv2D, Dense, DepthwiseConv2D, Embedding, GarNet, GarNetStack, GlobalPooling1D, GlobalPooling2D, Layer, Pooling1D, Pooling2D, SeparableConv1D, SeparableConv2D, SimpleRNN, Softmax
  from hls4ml.model.optimizer import get_backend_passes, layer_optimizer
  from hls4ml.model.types import FixedPrecisionType, IntegerPrecisionType, NamedType, PackedType
  from hls4ml.report import parse_vivado_report
  from hls4ml.utils.fixed_point_utils import ceil_log2
label_desc: Use image node_id 3 for calling the VivadoBackend obj's underlying member method code with example usage: obj._register_flows() without return types