^bb0(%arg0: tensor<? x f16>, %arg1: tensor<? x f16>, %arg2: tensor<? x f16>):
  // expected-error @+1 {{'tfl.add_n' op operand #0 must be variadic of tensor of 32-bit float or 32-bit signless integer}}
  %0 = "tfl.add_n"(%arg0, %arg1, %arg2): (tensor<? x f16>, tensor<? x f16>, tensor<? x f16>) -> tensor<? x f16>
  func.return %0 : tensor<? x f16>
}

// -----

        element_types.push_back(getElementTypeOrSelf(value.getType()));
      }
    }

    if constexpr (std::is_same<DstOpT, mhlo::CaseOp>::value) {
      // Explicitly handle the Case op because it has variadic regions and takes
      // the number of regions as an input along with the operands.
      mhlo_op = rewriter.create<DstOpT>(loc, op.getResultTypes(),
                                        adaptor.getBranchIndex(),

        (incl. anti-aliasing).
    *   Renamed `tf.image` functions to remove duplicate "image" where it is
        redundant.
    *   Variadic reduce is supported on CPU Variadic reduce is supported on CPU
    *   Remove unused `StringViewVariantWrapper`.
    *   Delete unused `Fingerprint64Map` op registration
    *   Add broadcasting support to `tf.matmul`.

	}
	return s.newValue3(ssa.OpSliceMake, n.Type(), p, l, c)
}

// minMax converts an OMIN/OMAX builtin call into SSA.
func (s *state) minMax(n *ir.CallExpr) *ssa.Value {
	// The OMIN/OMAX builtin is variadic, but its semantics are
	// equivalent to left-folding a binary min/max operation across the
	// arguments list.
	fold := func(op func(x, a *ssa.Value) *ssa.Value) *ssa.Value {
		x := s.expr(n.Args[0])

		{"(*Signature).Results", Method, 5},
		{"(*Signature).String", Method, 5},
		{"(*Signature).TypeParams", Method, 18},
		{"(*Signature).Underlying", Method, 5},
		{"(*Signature).Variadic", Method, 5},
		{"(*Slice).Elem", Method, 5},
		{"(*Slice).String", Method, 5},
		{"(*Slice).Underlying", Method, 5},
		{"(*StdSizes).Alignof", Method, 5},
		{"(*StdSizes).Offsetsof", Method, 5},