@Param({ "noop", "real", "preallocate" })
    private String breaker;

    @Setup
    public void setup() {
        switch (breaker) {
            case "real":
                breakerService = new HierarchyCircuitBreakerService(Settings.EMPTY, List.of(), clusterSettings);
                break;
            case "preallocate":
                preallocateBreaker = true;

	// Since the number of directory records is not validated, it is not
	// safe to preallocate r.File without first checking that the specified
	// number of files is reasonable, since a malformed archive may
	// indicate it contains up to 1 << 128 - 1 files. Since each file has a
	// header which will be _at least_ 30 bytes we can safely preallocate
	// if (data size / 30) >= end.directoryRecords.

   */
  @CanIgnoreReturnValue
  public static <K, V> ImmutableMap<K, V> uniqueIndex(
      Iterable<V> values, Function<? super V, K> keyFunction) {
    // We can provide a hint to the builder to preallocate the correct size when the iterable is
    // either a List (which likely has a fast size() implementation), or an ImmutableCollection
    // (which definitely has a fast size() implementation). While Collection also has a size()

   */
  @CanIgnoreReturnValue
  public static <K, V> ImmutableMap<K, V> uniqueIndex(
      Iterable<V> values, Function<? super V, K> keyFunction) {
    // We can provide a hint to the builder to preallocate the correct size when the iterable is
    // either a List (which likely has a fast size() implementation), or an ImmutableCollection
    // (which definitely has a fast size() implementation). While Collection also has a size()

            lock.lock();
            return getAvailablePort();
        } finally {
            lock.unlock();
        }
    }

    /**
     * Deallocate the given port
     *
     * @param port The port to deallocate
     */
    public void deallocate(int port) {
        try {
            lock.lock();
            allocated.remove(Integer.valueOf(port));
        } finally {
            lock.unlock();
        }

        for (int i = methods.length; i-- > 0; ) {
            methodInfos[i] = new MethodInfo(methods[i]);
        }

        int upcastCount = getAccessibleMethods(clazz, methodInfos, 0);

        // Reallocate array in case some method had no accessible counterpart.
        if (upcastCount < methods.length) {
            methods = new Method[upcastCount];
        }

        int j = 0;

			buf.WriteByte('&')
		}
		buf.WriteString(keyEscaped)
		buf.WriteByte('=')
		buf.WriteString(url.QueryEscape(v))
	}
	return buf.String()
}

// NewBytes returns a new Bytes.
// A slice is preallocated.
func NewBytes() *Bytes {
	b := Bytes(GetByteBuffer()[:0])
	return &b
}

// NewBytesCap returns an empty Bytes with the given capacity.
func NewBytesCap(size int) *Bytes {

    int max_values, TF_Status* status);

// Gets the TF_Tensor valued attribute of `attr_name` of `oper`.
//
// Allocates a new TF_Tensor which the caller is expected to take
// ownership of (and can deallocate using TF_DeleteTensor).
TF_CAPI_EXPORT extern void TF_OperationGetAttrTensor(TF_Operation* oper,
                                                     const char* attr_name,

    return;
  }
  if (num_return_outputs > 0 && return_outputs == nullptr) {
    status->status = InvalidArgument(
        "'return_outputs' must be preallocated to length ", num_return_outputs);
    return;
  }
  GraphDef def;
  if (!tensorflow::ParseProtoUnlimited(&def, graph_def->data,
                                       graph_def->length)) {

pkg syscall (darwin-arm64), const F_PEOFPOSMODE = 3
pkg syscall (darwin-arm64), const F_PEOFPOSMODE ideal-int
pkg syscall (darwin-arm64), const F_PREALLOCATE = 42
pkg syscall (darwin-arm64), const F_PREALLOCATE ideal-int
pkg syscall (darwin-arm64), const F_RDADVISE = 44
pkg syscall (darwin-arm64), const F_RDADVISE ideal-int
pkg syscall (darwin-arm64), const F_RDAHEAD = 45