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

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

}

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 {

}

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

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

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