*/
    public static String create() {
        final StringBuilder buf = new StringBuilder(BASE.length() * 2);
        buf.append(BASE);
        final int lowTime = (int) (System.currentTimeMillis() >> 32);
        StringUtil.appendHex(buf, lowTime);
        StringUtil.appendHex(buf, RANDOM.nextInt());
        return buf.toString();
    }

    private static byte[] getAddress() {
        try {

        Trans2GetDfsReferral cmd = new Trans2GetDfsReferral("foo");
        byte[] buf = new byte[2];
        int r = cmd.writeSetupWireFormat(buf, 0);
        assertEquals(2, r);
        byte subCmd = (byte) getPrivateField(cmd, "subCommand");
        assertEquals(subCmd, buf[0]);
        assertEquals((byte) 0x00, buf[1]);
    }

    @Test
    @DisplayName("writeParametersWireFormat writes referral level and path")

    OLD {
      @Override
      long copy(Readable from, Appendable to) throws IOException {
        CharBuffer buf = CharStreams.createBuffer();
        long total = 0;
        while (from.read(buf) != -1) {
          ((Buffer) buf).flip();
          to.append(buf);
          total += buf.remaining();
          ((Buffer) buf).clear();
        }
        return total;
      }
    },
    NEW {
      @Override

				}
			})
			b.Run("ToFileInfoNew", func(b *testing.B) {
				b.SetBytes(int64(size))
				b.ResetTimer()
				b.ReportAllocs()
				for b.Loop() {
					buf, _, _ := isIndexedMetaV2(enc)
					if buf == nil {
						b.Fatal("buf == nil")
					}
					_, err = buf.ToFileInfo("volume", "path", ids[rng.Intn(size)], true)
					if err != nil {
						b.Fatal(err)
					}
				}
			})

		// Comma to separate argument gets a space; comma within does not.
		var buf []byte
		nest := 0
		for i := 0; i < len(printed); i++ {
			c := printed[i]
			switch c {
			case '{', '[':
				nest++
			case '}', ']':
				nest--
			case ',':
				buf = append(buf, ',')
				if nest == 0 {
					buf = append(buf, ' ')
				}
				for i+1 < len(printed) && (printed[i+1] == ' ' || printed[i+1] == '\t') {

}

// AppendFile - append to a file.
func (client *storageRESTClient) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	values.Set(storageRESTFilePath, path)
	reader := bytes.NewReader(buf)
	respBody, err := client.call(ctx, storageRESTMethodAppendFile, values, reader, -1)
	defer xhttp.DrainBody(respBody)
	return err
}

)

var IsSpace = isSpace

const DefaultBufSize = defaultBufSize

func (s *Scanner) MaxTokenSize(n int) {
	if n < utf8.UTFMax || n > 1e9 {
		panic("bad max token size")
	}
	if n < len(s.buf) {
		s.buf = make([]byte, n)
	}
	s.maxTokenSize = n
}

// ErrOrEOF is like Err, but returns EOF. Used to test a corner case.
func (s *Scanner) ErrOrEOF() error {
	return s.err

64-bit integers. func ctrBlocks(b *Block, dst, src []byte, ivlo, ivhi uint64) { buf := make([]byte, len(src), 8*BlockSize) for i := 0; i < len(buf); i += BlockSize { byteorder.BEPutUint64(buf[i:], ivhi) byteorder.BEPutUint64(buf[i+8:], ivlo) ivlo, ivhi = add128(ivlo, ivhi, 1) encryptBlock(b, buf[i:], buf[i:]) } // XOR into buf first, in case src and dst overlap (see above). subtle.XORBytes(buf, src, buf) copy(dst, buf) } func add128(lo, hi uint64, x uint64) (uint64, uint64) { lo, c := bits.Add64(lo,...

        }
        char[] buf = new char[bufferSize];
        int size = 0;
        int len;
        try {
            while ((len = reader.read(buf, size, bufferSize - size)) != -1) {
                size += len;
                if (size == bufferSize) {
                    final char[] newBuf = new char[bufferSize + initialCapacity];
                    System.arraycopy(buf, 0, newBuf, 0, bufferSize);

    // SMB uses little-endian byte order
    private static void writeLong(byte[] buf, int offset, long val) {
        for (int i = 0; i < 8; i++) {
            buf[offset + i] = (byte) ((val >>> (8 * i)) & 0xFF);
        }
    }

    private static void writeShort(byte[] buf, int offset, int val) {
        buf[offset] = (byte) (val & 0xFF);
        buf[offset + 1] = (byte) ((val >>> 8) & 0xFF);
    }

    @Test