val buffer = Buffer()
    operator.read(6, buffer, 21)
    operator.read(36, buffer, 1)
    operator.read(5, buffer, 5)
    operator.read(28, buffer, 8)
    operator.read(17, buffer, 10)
    operator.read(36, buffer, 2)
    operator.read(2, buffer, 4)
    operator.write(0, buffer, buffer.size)
    operator.read(0, buffer, 12)
    operator.read(47, buffer, 3)
    operator.read(45, buffer, 2)
    operator.read(47, buffer, 3)

                    buffer = new short[_buffers];
                }
                _src = _src.derive(_bufferi);
                for (int _i = 0; _i < _bufferl; _i++) {
                    buffer[_i] = (short)_src.dec_ndr_short();
                }
            }
        }
    }
    public static class sid_t extends NdrObject {

            bufferIndex += 2;
            flags = readInt2( buffer, bufferIndex );
            bufferIndex += 2;
            if( version == 3 ) {
                proximity = readInt2( buffer, bufferIndex );
                bufferIndex += 2;
                ttl = readInt2( buffer, bufferIndex );
                bufferIndex += 2;
                pathOffset = readInt2( buffer, bufferIndex );

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }

        bufferIndex += 8;

        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.fileAttributes = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        bufferIndex += 4; // Reserved2

        bufferIndex++;
        this.type = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        int ownerUOffset = SMBUtil.readInt4(buffer, bufferIndex); // offset to owner sid
        bufferIndex += 4;
        int ownerGOffset = SMBUtil.readInt4(buffer, bufferIndex); // offset to group sid
        bufferIndex += 4;
        SMBUtil.readInt4(buffer, bufferIndex); // offset to sacl
        bufferIndex += 4;

    }
    public SecurityDescriptor(byte[] buffer, int bufferIndex, int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }
    public int decode(byte[] buffer, int bufferIndex, int len) throws IOException {
        int start = bufferIndex;

        bufferIndex++; // revision
        bufferIndex++;
        type = ServerMessageBlock.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

import okhttp3.logging.internal.isProbablyUtf8
import okio.Buffer
import org.junit.jupiter.api.Test

class IsProbablyUtf8Test {
  @Test fun isProbablyUtf8() {
    assertThat(Buffer().isProbablyUtf8()).isTrue()
    assertThat(Buffer().writeUtf8("abc").isProbablyUtf8()).isTrue()
    assertThat(Buffer().writeUtf8("new\r\nlines").isProbablyUtf8()).isTrue()
    assertThat(Buffer().writeUtf8("white\t space").isProbablyUtf8()).isTrue()

        val read = delegate.read(buffer, byteCount)
        if (read != -1L) {
          sink.write(buffer.readByteString().toAsciiUppercase())
        }
        return read
      }
    }
  }

    if (readBuffer.remaining() <= buffer.remaining()) {
      buffer.put(readBuffer);
      munchIfFull();
      return this;
    }

    // First add just enough to fill buffer size, and munch that
    int bytesToCopy = bufferSize - buffer.position();
    for (int i = 0; i < bytesToCopy; i++) {
      buffer.put(readBuffer.get());
    }
    munch(); // buffer becomes empty here, since chunkSize divides bufferSize