//	unbuffered.
func make(t Type, size ...IntegerType) Type

// The max built-in function returns the largest 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,
// 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

static void*
goDummyCallbackThread(void* p)
{
	int i, max;

	max = *(int*)p;
	for(i=0; i<max; i++)
		goDummy();
	return NULL;
}

int
callGoInCThread(int max)
{
	pthread_t thread;

	if (pthread_create(&thread, NULL, goDummyCallbackThread, (void*)(&max)) != 0)
		return -1;
	if (pthread_join(thread, NULL) != 0)
		return -1;

	return max;

pkg syscall (freebsd-386), const IP_MAXPACKET = 65535
pkg syscall (freebsd-386), const IP_MAX_GROUP_SRC_FILTER = 512
pkg syscall (freebsd-386), const IP_MAX_MEMBERSHIPS = 4095
pkg syscall (freebsd-386), const IP_MAX_SOCK_MUTE_FILTER = 128
pkg syscall (freebsd-386), const IP_MAX_SOCK_SRC_FILTER = 128
pkg syscall (freebsd-386), const IP_MAX_SOURCE_FILTER = 1024
pkg syscall (freebsd-386), const IP_MF = 8192

(and similarly for <code>max</code>).
If all arguments are constant, the result is constant.
</p>

<pre>
var x, y int
m := min(x)                 // m == x
m := min(x, y)              // m is the smaller of x and y
m := max(x, y, 10)          // m is the larger of x and y but at least 10
c := max(1, 2.0, 10)        // c == 10.0 (floating-point kind)
f := max(0, float32(x))     // type of f is float32

pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false
pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
pkg syscall (freebsd-386), const AF_MAX = 38
pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
pkg syscall (freebsd-386), const ELAST = 94
pkg syscall (freebsd-386), const ImplementsGetwd = false
pkg syscall (freebsd-386), const O_CLOEXEC = 0

}

// slowReader is a reader that returns only a few bytes at a time, to test the incremental
// reads in Scanner.Scan.
type slowReader struct {
	max int
	buf io.Reader
}

func (sr *slowReader) Read(p []byte) (n int, err error) {
	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

// genLine writes to buf a predictable but non-trivial line of text of length

pkg syscall (freebsd-386-cgo), const IP_MAX_GROUP_SRC_FILTER ideal-int
pkg syscall (freebsd-386-cgo), const IP_MAX_MEMBERSHIPS ideal-int
pkg syscall (freebsd-386-cgo), const IP_MAX_SOCK_MUTE_FILTER ideal-int
pkg syscall (freebsd-386-cgo), const IP_MAX_SOCK_SRC_FILTER ideal-int
pkg syscall (freebsd-386-cgo), const IP_MAX_SOURCE_FILTER ideal-int
pkg syscall (freebsd-386-cgo), const IP_MF ideal-int

		b.uint32(1)           // total number of disks

		if _, err := w.cw.Write(buf[:]); err != nil {
			return err
		}

		// store max values in the regular end record to signal
		// that the zip64 values should be used instead
		records = uint16max
		size = uint32max
		offset = uint32max
	}

	// write end record

	CLZ	X20, X21				// 931a0a60
	CLZW	X21, X22				// 1b9b0a60
	CPOP	X22, X23				// 931b2b60
	CPOPW	X23, X24				// 1b9c2b60
	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

func NewReaderSize(rd io.Reader, size int) *Reader {
	// Is it already a Reader?
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
		return b
	}
	r := new(Reader)
	r.reset(make([]byte, max(size, minReadBufferSize)), rd)
	return r
}

// NewReader returns a new [Reader] whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
	return NewReaderSize(rd, defaultBufSize)
}