code: def arm_compute_lib_pattern_table(disabled_ops=["concatenate"]):
      """Get the ACL pattern table."""
  
      def conv_pattern():
          """Create a convolution pattern.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("nn.pad")(wildcard(), wildcard()) | wildcard()
          pattern = is_op("nn.conv2d")(pattern, is_constant())
          pattern = pattern.optional(
              lambda x: is_op("nn.bias_add")(x, is_constant())
          )
          pattern = pattern.optional(is_op("nn.relu"))
          return pattern
  
      def qnn_conv_pattern():
          """Create a quantized convolution pattern.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("nn.pad")(wildcard(), wildcard()) | wildcard()
          pattern = is_op("qnn.conv2d")(
              pattern,
              is_constant(),
              is_constant(),
              is_constant(),
              is_constant(),
              is_constant(),
          )
          pattern = pattern.optional(
              lambda x: is_op("nn.bias_add")(x, is_constant())
          )
          pattern = pattern.optional(is_op("nn.relu"))
          pattern = is_op("qnn.requantize")(
              pattern,
              wildcard(),
              wildcard(),
              is_constant(),
              is_constant(),
          )
          return pattern
  
      def dense_pattern():
          """Create a dense (fully-connected) pattern.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("nn.dense")(wildcard(), is_constant())
          pattern = pattern.optional(
              lambda x: is_op("nn.bias_add")(x, is_constant())
          )
          return pattern
  
      def qnn_dense_pattern():
          """Create a quantized dense (fully-connected) pattern.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("qnn.dense")(
              wildcard(),
              is_constant(),
              is_constant(),
              is_constant(),
              is_constant(),
              is_constant(),
          )
          pattern = pattern.optional(
              lambda x: is_op("nn.bias_add")(x, is_constant())
          )
          pattern = is_op("qnn.requantize")(
              pattern,
              wildcard(),
              wildcard(),
              is_constant(),
              is_constant(),
          )
          return pattern
  
      def avg_pool2d_pattern():
          """Creates a pattern that matches either quantized
          avg_pool2d or quantized global_avg_pool2d.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("cast")(wildcard())
          pattern = is_op("nn.avg_pool2d")(pattern) | is_op(
              "nn.global_avg_pool2d"
          )(pattern)
          pattern = is_op("cast")(pattern)
          return pattern
  
      def l2_pool2d_pattern():
          """Create an l2 pooling pattern from equivalent relay operators.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the convolution pattern.
          """
          pattern = is_op("power")(wildcard(), is_expr(const(2.0)))
          pattern = is_op("nn.avg_pool2d")(pattern)
          pattern = is_op("sqrt")(pattern)
          return pattern
  
      def concatenate_pattern():
          """Create an concatenate pattern from equivalent relay operators.
  
          Returns
          -------
          pattern : dataflow_pattern.AltPattern
              Denotes the concatenate pattern.
          """
          pattern = is_op("concatenate")(is_tuple(None))
          return pattern
  
      def check_conv(extract):
          """Check conv pattern is supported by ACL."""
          call = extract
          while call.op.name != "nn.conv2d":
              call = call.args[0]
          return conv2d(call)
  
      def check_qnn_conv(extract):
          """Check qnn conv pattern is supported by ACL."""
          if extract.attrs.out_dtype not in ("uint8", "int8"):
              return False
          call = extract
          while call.op.name != "qnn.conv2d":
              call = call.args[0]
          return qnn_conv2d(call)
  
      def check_dense(extract):
          """Check conv pattern is supported by ACL."""
          call = extract
          while call.op.name != "nn.dense":
              call = call.args[0]
          return dense(call)
  
      def check_qnn_dense(extract):
          """Check qnn conv pattern is supported by ACL."""
          if extract.attrs.out_dtype not in ("uint8", "int8"):
              return False
          call = extract
          while call.op.name != "qnn.dense":
              call = call.args[0]
          return qnn_dense(call)
  
      def check_avg_pool2d(extract):
          """Check average pool2d pattern is supported by ACL."""
          if extract.attrs.dtype not in ("uint8", "int8"):
              return False
          pool = extract.args[0]
          if pool.args[0].attrs.dtype != "int32":
              return False
          return avg_pool2d(pool, from_quantized_composite=True)
  
      def check_l2_pool2d(extract):
          """Check l2 pool2d pattern is supported by ACL."""
          pool = extract.args[0]
          return avg_pool2d(pool)
  
      def check_concatenate(expr):
          """Check concatenate pattern is supported by ACL."""
          if "concatenate" in disabled_ops:
              return False
          attrs, type_args = expr.attrs, expr.type_args
          for idx in range(len(type_args[0].fields)):
              if type_args[0].fields[idx].dtype not in [
                  "float32",
                  "uint8",
                  "int8",
              ]:
                  return False
          # ACL concatenate only supports maximum 4 dimensions input tensor
          if attrs.axis not in [-4, -3, -2, -1, 0, 1, 2, 3]:
              return False
          return True
  
      return [
          ("arm_compute_lib.conv2d", conv_pattern(), check_conv),
          (
              "arm_compute_lib.qnn_conv2d",
              qnn_conv_pattern(),
              check_qnn_conv,
          ),
          ("arm_compute_lib.dense", dense_pattern(), check_dense),
          (
              "arm_compute_lib.qnn_dense",
              qnn_dense_pattern(),
              check_qnn_dense,
          ),
          (
              "arm_compute_lib.qnn_conv2d",
              qnn_conv_pattern(),
              check_qnn_conv,
          ),
          (
              "arm_compute_lib.avg_pool2d",
              avg_pool2d_pattern(),
              check_avg_pool2d,
          ),
          (
              "arm_compute_lib.l2_pool2d",
              l2_pool2d_pattern(),
              check_l2_pool2d,
          ),
          (
              "arm_compute_lib.concatenate",
              concatenate_pattern(),
              check_concatenate,
          ),
      ]
  
imports: import tvm
  from tvm import relay
  from tvm._ffi import register_func
  from tvm.relay import transform
  from tvm.relay.build_module import bind_params_by_name
  from tvm.relay.expr import const
  from ...dataflow_pattern import is_constant, is_expr, is_op, is_tuple, wildcard
  from ..strategy.generic import is_depthwise_conv2d
  from .register import register_pattern_table
label_desc: Use image node_id 4 for calling a global function with example usage: arm_compute_lib_pattern_table(disabled_ops) and returns: list, pattern, pattern, pattern, pattern, pattern, pattern, pattern, conv2d, qnn_conv2d, dense, qnn_dense, avg_pool2d, avg_pool2d, True, False, False, False, False, False, False, False