runtime.GC()
			var buf bytes.Buffer
			err := pprof.Lookup("heap").WriteTo(&buf, 0)
			return buf.Bytes(), err
		}
	case madmin.ProfilerBlock:
		runtime.SetBlockProfileRate(100)
		prof.stopFn = func() ([]byte, error) {
			var buf bytes.Buffer
			err := pprof.Lookup("block").WriteTo(&buf, 0)
			runtime.SetBlockProfileRate(0)
			return buf.Bytes(), err
		}
	case madmin.ProfilerMutex:

            byte[] buf = new byte[16];

            // Skip advances internal file pointer; next read should use this offset
            in.skip(2);

            // Act
            int n = in.readDirect(buf, 0, 5);

            // Assert
            assertEquals(3, n, "Should report bytes read from SMB2 response");

	headerVer, metaVer uint
}

func decodeXLHeaders(buf []byte) (x xlHeaders, b []byte, err error) {
	x.headerVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	x.metaVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	if x.headerVer > xlHeaderVersion {
		return x, buf, fmt.Errorf("decodeXLHeaders: Unknown xl header version %d", x.headerVer)
	}

                buf.start = off;
                buf.reset();
                msg.encode_header(buf);
                buf.enc_ndr_long(msg.alloc_hint);
                buf.enc_ndr_short(0); /* context id */
                buf.enc_ndr_short(msg.getOpnum());
            }

            if ((msg.flags & DCERPC_LAST_FRAG) == DCERPC_LAST_FRAG) {

		// Add input readahead.
		// We use 2 buffers, so we always have a full buffer of input.
		pool := globalBytePoolCap.Load()
		bufA := pool.Get()
		bufB := pool.Get()
		defer pool.Put(bufA)
		defer pool.Put(bufB)
		ra, err := readahead.NewReaderBuffer(data, [][]byte{bufA[:fi.Erasure.BlockSize], bufB[:fi.Erasure.BlockSize]})
		if err == nil {
			toEncode = ra
			defer ra.Close()
		}
	}

        final StringBuilder buf = new StringBuilder(1000);

        @SuppressWarnings("unchecked")
        final List<String> roleTypeList = (List<String>) dataMap.get(fessConfig.getIndexFieldRole());
        buf.append(url);
        if (roleTypeList != null && !roleTypeList.isEmpty()) {
            buf.append(";r=");
            buf.append(roleTypeList.stream().sorted().collect(Collectors.joining(",")));

            }
        }
        if (buf.indexOf("mm") == -1) {
            final int pos = buf.indexOf("m");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "mm");
            }
        }
        if (buf.indexOf("ss") == -1) {
            final int pos = buf.indexOf("s");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "ss");
            }

  auto tf_dlm_type = GetDlDataType(data_type, status);
  if (!status->status.ok()) {
    return nullptr;
  }

  TensorReference tensor_ref(*tensor);  // This will call buf_->Ref()
  auto* tf_dlm_tensor_ctx = new TfDlManagedTensorCtx(tensor_ref);
  tf_dlm_tensor_ctx->reference = tensor_ref;

  DLManagedTensor* dlm_tensor = &tf_dlm_tensor_ctx->tensor;

        buf.reset();
        ns.encode(buf); // should not throw

        // After encoding, check how many bytes were used
        int bytesUsed = buf.getIndex();
        // Should be 2 bytes for the short value (alignment may add padding)
        assertTrue(bytesUsed >= 2, "Should use at least 2 bytes for short");

        // Reset index to read back
        buf.reset();

            tempBuf.append("null");
        }
        buf.append(tempBuf.toString());
        return buf;
    }

    /**
     * Appends a timestamp to the buffer.
     *
     * @param buf the string buffer to append to
     * @return the updated buffer
     */
    protected StringBuilder appendTimestamp(final StringBuilder buf) {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();