counted only if the ops are named 'op_name' and has 'attr_val' if
      'attr_name' is specified.
    """
    op_count = 0
    for op_name in op_names:
      # Check the main graph
      op_count += self._count_op_with_name_and_attribute(
          nodes=graphdef.node,
          op_name=op_name,
          attr_name=attr_name,
          attr_val=attr_val,
          get_op_name=get_op_name,

        op_state.operands[1] = shape_op;
      }
    }
  }
  if (op_name == "vhlo.reduce_v1" || op_name == "vhlo.reduce_window_v1" ||
      op_name == "vhlo.sort_v1" || op_name == "vhlo.scatter_v1") {
    op_state.addRegion();
  }
  if (op_name == "vhlo.while_v1") {
    op_state.addRegion();
    op_state.addRegion();
  }

  TF_OperationDescription* init(string type) {
    // Construct op_name to match the name used by REGISTER_OP in the
    // ATTR_TEST_REGISTER calls above.
    string op_name = "CApiAttributesTestOp";
    if (type.find("list(") == 0) {
      op_name += "List";
      type = type.replace(0, 5, "");
      type = type.replace(type.size() - 1, 1, "");
    }
    op_name += type;
    return TF_NewOperation(

		failOnce.Do(func() {
			// (B) Evict two pods and fail this update.
			evict(podNames[1], podNames[2])
			handled = true
			err = errors.NewConflict(a.GetResource().GroupResource(), pdb.Name, fmt.Errorf("conflict"))
		})
		return handled, obj, err
	})

	// (A) Delete one pod
	if err := dc.coreClient.CoreV1().Pods("default").Delete(ctx, podNames[0], metav1.DeleteOptions{}); err != nil {
		t.Fatal(err)
	}

    for (StringRef op_name : func_count_map.keys()) {
      const int32_t quantized_count = func_count_map[op_name].num_quant;
      const int32_t total_count =
          quantized_count + func_count_map[op_name].num_float;
      lines.push_back(absl::StrFormat("%s %d/%d",
                                      pad_string(op_name, name_col_width),

	pods, err := ctrl.findPodsByPVCKey(pvcKey)
	if err != nil {
		return nil, err
	}
	podNames := []string{}
	for _, pod := range pods {
		if util.IsPodTerminated(pod, pod.Status) {
			continue
		}
		if len(pod.Spec.NodeName) == 0 {
			podNames = append(podNames, pod.Name)
		}
	}
	return podNames, nil
}

// doDeleteVolume finds appropriate delete plugin and deletes given volume, returning

}

bool IsInSubgraph(const string& func_id) { return !func_id.empty(); }

Status Encapsulator::CopySubgraphNodes(
    absl::flat_hash_map<const Node*, Node*>* node_images) {
  for (Node* node : graph_in_->op_nodes()) {
    string func_id;
    TF_RETURN_IF_ERROR(GetFunctionNameAttr(node, &func_id));
    if (!IsInSubgraph(func_id)) continue;

    Subgraph& subgraph = subgraphs_[func_id];

	if r1 == socket_error {
		err = errnoErr(e1)
	}
	return
}

func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) {
	r1, _, e1 := Syscall6(procgetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(unsafe.Pointer(optlen)), 0)
	if r1 == socket_error {
		err = errnoErr(e1)
	}
	return
}

  // Iterate over nodes in sorted order so that compiler fuel is deterministic.
  // We can't simply pass op_nodes().begin() and op_nodes().end() to the
  // std::vector constructor because they're not proper iterators, with
  // iterator_traits defined and so on.
  std::vector<Node*> sorted_nodes;
  for (Node* node : graph_->op_nodes()) {
    sorted_nodes.push_back(node);
  }

                                PatternRewriter &rewriter) const override {
    Value result = op.getX();
    for (StringRef op_name : op.getOpNames().getAsValueRange<StringAttr>()) {
      std::string full_name = "tf." + op_name.str();
      // All ops in the sequences have the same result type as the original
      // result type.