// We are starting so many processes that on
			// some systems (problem seen on Darwin,
			// Dragonfly, OpenBSD) the fork call will fail
			// with EAGAIN.
			if pe, ok := err.(*os.PathError); ok {
				err = pe.Err
			}
			if se, ok := err.(syscall.Errno); ok && (se == syscall.EAGAIN || se == syscall.EMFILE) {
				time.Sleep(time.Millisecond)
				continue
			}

			t.Error(err)
			return
		}

						this._scheduledTimeouts.set(id, setTimeout(
							() => {
								this._resume();
								while (this._scheduledTimeouts.has(id)) {
									// for some reason Go failed to register the timeout event, log and try again
									// (temporary workaround for https://github.com/golang/go/issues/28975)
									console.warn("scheduleTimeoutEvent: missed timeout event");
									this._resume();
								}
							},

and it may store non-pointer data, C pointers, or Go pointers to pinned
memory through those pointers. It may not store a Go pointer to unpinned
memory in memory pointed to by a C pointer (which again, implies that it
may not store a string, slice, channel, and so forth). A Go function
called by C code may take a Go pointer but it must preserve the property
that the Go memory to which it points (and the Go memory to which that

	for {
		r1, _, err := r.ReadRune()
		if err != nil {
			if err != io.EOF {
				t.Error("unexpected error on ReadRune:", err)
			}
			break
		}
		got += string(r1)
		// Put it back and read it again.
		if err = r.UnreadRune(); err != nil {
			t.Fatal("unexpected error on UnreadRune:", err)
		}
		r2, _, err := r.ReadRune()
		if err != nil {
			t.Fatal("unexpected error reading after unreading:", err)
		}

pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VALID = 5632
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VALID ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VARIAN = 32989
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VARIAN ideal-int
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VAXELN = 32827
pkg syscall (netbsd-arm64-cgo), const ETHERTYPE_VAXELN ideal-int

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>

<p>
A method is a <a href="#Function_declarations">function</a> with a <i>receiver</i>.

	VMOV	V10.S[0], V12.S[1]    // 4c050c6e
	VMOV	V9.H[0], V12.H[1]     // 2c05066e
	VMOV	V8.B[0], V12.B[1]     // 0c05036e
	VMOV	V8.B[7], V4.B[8]      // 043d116e

// CBZ
again:
	CBZ	R1, again // CBZ R1

// conditional operations
	CSET	GT, R1	        // e1d79f9a
	CSETW	HI, R2	        // e2979f1a
	CSEL	LT, R1, R2, ZR	// 3fb0829a
	CSELW	LT, R2, R3, R4	// 44b0831a

	// to _cgoCheckPointer, as done in checkIndex and checkAddr.
	//
	// When the function argument is a conversion to unsafe.Pointer,
	// we unwrap the conversion before checking the pointer,
	// and then wrap again when calling C.f. This lets us check
	// the real type of the pointer in some cases. See issue #25941.
	//
	// When the call to C.f is deferred, we use an additional function

pkg syscall (darwin-arm64), const EADDRINUSE = 48
pkg syscall (darwin-arm64), const EADDRNOTAVAIL = 49
pkg syscall (darwin-arm64), const EAFNOSUPPORT = 47
pkg syscall (darwin-arm64), const EAGAIN = 35
pkg syscall (darwin-arm64), const EALREADY = 37
pkg syscall (darwin-arm64), const EAUTH = 80
pkg syscall (darwin-arm64), const EAUTH Errno
pkg syscall (darwin-arm64), const EBADARCH = 86

pkg syscall (freebsd-arm64), const EADDRINUSE = 48
pkg syscall (freebsd-arm64), const EADDRNOTAVAIL = 49
pkg syscall (freebsd-arm64), const EAFNOSUPPORT = 47
pkg syscall (freebsd-arm64), const EAGAIN = 35
pkg syscall (freebsd-arm64), const EALREADY = 37
pkg syscall (freebsd-arm64), const EAUTH = 80
pkg syscall (freebsd-arm64), const EAUTH Errno
pkg syscall (freebsd-arm64), const EBADF = 9