},
						},
						SchemaProps: spec.SchemaProps{
							Description: "APIGroups is the name of the APIGroup that contains the resources.  If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed.  \"*\" means all.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{

  for (auto& input : inputs) {
    auto input_op = input.get().getDefiningOp();
    if (!input_op || !IsSupportedHostInputOp(input_op)) return false;
  }
  for (auto entry : llvm::enumerate(inputs)) {
    Value input = entry.value().get();
    auto ranked_type = mlir::dyn_cast<RankedTensorType>(input.getType());
    if (!ranked_type) return false;
    auto input_shape = ranked_type.getShape();

      node.name = output_renaming_map[node.name]
    elif node.op == '_Retval':
      graph_def.node.remove(node)
    else:
      # Update the inputs referring to the pre-renaming node.
      for idx, input_name in enumerate(node.input):
        if input_name in output_renaming_map:
          node.input[idx] = output_renaming_map[input_name]
      # Update the control inputs referring to the pre-renaming node.
      updating_inputs = []

      )
    factory.newConnection(pool, routeA1)
    assertThat(realTaskRunner.activeQueues()).isNotEmpty()
    Thread.sleep(100)
    val threads = arrayOfNulls<Thread>(Thread.activeCount() * 2)
    Thread.enumerate(threads)
    for (t in threads) {
      if (t != null && t.name == "OkHttp TaskRunner") {
        t.interrupt()
      }
    }
    Thread.sleep(100)
    assertThat(realTaskRunner.activeQueues()).isEmpty()

    if (!result_ty) {
      return emitOptionalError(location, "Expected shape type for operand 0");
    }
    for (auto [index, ty] :
         llvm::drop_begin(llvm::enumerate(operands.getTypes()), 1)) {
      auto shape_type = llvm::dyn_cast_or_null<ShapedType>(ty);
      if (!shape_type) {
        return emitOptionalError(location, "Expected shape type for operand ",

      paddings_value.getNumElements() != permutation.size() * 2)
    return failure();

  SmallVector<int32_t, 8> shuffled_paddings(paddings_value.getNumElements());
  for (const auto &index_pair :
       llvm::enumerate(paddings_value.getValues<APInt>())) {
    size_t outer_idx = index_pair.index() / 2;
    size_t inner_idx = index_pair.index() % 2;

    shuffled_paddings[permutation[outer_idx] * 2 + inner_idx] =

		return fmt.Errorf("%s is not positive integer multiple of %s", quantity.String(), name)
	}

	return nil
}

// validateResourceQuotaScopes ensures that each enumerated hard resource constraint is valid for set of scopes
func validateResourceQuotaScopes(resourceQuotaSpec *core.ResourceQuotaSpec, fld *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}

        "properties": {
          "apiGroups": {
            "description": "APIGroups is the name of the APIGroup that contains the resources.  If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"\" represents the core API group and \"*\" represents all API groups.",
            "items": {
              "default": "",
              "type": "string"
            },

  // MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource.
  // +optional
  map<string, .k8s.io.apimachinery.pkg.api.resource.Quantity> maxLimitRequestRatio = 6;
}

IRMapping CloneSrcFuncArgumentsToMainFunc(func::FuncOp src_func_op,
                                          func::FuncOp main_func_op) {
  IRMapping mapper{};

  for (auto [src_arg_idx, src_arg] :
       llvm::enumerate(src_func_op.getArguments())) {
    // No need to create a mapping when there is no usage - it will not affect
    // the cloning.
    if (src_arg.use_empty()) continue;