}

func ExampleCompare() {
	// Interpret Compare's result by comparing it to zero.
	var a, b []byte
	if bytes.Compare(a, b) < 0 {
		// a less b
	}
	if bytes.Compare(a, b) <= 0 {
		// a less or equal b
	}
	if bytes.Compare(a, b) > 0 {
		// a greater b
	}
	if bytes.Compare(a, b) >= 0 {
		// a greater or equal b
	}

	// Prefer Equal to Compare for equality comparisons.
	if bytes.Equal(a, b) {

// included to match [bufio.Writer]'s WriteRune. The buffer is grown as needed;
// if it becomes too large, WriteRune will panic with [ErrTooLarge].
func (b *Buffer) WriteRune(r rune) (n int, err error) {
	// Compare as uint32 to correctly handle negative runes.
	if uint32(r) < utf8.RuneSelf {
		b.WriteByte(byte(r))
		return 1, nil
	}
	b.lastRead = opInvalid
	m, ok := b.tryGrowByReslice(utf8.UTFMax)
	if !ok {

pkg slices, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0 #57433
pkg slices, func Compact[$0 interface{ ~[]$1 }, $1 comparable]($0) $0 #57433
pkg slices, func CompactFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) bool) $0 #57433
pkg slices, func Compare[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0, $0) int #60091

pkg encoding/hex, func EncodedLen(int) int
pkg encoding/hex, method (InvalidByteError) Error() string
pkg encoding/hex, type InvalidByteError uint8
pkg encoding/hex, var ErrLength error
pkg encoding/json, func Compact(*bytes.Buffer, []uint8) error
pkg encoding/json, func HTMLEscape(*bytes.Buffer, []uint8)
pkg encoding/json, func Indent(*bytes.Buffer, []uint8, string, string) error
pkg encoding/json, func Marshal(interface{}) ([]uint8, error)

pkg syscall (freebsd-arm64), const MSG_CMSG_CLOEXEC = 262144
pkg syscall (freebsd-arm64), const MSG_CMSG_CLOEXEC ideal-int
pkg syscall (freebsd-arm64), const MSG_COMPAT = 32768
pkg syscall (freebsd-arm64), const MSG_COMPAT ideal-int
pkg syscall (freebsd-arm64), const MSG_CTRUNC = 32
pkg syscall (freebsd-arm64), const MSG_CTRUNC ideal-int
pkg syscall (freebsd-arm64), const MSG_DONTROUTE = 4

			break
		}
		if err != nil {
			return err
		}
		f.headerOffset += r.baseOffset
		r.File = append(r.File, f)
	}
	if uint16(len(r.File)) != uint16(end.directoryRecords) { // only compare 16 bits here
		// Return the readDirectoryHeader error if we read
		// the wrong number of directory entries.
		return err
	}
	if zipinsecurepath.Value() == "0" {
		for _, f := range r.File {

connecting to servers with buggy HTTP/2 implementations.
These kinds of changes are unavoidable and
[permitted by the Go 1 compatibility rules](/doc/go1compat).
Even so, Go provides a mechanism called GODEBUG to
reduce the impact such changes have on Go developers
using newer toolchains to compile old code.

A GODEBUG setting is a `key=value` pair
that controls the execution of certain parts of a Go program.
The environment variable `GODEBUG`

pkg syscall (freebsd-riscv64), const MSG_CMSG_CLOEXEC = 262144 #53466
pkg syscall (freebsd-riscv64), const MSG_CMSG_CLOEXEC ideal-int #53466
pkg syscall (freebsd-riscv64), const MSG_COMPAT = 32768 #53466
pkg syscall (freebsd-riscv64), const MSG_COMPAT ideal-int #53466
pkg syscall (freebsd-riscv64), const MSG_CTRUNC = 32 #53466
pkg syscall (freebsd-riscv64), const MSG_CTRUNC ideal-int #53466

			for i := 0; i < n; i++ {
				x[i] = 'a'
			}

			for i := 0; i < n; i++ {
				y[i] = 'a'
			}

			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				Compare(x, y)
			}
		})
	}
}

func BenchmarkIndexAnyASCII(b *testing.B) {
	x := Repeat([]byte{'#'}, 2048) // Never matches set

support for concurrent programming.  Programs are constructed from
<i>packages</i>, whose properties allow efficient management of
dependencies.
</p>

<p>
The syntax is compact and simple to parse, allowing for easy analysis
by automatic tools such as integrated development environments.
</p>

<h2 id="Notation">Notation</h2>
<p>
The syntax is specified using a