"runtime.wasmExit": (sp) => {
						sp >>>= 0;
						const code = this.mem.getInt32(sp + 8, true);
						this.exited = true;
						delete this._inst;
						delete this._values;
						delete this._goRefCounts;
						delete this._ids;
						delete this._idPool;
						this.exit(code);
					},

					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
					"runtime.wasmWrite": (sp) => {

gohostos="$(../bin/go env GOHOSTOS)"
gohostarch="$(../bin/go env GOHOSTARCH)"
goos="$(../bin/go env GOOS)"
goarch="$(../bin/go env GOARCH)"

# NOTE: Cannot invoke go command after this point.
# We're about to delete all but the cross-compiled binaries.
cd ..
if [ "$goos" = "$gohostos" -a "$goarch" = "$gohostarch" ]; then
	# cross-compile for local system. nothing to copy.
	# useful if you've bootstrapped yourself but want to

		for _, feature := range wanted {
			if feature == "" {
				continue
			}
			_, ok := w.features[feature]
			if !ok {
				t.Errorf("package %s: missing feature %q", fi.Name(), feature)
			}
			delete(w.features, feature)
		}

		for _, feature := range w.Features() {
			t.Errorf("package %s: extra feature not in golden file: %q", fi.Name(), feature)
		}
	}
}

func TestCompareAPI(t *testing.T) {

<p>
The built-in function <code>delete</code> removes the element with key
<code>k</code> from a <a href="#Map_types">map</a> <code>m</code>. The
type of <code>k</code> must be <a href="#Assignability">assignable</a>
to the key type of <code>m</code>.
</p>

<pre class="grammar">
delete(m, k)  // remove element m[k] from map m
</pre>

<p>

	// Pass the address of i because the C function was written to
	// take a pointer.  We could pass an int if we felt like
	// rewriting the C code.
	C.callback(unsafe.Pointer(&i))

	callbackMutex.Lock()
	delete(callbackFuncs, i)
	callbackMutex.Unlock()
}

//export goCallback
func goCallback(p unsafe.Pointer) {
	i := *(*int)(p)

	callbackMutex.Lock()
	f := callbackFuncs[i]
	callbackMutex.Unlock()

pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_FD = 352
pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_FD ideal-int
pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_FILE = 351
pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_FILE ideal-int
pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_LINK = 427
pkg syscall (freebsd-arm64), const SYS___ACL_DELETE_LINK ideal-int

pkg syscall (darwin-arm64), const EV_ADD ideal-int
pkg syscall (darwin-arm64), const EV_CLEAR = 32
pkg syscall (darwin-arm64), const EV_CLEAR ideal-int
pkg syscall (darwin-arm64), const EV_DELETE = 2
pkg syscall (darwin-arm64), const EV_DELETE ideal-int
pkg syscall (darwin-arm64), const EV_DISABLE = 8
pkg syscall (darwin-arm64), const EV_DISABLE ideal-int
pkg syscall (darwin-arm64), const EV_DISPATCH = 128

		}
	}

	// Remove functions only used as expressions, so their respective
	// bridge functions are not generated.
	for name, used := range functions {
		if !used {
			delete(f.Name, name)
		}
	}
}

// rewriteName returns the expression used to rewrite a reference.
// If addPosition is true, add position info in the ident name.

	// Pseudo-registers.
	register["SB"] = RSB
	register["FP"] = RFP
	register["PC"] = RPC
	// Avoid unintentionally clobbering g using R30.
	delete(register, "R30")
	register["g"] = mips.REG_R30
	// Avoid unintentionally clobbering RSB using R28.
	delete(register, "R28")
	register["RSB"] = mips.REG_R28
	registerPrefix := map[string]bool{
		"F":   true,
		"FCR": true,
		"M":   true,
		"R":   true,

pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_FD = 352 #53466
pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_FD ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_FILE = 351 #53466
pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_FILE ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_LINK = 427 #53466
pkg syscall (freebsd-riscv64), const SYS___ACL_DELETE_LINK ideal-int #53466