val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

    val command = fromSource.readByte() and 0xff

    val reserved = fromSource.readByte() and 0xff
    if (reserved != 0) throw ProtocolException("unexpected reserved: $reserved")

    val addressType = fromSource.readByte() and 0xff
    val toAddress =
      when (addressType) {

    // Section prefix.
    sectionIndexBuffer.writeByte(section and 0x1fc000 shr 14)
    sectionIndexBuffer.writeByte((section and 0x3f80) shr 7)

    // Section index.
    sectionIndexBuffer.writeByte((sectionOffset and 0x3f80) shr 7)
    sectionIndexBuffer.writeByte(sectionOffset and 0x7f)

    // Ranges.
    for (range in sectionMappedRanges) {
      rangesBuffer.writeByte(range.rangeStart)

                this.negotiatedFlags2 |= SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
            }
        }
        else {
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_SIGNATURES;
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
        }

        if ( log.isDebugEnabled() ) {
            log.debug(

  static int load32(byte[] source, int offset) {
    // TODO(user): Measure the benefit of delegating this to LittleEndianBytes also.
    return (source[offset] & 0xFF)
        | ((source[offset + 1] & 0xFF) << 8)
        | ((source[offset + 2] & 0xFF) << 16)
        | ((source[offset + 3] & 0xFF) << 24);
  }

  /**
   * Indicates that the loading of Unsafe was successful and the load and store operations will be

                dst[dstIndex + ( 2 * i + 2 )] = (byte)(( tmp[i] & 0x0F ) + 0x41 );
            }
            for( ; i < 15; i++ ) {
                dst[dstIndex + ( 2 * i + 1 )] = (byte)0x43;
                dst[dstIndex + ( 2 * i + 2 )] = (byte)0x41;
            }
            dst[dstIndex + TYPE_OFFSET] = (byte)((( hexCode & 0xF0 ) >> 4 ) + 0x41 );

            tmp[ i ] |= (byte) ( ( ( src[ srcIndex + ( 2 * i + 2 ) ] & 0xFF ) - 0x41 ) & 0x0F );
            if ( tmp[ i ] != (byte) ' ' ) {
                length = i + 1;
            }
        }
        this.name = Strings.fromOEMBytes(tmp, 0, length, this.config);
        this.hexCode = ( ( src[ srcIndex + TYPE_OFFSET ] & 0xFF ) - 0x41 ) << 4;

        return ( src[ srcIndex ] & 0xFF ) + ( ( src[ srcIndex + 1 ] & 0xFF ) << 8 );
    }


    public static int readInt4 ( byte[] src, int srcIndex ) {
        return ( src[ srcIndex ] & 0xFF ) + ( ( src[ srcIndex + 1 ] & 0xFF ) << 8 ) + ( ( src[ srcIndex + 2 ] & 0xFF ) << 16 )
                + ( ( src[ srcIndex + 3 ] & 0xFF ) << 24 );
    }

            bufferIndex += 16;
            e.versionMajor = buffer[ bufferIndex++ ] & 0xFF;
            e.versionMinor = buffer[ bufferIndex++ ] & 0xFF;
            e.type = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            int off = SMBUtil.readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = ( off & 0xFFFF ) - this.converter;
            off = start + off;

		{"117Gn8rfHL2ACARPAhaFd0AGzic9pUbIA/5OCn5A", 35},
		{"SHØRT", 49},
		{"There are far too many object names, and far too few bucket names!", 8},
		{"a/b/c/", 159},
		{"/a/b/c", 96},
		{string([]byte{0xff, 0xfe, 0xfd}), 147},
	}

	// Tests hashing order to be consistent.
	for i, testCase := range testCases {
		if sipHashElement := hashKey("SIPMOD", testCase.objectName, 200, testUUID); sipHashElement != testCase.sipHash {

        key8[ 0 ] = (byte) ( key[ 0 ] & 0xFE );
        key8[ 1 ] = (byte) ( ( key[ 0 ] << 7 ) | ( ( key[ 1 ] & 0xFF ) >>> 1 ) );
        key8[ 2 ] = (byte) ( ( key[ 1 ] << 6 ) | ( ( key[ 2 ] & 0xFF ) >>> 2 ) );
        key8[ 3 ] = (byte) ( ( key[ 2 ] << 5 ) | ( ( key[ 3 ] & 0xFF ) >>> 3 ) );
        key8[ 4 ] = (byte) ( ( key[ 3 ] << 4 ) | ( ( key[ 4 ] & 0xFF ) >>> 4 ) );