Thai Nguyen <******@****.***> 1709597042 -0800

	n := uint16(b[0])<<8 + uint16(b[1])
	return n
}

func readStr(r io.Reader, b []byte) string {
	n := readU16BE(b)
	if int(n) > len(b) {
		return "err: n>b"
	}
	io.ReadFull(r, b[0:n]) // #2
	return string(b[0:n])  // #3
	return "ok"
}

func main() {
	br := strings.NewReader("abcd")
	readStr(br, make([]byte, 256))

		}
		g64 = slr.ReadULEB128()
		if g64 != e64 {
			t.Fatalf("slr.ReadULEB128() got %d want %d", g64, e64)
		}
		gs1 := readStr(slr)
		if gs1 != s1 {
			t.Fatalf("readStr got %s want %s", gs1, s1)
		}
		gs2 := readStr(slr)
		if gs2 != s2 {
			t.Fatalf("readStr got %s want %s", gs2, s2)
		}
		if _, err := slr.Seek(4, io.SeekStart); err != nil {
			t.Fatal(err)
		}
		off := slr.Offset()
		if off != 4 {

		bw.Close()
	}

	reader := newBitrotReader(disk, nil, volume, filePath, 35, bitrotAlgo, bitrotWriterSum(writer), 10)
	b := make([]byte, 10)
	if _, err = reader.ReadAt(b, 0); err != nil {
		t.Fatal(err)
	}
	if _, err = reader.ReadAt(b, 10); err != nil {
		t.Fatal(err)
	}
	if _, err = reader.ReadAt(b, 20); err != nil {
		t.Fatal(err)
	}
	if _, err = reader.ReadAt(b[:5], 30); err != nil {
		t.Fatal(err)
	}

// NewReaderSize returns a new [Reader] whose buffer has at least the specified
// size. If the argument io.Reader is already a [Reader] with large enough
// size, it returns the underlying [Reader].
func NewReaderSize(rd io.Reader, size int) *Reader {
	// Is it already a Reader?
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
		return b
	}
	r := new(Reader)
	r.reset(make([]byte, max(size, minReadBufferSize)), rd)

	return os.WriteFile(filename, data, perm)
}

// ReadDir reads the directory named by dirname and returns
// a list of fs.FileInfo for the directory's contents,
// sorted by filename. If an error occurs reading the directory,
// ReadDir returns no directory entries along with the error.
//
// Deprecated: As of Go 1.16, [os.ReadDir] is a more efficient and correct choice:

// ReadAt blocks until either all the data is available or an error occurs.
// In this respect ReadAt is different from Read.
//
// If the n = len(p) bytes returned by ReadAt are at the end of the
// input source, ReadAt may return either err == EOF or err == nil.
//
// If ReadAt is reading from an input source with a seek offset,
// ReadAt should not affect nor be affected by the underlying

	}
	if offset+length > totalLength {
		return -1, errInvalidArgument
	}

	if length == 0 {
		return 0, nil
	}

	reader := newParallelReader(readers, e, offset, totalLength)
	if len(prefer) == len(readers) {
		reader.preferReaders(prefer)
	}
	defer reader.Done()

	startBlock := offset / e.blockSize
	endBlock := (offset + length) / e.blockSize

	var bytesWritten int64
	var bufs [][]byte

			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &linkEditDataCmd{}, "DataOff")
		case LC_ENCRYPTION_INFO, LC_ENCRYPTION_INFO_64:
			err = machoUpdateLoadCommand(reader, linkseg, linkoffset, &encryptionInfoCmd{}, "CryptOff")
		case LC_UUID:
			var u uuidCmd
			err = reader.ReadAt(0, &u)
			if err == nil {
				copy(u.Uuid[:], uuidFromGoBuildId(*flagBuildid))
				err = reader.WriteAt(0, &u)
			}

				v <<= 8
				ndst++
			}
		}
	}
	return
}

// NewDecoder constructs a new ascii85 stream decoder.
func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }

type decoder struct {
	err     error
	readErr error
	r       io.Reader
	buf     [1024]byte // leftover input
	nbuf    int
	out     []byte // leftover decoded output
	outbuf  [1024]byte
}