// MergeGateways combines multiple gateways targeting the same workload into a single logical Gateway.
// Note that today any Servers in the combined gateways listening on the same port must have the same protocol.
// If servers with different protocols attempt to listen on the same port, one of the protocols will be chosen at random.

// CHECK:             tfl.yield
// CHECK-SAME:  (tensor<i1>) -> ()
// CHECK:             [[VAL_30:%.*]]:7 =
// CHECK: call @tfl.while_body
// CHECK:             tfl.yield
// CHECK-SAME: (tensor<i32>, tensor<i32>, tensor<*xf32>, tensor<4x2xf32>, tensor<4x2xf32>, tensor<*xf32>, tensor<4x4x3xf32>) -> ()

// CHECK-LABEL:   func private @tfl.while_cond(

module {
  // CHECK-LABEL: func @singlecluster
  // CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)
  func.func @singlecluster(%arg0: tensor<?xi32>) -> tensor<?xi32> {
    // CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"(%[[ARG_0]])
    %2 = "tf.A"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>

    // CHECK: %[[TPU0_OUTPUT:[0-9]*]] = "tf_device.launch"
    // CHECK-SAME: <{device = "tpu0"}>

This will be especially useful when you use it in a **large code base** where you use **the same dependencies** over and over again in **many *path operations***.

## To `async` or not to `async`

As dependencies will also be called by **FastAPI** (the same as your *path operation functions*), the same rules apply while defining your functions.

// CHECK: %[[CALL:.+]] = "tf.XlaCallModule"(%[[ARG_0]], %[[DQ]])
// CHECK-SAME: _entry_function = @composite_conv_fn, _original_entry_function = "composite_conv_fn", _quantization_method = "weight_only_ptq { }"
// CHECK-SAME: (tensor<1x3x2x3xf32>, tensor<2x3x3x2xf32>) -> tensor<1x2x2x2xf32>
// CHECK: return %[[CALL]] : tensor<1x2x2x2xf32>

// -----

   - Variant runtime2 has attributes {custom=c2, org.gradle.status=${MultipleVariantSelectionIntegrationTest.defaultStatus()}}""")
    }

    void "cannot select distinct variants of the same component by using different attributes if they have the same capabilities"() {
        given:
        repository {
            'org:test:1.0' {
                variant('api') {
                    attribute('custom', 'c1')
                }

  // CHECK: "tf.IfRegion"
  // CHECK-SAME: is_stateless = false

  // CHECK: "tf.CalibrationStatisticsSaver"
  // CHECK-SAME: output_file_path = "serving_default_0.pb"

  // CHECK: "tf.CalibrationStatisticsSaver"
  // CHECK-SAME: output_file_path = "serving_default_1.pb"

  // CHECK: "tf.CalibrationStatisticsSaver"
  // CHECK-SAME: output_file_path = "serving_default_2.pb"

// CHECK-SAME: tf.entry_function = {inputs = "add_x:0,add_y:0", outputs = "add:0"}
// CHECK-SAME: tf_saved_model.exported_names = ["main"]

// Check that the function call to @add exists and not to @NoOp.
// CHECK: %[[CALL0:.*]] = "tf.PartitionedCall"(%[[ARG0]], %[[ARG1]]) <{
// CHECK-NOT: f = @NoOp
// CHECK-SAME: f = @add
// CHECK-SAME: }>
// CHECK-SAME: : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>

// CHECK: "tf_saved_model.session_initializer"()
// CHECK-SAME: initializers = [@init_func_restore_op]

// CHECK: func.func @init_func_restore_op()
// CHECK-SAME: tf_saved_model.exported_names = ["tf_saved_model.session_initializer_restore_op"]
// CHECK-SAME: tf_saved_model.initializer_type = "restore_op"

			return u.nify(x.elem, y.elem, emode, p)
		}

	case *Struct:
		// Two struct types unify if they have the same sequence of fields,
		// and if corresponding fields have the same names, their (field) types unify,
		// and they have identical tags. Two embedded fields are considered to have the same
		// name. Lower-case field names from different packages are always different.
		if y, ok := y.(*Struct); ok {