// 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 EADDRINUSE = 48
pkg syscall (netbsd-arm64-cgo), const EADDRNOTAVAIL = 49
pkg syscall (netbsd-arm64-cgo), const EAFNOSUPPORT = 47
pkg syscall (netbsd-arm64-cgo), const EAGAIN = 35
pkg syscall (netbsd-arm64-cgo), const EALREADY = 37
pkg syscall (netbsd-arm64-cgo), const EAUTH = 80
pkg syscall (netbsd-arm64-cgo), const EAUTH Errno
pkg syscall (netbsd-arm64-cgo), const EBADF = 9

	tok := in.Stack.Next()
	if tok != scanner.Ident {
		in.expectText("expected identifier after '#'")
	}
	if !in.enabled() {
		// Can only start including again if we are at #else or #endif but also
		// need to keep track of nested #if[n]defs.
		// We let #line through because it might affect errors.
		switch in.Stack.Text() {
		case "else", "endif", "ifdef", "ifndef", "line":

pkg syscall (darwin-386), const EACCES = 13
pkg syscall (darwin-386), const EADDRINUSE = 48
pkg syscall (darwin-386), const EADDRNOTAVAIL = 49
pkg syscall (darwin-386), const EAFNOSUPPORT = 47
pkg syscall (darwin-386), const EAGAIN = 35
pkg syscall (darwin-386), const EALREADY = 37
pkg syscall (darwin-386), const EAUTH = 80
pkg syscall (darwin-386), const EBADARCH = 86
pkg syscall (darwin-386), const EBADEXEC = 85

	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