b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		bb.Reset()
		b := bb.AvailableBuffer()
		b = b[:cap(b)] // use max capacity to simulate a large append operation
		bb.Write(b)    // should be nearly infinitely fast
	}

pkg syscall (netbsd-arm64-cgo), const IFT_FAST = 125
pkg syscall (netbsd-arm64-cgo), const IFT_FASTETHER = 62
pkg syscall (netbsd-arm64-cgo), const IFT_FASTETHERFX = 69
pkg syscall (netbsd-arm64-cgo), const IFT_FASTETHERFX ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_FASTETHER ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_FAST ideal-int
pkg syscall (netbsd-arm64-cgo), const IFT_FDDI = 15

pkg syscall (freebsd-arm64), const BPF_T_BINTIME_FAST = 258
pkg syscall (freebsd-arm64), const BPF_T_BINTIME_FAST ideal-int
pkg syscall (freebsd-arm64), const BPF_T_BINTIME_MONOTONIC = 514
pkg syscall (freebsd-arm64), const BPF_T_BINTIME_MONOTONIC ideal-int
pkg syscall (freebsd-arm64), const BPF_T_BINTIME_MONOTONIC_FAST = 770
pkg syscall (freebsd-arm64), const BPF_T_BINTIME_MONOTONIC_FAST ideal-int

// Reset is the same as [Buffer.Truncate](0).
func (b *Buffer) Reset() {
	b.buf = b.buf[:0]
	b.off = 0
	b.lastRead = opInvalid
}

// tryGrowByReslice is an inlineable version of grow for the fast-case where the
// internal buffer only needs to be resliced.
// It returns the index where bytes should be written and whether it succeeded.
func (b *Buffer) tryGrowByReslice(n int) (int, bool) {

func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if atEOF && len(data) == 0 {
		return 0, nil, nil
	}

	// Fast path 1: ASCII.
	if data[0] < utf8.RuneSelf {
		return 1, data[0:1], nil
	}

	// Fast path 2: Correct UTF-8 decode without error.
	_, width := utf8.DecodeRune(data)
	if width > 1 {
		// It's a valid encoding. Width cannot be one for a correctly encoded

pkg syscall (freebsd-386), const IFT_ESCON ideal-int
pkg syscall (freebsd-386), const IFT_ETHER ideal-int
pkg syscall (freebsd-386), const IFT_FAITH ideal-int
pkg syscall (freebsd-386), const IFT_FAST ideal-int
pkg syscall (freebsd-386), const IFT_FASTETHER ideal-int
pkg syscall (freebsd-386), const IFT_FASTETHERFX ideal-int
pkg syscall (freebsd-386), const IFT_FDDI ideal-int

pkg syscall (freebsd-riscv64), const BPF_T_NANOTIME_FAST ideal-int #53466
pkg syscall (freebsd-riscv64), const BPF_T_NANOTIME_MONOTONIC = 513 #53466
pkg syscall (freebsd-riscv64), const BPF_T_NANOTIME_MONOTONIC ideal-int #53466
pkg syscall (freebsd-riscv64), const BPF_T_NANOTIME_MONOTONIC_FAST = 769 #53466
pkg syscall (freebsd-riscv64), const BPF_T_NANOTIME_MONOTONIC_FAST ideal-int #53466

		n += wasSpace & ^isSpace
		wasSpace = isSpace
	}

	if setBits >= utf8.RuneSelf {
		// Some runes in the input slice are not ASCII.
		return FieldsFunc(s, unicode.IsSpace)
	}

	// ASCII fast path
	a := make([][]byte, n)
	na := 0
	fieldStart := 0
	i := 0
	// Skip spaces in the front of the input.
	for i < len(s) && asciiSpace[s[i]] != 0 {
		i++
	}
	fieldStart = i
	for i < len(s) {

	}
	last := &r.buf[len(r.buf)-1]
	return last.off + last.n
}

func (r *rleBuffer) Write(p []byte) (n int, err error) {
	var rp *repeatedByte
	if len(r.buf) > 0 {
		rp = &r.buf[len(r.buf)-1]
		// Fast path, if p is entirely the same byte repeated.
		if lastByte := rp.b; len(p) > 0 && p[0] == lastByte {
			if bytes.Count(p, []byte{lastByte}) == len(p) {
				rp.n += int64(len(p))
				return len(p), nil
			}
		}

pkg syscall (freebsd-386), const BPF_T_BINTIME_FAST = 258
pkg syscall (freebsd-386), const BPF_T_BINTIME_FAST ideal-int
pkg syscall (freebsd-386), const BPF_T_BINTIME_MONOTONIC = 514
pkg syscall (freebsd-386), const BPF_T_BINTIME_MONOTONIC ideal-int
pkg syscall (freebsd-386), const BPF_T_BINTIME_MONOTONIC_FAST = 770
pkg syscall (freebsd-386), const BPF_T_BINTIME_MONOTONIC_FAST ideal-int
pkg syscall (freebsd-386), const BPF_T_FAST = 256