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

	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
	}

		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) {

	buf []repeatedByte
}

func (r *rleBuffer) Size() int64 {
	if len(r.buf) == 0 {
		return 0
	}
	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 {

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

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

}

var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read")

// UnreadByte unreads the last byte returned by the most recent successful
// read operation that read at least one byte. If a write has happened since
// the last read, if the last read returned an error, or if the read read zero
// bytes, UnreadByte returns an error.
func (b *Buffer) UnreadByte() error {

	// These are ordered and grouped to match ../../go/ast/ast.go
	case *ast.Field:
		if len(n.Names) == 0 && context == ctxField {
			f.walk(&n.Type, ctxEmbedType, visit)
		} else {
			f.walk(&n.Type, ctxType, visit)
		}
	case *ast.FieldList:
		for _, field := range n.List {
			f.walk(field, context, visit)
		}
	case *ast.BadExpr:
	case *ast.Ident:
	case *ast.Ellipsis:
		f.walk(&n.Elt, ctxType, visit)

}

func funcTypeTypeParams(n *ast.FuncType) *ast.FieldList {
	return n.TypeParams
}

func typeSpecTypeParams(n *ast.TypeSpec) *ast.FieldList {
	return n.TypeParams

error message, but this package reserves the right to not force a fault on
freed memory. That means a valid implementation of this package is to just
allocate all memory the way the runtime normally would, and in fact, it
reserves the right to occasionally do so for some Go values.
*/
package arena

import (
	"internal/reflectlite"
	"unsafe"
)

// Arena represents a collection of Go values allocated and freed together.