try (InputStreamReader reader = new InputStreamReader(byteSource.openStream(), cs)) {
            int nRead = 0;
            while (remaining > 0 && (nRead = reader.read(buffer, bufIndex, remaining)) != -1) {
              bufIndex += nRead;
              remaining -= nRead;
            }
            if (nRead == -1) {
              // we reached EOF
              return new String(buffer, 0, bufIndex);
            }

    }

    @Override
    public synchronized int read() throws IOException {
        if (read(tmp, 0, 1) < 0) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    @Override
    public synchronized int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /* This method will not return until len bytes have been read
     * or the stream has been closed.
     */

                        break;
                    case '\'':
                        out.append('\'');
                        break;
                    case '\"':
                        out.append('"');
                        break;
                    case 'r':
                        out.append('\r');
                        break;
                    case 'f':

                        break;
                    case '\'':
                        out.append('\'');
                        break;
                    case '\"':
                        out.append('"');
                        break;
                    case 'r':
                        out.append('\r');
                        break;
                    case 'f':

	recordDelimiter []byte
	oneByte         []byte
	useOneByte      bool
}

func (rr *recordTransform) Read(p []byte) (n int, err error) {
	if rr.useOneByte {
		p[0] = rr.oneByte[0]
		rr.useOneByte = false
		n, err = rr.reader.Read(p[1:])
		n++
	} else {
		n, err = rr.reader.Read(p)
	}

	if err != nil {
		return n, err
	}

	// Do nothing if record-delimiter is already newline.

        while (!eol) {
            switch (c = read()) {
            case -1:
            case '\n':
                eol = true;
                break;
            case '\r':
                eol = true;
                final long cur = fp;
                if (read() != '\n') {
                    fp = cur;
                }
                break;
            default:
                input.append((char) c);

            else -> source.read(sink, limit)
          }
        }
      }

      override fun timeout(): Timeout = timeout
    }

    /**
     * Returns a value in [0..maxByteCount] with the number of bytes that can be read from [source]
     * in the current part. If this returns 0 the current part is exhausted; otherwise it has at
     * least one byte left to read.
     */

scan:
	for {
		offset := d.pos - 1

		// read string key
		if c != '"' {
			err = d.mkError(ErrSyntax, "looking for beginning of object key string")
			break
		}
		if k, err = d.string(); err != nil {
			break
		}

		// read colon before value
		if c = d.skipSpaces(); c != ':' {
			err = d.mkError(ErrSyntax, "after object key")
			break
		}

		// read value
		d.skipSpaces()
		if d.emitKV {

	"bytes"
	"fmt"
	"io"
	"net/http"
	"strings"
)

// newUnsignedV4ChunkedReader returns a new s3UnsignedChunkedReader that translates the data read from r
// out of HTTP "chunked" format before returning it.
// The s3ChunkedReader returns io.EOF when the final 0-length chunk is read.
func newUnsignedV4ChunkedReader(req *http.Request, trailer bool, signature bool) (io.ReadCloser, APIErrorCode) {
	if signature {

    /**
     * Reads exactly len bytes from the input stream into the buffer.
     *
     * @param in the input stream to read from
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the number of bytes to read
     * @return the number of bytes actually read
     * @throws IOException if an I/O error occurs
     */