for (const auto* edge : oper->node.out_edges()) {
    if (edge->IsControlEdge() && !edge->dst()->IsSink()) {
      ++count;
    }
  }
  return count;
}

int TF_OperationGetControlOutputs(TF_Operation* oper,
                                  TF_Operation** control_outputs,
                                  int max_control_outputs) {
  int count = 0;
  for (const auto* edge : oper->node.out_edges()) {

func (z BackendType) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt(o, int(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BackendType) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int
		zb0001, bts, err = msgp.ReadIntBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BackendType(zb0001)

                    CompactHashSet<String> set = CompactHashSet.create(asList(elements));
                    for (int i = 0; i < 100; i++) {
                      set.add("extra" + i);
                    }
                    for (int i = 0; i < 100; i++) {
                      set.remove("extra" + i);
                    }
                    set.trimToSize();
                    return set;

        sortedElements =
            Arrays.copyOf(sortedElements, IntMath.saturatedAdd(length, length / 2 + 1));
      }
      int[] sortedCounts = new int[sortedElements.length];
      for (int i = 0; i < length; i++) {
        int index = Arrays.binarySearch(sortedElements, 0, uniques, elements[i], comparator);
        if (counts[i] >= 0) {
          sortedCounts[index] += counts[i];
        } else {

    boolean supportsValuesHashCode = supportsValuesHashCode(map);
    if (supportsValuesHashCode) {
      int expectedEntrySetHash = 0;
      for (Entry<K, V> entry : entrySet) {
        assertTrue(map.containsKey(entry.getKey()));
        assertTrue(map.containsValue(entry.getValue()));
        int expectedHash =
            (entry.getKey() == null ? 0 : entry.getKey().hashCode())

@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}
```

     */
    boolean hasCapability ( int cap ) throws CIFSException;


    /**
     * @return the send buffer size of the underlying connection
     * @throws CIFSException
     */
    int getSendBufferSize () throws CIFSException;


    /**
     * @return the receive buffer size of the underlying connection
     * @throws CIFSException
     */
    int getReceiveBufferSize () throws CIFSException;

        return emptySource;
    }

    protected Map<String, Object> createEmptyMap() {
        final Map<String, Object> map = new HashMap<>();
        map.put(FieldNames.TEXT, StringUtil.EMPTY);

        for (int i = 0; i < readings.length; i++) {
            map.put(FieldNames.READING_PREFIX + i, new String[] {});
        }

        map.put(FieldNames.FIELDS, new String[] {});
        map.put(FieldNames.TAGS, new String[] {});

		return nil, err
	}

	partQuorumMap := make(map[int]int)
	for _, driveParts := range objectParts {
		partsWithMetaCount := make(map[int]int, len(driveParts))
		// part files can be either part.N or part.N.meta
		for _, partPath := range driveParts {
			var partNum int
			if _, err := fmt.Sscanf(partPath, "part.%d", &partNum); err == nil {
				partsWithMetaCount[partNum]++

    /**
     * Unset received status
     */
    void clearReceived ();


    /**
     * 
     * @return number of credits granted by the server
     */
    int getGrantedCredits ();


    /**
     * @return status code
     */
    int getErrorCode ();


    /**
     * @param k
     */
    void setMid ( long k );


    /**
     * @return mid
     */
    long getMid ();