}
        System.arraycopy( dialects, 0, dst, dstIndex, dialects.length );
        return dialects.length;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    int readBytesWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    public String toString() {
        return new String( "SmbComNegotiate[" +
            super.toString() +

    static byte[] readSecurityBuffer(byte[] src, int index) {
        int length = readUShort(src, index);
        int offset = readULong(src, index + 4);
        byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(byte[] dest, int offset, int ulong) {
        dest[offset] = (byte) (ulong & 0xff);

//      serialized representation of a `RunOptions` protocol buffer.
//    - `run_metadata` may be NULL, in which case it will be ignored; or
//      non-NULL, in which case it must point to an empty, freshly allocated
//      `TF_Buffer` that may be updated to contain the serialized representation
//      of a `RunMetadata` protocol buffer.
//
// The caller retains ownership of `input_values` (which can be deleted using

        }
        dstIndex += writeString( newFileName, dst, dstIndex );

        return dstIndex - start;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    int readBytesWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    public String toString() {
        return new String( "SmbComRename[" +
            super.toString() +

import assertk.assertions.isEqualTo
import okhttp3.internal.http2.hpackjson.HpackJsonUtil
import okhttp3.internal.http2.hpackjson.Story
import okio.Buffer

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {

      }

    fun body(body: Buffer) = body(body.toMockResponseBody())

    fun body(body: MockResponseBody) =
      apply {
        setHeader("Content-Length", body.contentLength)
        this.body = body
      }

    /** Sets the response body to the UTF-8 encoded bytes of [body]. */
    fun body(body: String): Builder = body(Buffer().writeUtf8(body))

            t = ( t + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601 ) * 10000L;
        }
        writeInt8(t, dst, dstIndex);
    }


    public static long readUTime ( byte[] buffer, int bufferIndex ) {
        return ( readInt4(buffer, bufferIndex) & 0xFFFFFFFFL ) * 1000L;
    }


    public static void writeUTime ( long t, byte[] dst, int dstIndex ) {
        writeInt4(t / 1000, dst, dstIndex);
    }

        }
        dstIndex += writeString( path, dst, dstIndex );

        return dstIndex - start;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    int readBytesWireFormat( byte[] buffer, int bufferIndex ) {
        return 0;
    }
    public String toString() {
        return new String( "SmbComOpenAndX[" +
            super.toString() +

	"io"
	"testing"
	"time"

	"github.com/tinylib/msgp/msgp"
)

func BenchmarkDecodeVolInfoMsgp(b *testing.B) {
	v := VolInfo{
		Name:    "uuid",
		Created: time.Now(),
	}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {

        MessageDigest md = MessageDigest.getInstance("SHA-1");
        try (InputStream fis = Files.newInputStream(path)) {
            byte[] buffer = new byte[SHA1_BUFFER_SIZE];
            int read;
            while ((read = fis.read(buffer)) != -1) {
                md.update(buffer, 0, read);
            }
        }
        StringBuilder result = new StringBuilder();
        for (byte b : md.digest()) {