// max will return NaN.
func max[T cmp.Ordered](x T, y ...T) T

// The min built-in function returns the smallest value of a fixed number of
// arguments of [cmp.Ordered] types. There must be at least one argument.
// If T is a floating-point type and any of the arguments are NaNs,
// min will return NaN.
func min[T cmp.Ordered](x T, y ...T) T

		var nf int // Bytes written in fragment
		dataStart, dataEnd := sw.sp[0].Offset, sw.sp[0].endOffset()
		if sw.pos < dataStart { // In a hole fragment
			bf := b[:min(int64(len(b)), dataStart-sw.pos)]
			nf, err = zeroWriter{}.Write(bf)
		} else { // In a data fragment
			bf := b[:min(int64(len(b)), dataEnd-sw.pos)]
			nf, err = sw.fw.Write(bf)
		}
		b = b[nf:]
		sw.pos += int64(nf)
		if sw.pos >= dataEnd && len(sw.sp) > 1 {

pkg syscall (netbsd-arm64-cgo), const ETHERMIN = 46
pkg syscall (netbsd-arm64-cgo), const ETHERMIN ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHER_MIN_LEN = 64
pkg syscall (netbsd-arm64-cgo), const ETHER_MIN_LEN ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERMTU = 1500
pkg syscall (netbsd-arm64-cgo), const ETHERMTU ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERMTU_JUMBO = 9000

var s []string
_ = min(s...)               // invalid: slice arguments are not permitted
t := max("", "foo", "bar")  // t == "foo" (string kind)
</pre>

<p>
For numeric arguments, assuming all NaNs are equal, <code>min</code> and <code>max</code> are
commutative and associative:
</p>

<pre>
min(x, y)    == min(y, x)
min(x, y, z) == min(min(x, y), z) == min(x, min(y, z))
</pre>

}
</pre>

<p>
A function declaration may omit the body. Such a declaration provides the
signature for a function implemented outside Go, such as an assembly routine.
</p>

<pre>
func min(x int, y int) int {
	if x &lt; y {
		return x
	}
	return y
}

func flushICache(begin, end uintptr)  // implemented externally
</pre>

<h3 id="Method_declarations">Method declarations</h3>

		part := &r.buf[i]
		return part.off+part.n > off
	})
	parts := r.buf[skipParts:]
	if len(parts) > 0 {
		skipBytes := off - parts[0].off
		for _, part := range parts {
			repeat := int(min(part.n-skipBytes, int64(len(p)-n)))
			memset(p[n:n+repeat], part.b)
			n += repeat
			if n == len(p) {
				return
			}
			skipBytes = 0
		}
	}
	if n != len(p) {
		err = io.ErrUnexpectedEOF
	}

pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
pkg syscall (freebsd-386), const DLT_MATCHING_MAX ideal-int
pkg syscall (freebsd-386), const DLT_MATCHING_MIN = 104
pkg syscall (freebsd-386), const DLT_MATCHING_MIN ideal-int
pkg syscall (freebsd-386), const DLT_MFR = 182
pkg syscall (freebsd-386), const DLT_MOST = 211
pkg syscall (freebsd-386), const DLT_MPLS = 219

	CTZ	X24, X25				// 931c1c60
	CTZW	X25, X26				// 1b9d1c60
	MAX	X26, X28, X29				// b36eae0b
	MAX	X26, X28				// 336eae0b
	MAXU	X28, X29, X30				// 33ffce0b
	MAXU	X28, X29				// b3fece0b
	MIN	X29, X30, X5				// b342df0b
	MIN	X29, X30				// 334fdf0b
	MINU	X30, X5, X6				// 33d3e20b
	MINU	X30, X5					// b3d2e20b
	ORN	X6, X7, X8				// 33e46340
	ORN	X6, X7					// b3e36340
	SEXTB	X16, X17				// 93184860

pkg slices, func Max[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
pkg slices, func MaxFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091
pkg slices, func Min[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
pkg slices, func MinFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091

pkg syscall (freebsd-386-cgo), const DLT_LOOP ideal-int
pkg syscall (freebsd-386-cgo), const DLT_LTALK ideal-int
pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX ideal-int
pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MIN ideal-int
pkg syscall (freebsd-386-cgo), const DLT_MFR ideal-int
pkg syscall (freebsd-386-cgo), const DLT_MOST ideal-int
pkg syscall (freebsd-386-cgo), const DLT_MPLS ideal-int