T[] castBuffer = (T[]) buffer;
    Arrays.sort(castBuffer, 0, bufferSize, comparator);
    if (bufferSize > k) {
      Arrays.fill(buffer, k, buffer.length, null);
      bufferSize = k;
      threshold = buffer[k - 1];
    }
    // Up to bufferSize, all elements of buffer are real Ts (not null unless T includes null)
    T[] topK = Arrays.copyOf(castBuffer, bufferSize);

	derBytes, err := x509.CreateCertificate(cryptorand.Reader, &template, &template, &priv.PublicKey, priv)
	if err != nil {
		return nil, nil, err
	}

	// Generate cert
	certBuffer := bytes.Buffer{}
	if err := pem.Encode(&certBuffer, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
		return nil, nil, err
	}

	// Generate key
	keyBuffer := bytes.Buffer{}

        this.cache = new Object[maxBuffers];
        this.bufferSize = maxSize;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.BufferCache#getBuffer()
     */
    @Override
    public byte[] getBuffer () {
        synchronized ( this.cache ) {
            byte[] buf;

            if ( this.freeBuffers > 0 ) {
                for ( int i = 0; i < this.cache.length; i++ ) {

        resp.reset();

        long k;

        /*
         * First request w/ interim response
         */
        try {
            req.setBuffer(getContext().getBufferCache().getBuffer());
            req.nextElement();
            if ( req.hasMoreElements() ) {
                SmbComBlankResponse interim = new SmbComBlankResponse(getContext().getConfig());

  @GuardedBy("this")
  @CheckForNull
  private File file;

  /** ByteArrayOutputStream that exposes its internals. */
  private static class MemoryOutput extends ByteArrayOutputStream {
    byte[] getBuffer() {
      return buf;
    }

    int getCount() {
      return count;
    }
  }

  /** Returns the file holding the data (possibly null). */
  @VisibleForTesting
  @CheckForNull

 * 
 * @author mbechler
 * @internal
 */
public interface BufferCache {

    /**
     * 
     * @return a buffer from the cache, or a new one
     */
    byte[] getBuffer ();


    /**
     * Return a buffer to the cache
     * 
     * @param buf
     */
    void releaseBuffer ( byte[] buf );

          nullptr, pjrt_client->addressable_devices()[0]));
  tensorflow::AsyncValueTensor* av_tensor =
      tensorflow::AsyncValueTensor::FromTensor(&tensor);
  av_tensor->SetBuffer(std::move(buffer));

  EXPECT_THAT(
      GetPjRtCBufferFromTensor(&tensor),
      StatusIs(
          error::INTERNAL,
          HasSubstr(absl::StrCat(

import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Providers a byte buffer to be used in processing streams.
 */
@ServiceScope(Scope.Global.class)
public interface BufferProvider {
    byte[] getBuffer();

	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
	if err != nil {
		return nil, nil, err
	}

	// Generate cert
	certBuffer := bytes.Buffer{}
	if err := pem.Encode(&certBuffer, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
		return nil, nil, err
	}

	// Generate key
	keyBuffer := bytes.Buffer{}

                                 reduction_type.getValue().size());
  fbb.String("reduction_type", reduction_type_str);

  fbb.EndMap(start_map);
  fbb.Finish();
  custom_option_buffer.assign(fbb.GetBuffer().begin(), fbb.GetBuffer().end());
  return success();
}

LogicalResult ConvertNgrams(func::FuncOp func, llvm::StringRef api,
                            FuncAttr attr) {
  func.eraseBody();
  func.addEntryBlock();