code: def test_fuse_concat_max_num_args(executor_type, shape_type):
      """
      In this test, we have an operation with 3 inputs before concat. In the
      SplitArgs we cannot calculate these inputs as inputs to the concat layer,
      because they will be added to the concat after the fusing operation. So
      FuseOps pass should handle this case and stop fusing before the concat
      layer.
  
      The example:
         x     y     z                  x     y     z
         \     |     /                  \     |     /
          \    |    /                    \    |    /
             where            ...           where
               |                              |
              exp                            exp
               \                              /
                \                            /
                 \----->    concat    <-----/
      """
      if shape_type == "dynamic":
          shape = (tvm.tir.Any(), 20)
          ops_num = 80
      else:
          shape = (10, 20)
          ops_num = 300
      shape_np = (10, 20)
      dtype = "float32"
      axis = 1
  
      def _base_func(name):
          x = relay.var(name, shape=shape)
          y = relay.var(f"y{name}", shape=shape)
          z = relay.var(f"z{name}", shape=shape)
          cond = relay.less(x, relay.const(1, "float32"))
          l = relay.add(y, relay.const(1, "float32"))
          r = relay.add(z, relay.const(5, "float32"))
          w = relay.where(cond, l, r)
          w = relay.exp(w)
          return [x, y, z], w
  
      def _get_model():
          inp = []
          out = []
          inputs_np = {}
          for i in range(ops_num):
              inputs, w = _base_func(f"x{i}")
              inputs_np[f"x{i}"] = np.random.uniform(
                  size=shape_np
              ).astype(dtype)
              inputs_np[f"yx{i}"] = np.random.uniform(
                  size=shape_np
              ).astype(dtype)
              inputs_np[f"zx{i}"] = np.random.uniform(
                  size=shape_np
              ).astype(dtype)
              inp.extend(inputs)
              out.append(w)
          t = relay.Tuple(out)
          w = relay.op.concatenate(t, axis)
          return inputs_np, relay.Function(inp, w)
  
      def ref_impl(inputs):
          res = []
          for i in range(0, len(inputs), 3):
              x = inputs[i]
              y = inputs[i + 1]
              z = inputs[i + 2]
              comp = np.where(x < 1, y + 1, z + 5)
              comp = np.exp(comp)
              res.append(comp)
          return np.concatenate(tuple(res), axis=axis)
  
      if executor_type == "ge" and shape_type == "dynamic":
          pytest.skip()
      _validate_opencl_executors(executor_type, _get_model, ref_impl)
  
file_path: tvm/tests/python/codegen/test_target_codegen_opencl.py
imports: import tvm
  from tvm import te, relay
  import tvm.testing
  import re
  import pytest
  import numpy
label_desc: Use image node_id 11 for calling a global function with example usage: test_fuse_concat_max_num_args(executor_type, shape_type) and returns: list,  w, inputs_np,  relay, np