let summary = "XLA Launch Op. For use by the XLA JIT only.";

  let arguments = (ins
    Variadic<TF_Tensor>:$constants,
    Variadic<TF_Tensor>:$args,
    Variadic<TF_ResourceTensor>:$resources,

    SymbolRefAttr:$function
  );

  let results = (outs
    Variadic<TF_Tensor>:$results
  );

  TF_DerivedOperandSizeAttr Nresources = TF_DerivedOperandSizeAttr<2>;

		// and result values, corresponding parameter and result types unify,
		// and either both functions are variadic or neither is.
		// Parameter and result names are not required to match.
		// TODO(gri) handle type parameters or document why we can ignore them.
		if y, ok := y.(*Signature); ok {
			return x.variadic == y.variadic &&
				u.nify(x.params, y.params, emode, p) &&
				u.nify(x.results, y.results, emode, p)
		}

		// and result values, corresponding parameter and result types unify,
		// and either both functions are variadic or neither is.
		// Parameter and result names are not required to match.
		// TODO(gri) handle type parameters or document why we can ignore them.
		if y, ok := y.(*Signature); ok {
			return x.variadic == y.variadic &&
				u.nify(x.params, y.params, emode, p) &&
				u.nify(x.results, y.results, emode, p)
		}

        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])