// Blocks will read this much and find the first following newline.
// 128KB appears to be a very reasonable default.
const jsonSplitSize = 128 << 10

// startReaders will read the header if needed and spin up a parser
// and a number of workers based on GOMAXPROCS.
// If an error is returned no goroutines have been started and r.err will have been set.
func (r *PReader) startReaders() {

func (z BackendType) Msgsize() (s int) {
	s = msgp.IntSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BucketInfo) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Name"
	o = append(o, 0x85, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "Created"
	o = append(o, 0xa7, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64)

        byte[] encoded = AvPairs.encode(pairs);

        assertNotNull(encoded, "Encoded data should not be null");

        int expectedLength = 4 + 4 + // AvFlags header + data
                4 + 8 + // AvTimestamp header + data
                4 + 4 + // AvTargetName header + data
                4; // EOL
        assertEquals(expectedLength, encoded.length, "Encoded length should match expected");

        // Verify EOL at the end

     * ```
     *
     * The file is newline separated. The first two lines are the URL and the request method. Next
     * is the number of HTTP Vary request header lines, followed by those lines.
     *
     * Next is the response status line, followed by the number of HTTP response header lines,
     * followed by those lines.
     *
     * HTTPS responses also contain SSL session information. This begins with a blank line, and then

            @Override
            protected int readHeaderWireFormat(byte[] buffer, int bufferIndex) {
                // Simulate header reading
                return 33;
            }
        };
        byte[] buffer = new byte[1024];

        // Setup buffer after header
        buffer[33] = 4; // wordCount
        buffer[34] = (byte) 0xFF; // andxCommand
        buffer[36] = 0; // andxOffset low

     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        // SmbComSeekResponse has no additional data to read beyond header
        return 0;
    }

  /*
   * This method was rewritten in Java from an intermediate step of the Murmur hash function in
   * http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp, which contained the
   * following header:
   *
   * MurmurHash3 was written by Austin Appleby, and is placed in the public domain. The author
   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {

}

h1 {
	font-size: 30px;
}

h2 {
	font-size: 24px;
}

h3 {
	font-size: 18px;
}

.form-control {
	border-radius: 0px;
}

legend{
	display: none;
}

/* header */

#searchOptions {
	position: fixed;
	z-index: 10;
}

#searchOptions .container {
	width: 500px;
	max-width: 100%;
	height: 100%;
	overflow: auto;
	position: fixed;
	top: 0;
	bottom: 0;

OkHttp Zstandard (zstd) Integration
===================================

This module enables [Zstandard (zstd)][1] response compression in addition to Gzip, as long as
the `Accept-Encoding` header is not otherwise set. Web servers must be configured to return zstd
responses.

Note that zstd is not used for sending requests.

```java
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(ZstdInterceptor.INSTANCE)
  .build();
```

type RequestRecorder struct {
	// Data source to record
	io.Reader
	// Response body should be logged
	LogBody bool

	// internal recording buffer
	buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// Read reads from the internal reader and counts/save the body in the memory