// callback(x) calls goCallback(x)
	callbackMutex.Lock()
	callbackToken++
	i := callbackToken
	callbackFuncs[i] = f
	callbackMutex.Unlock()

	// 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()
}

of an interface type or of elements of a composite type remains unchanged:
</p>

<pre>
// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }

// NewMutex has the same composition as Mutex but its method set is empty.

	fw *flate.Writer
}

func (w *pooledFlateWriter) Write(p []byte) (n int, err error) {
	w.mu.Lock()
	defer w.mu.Unlock()
	if w.fw == nil {
		return 0, errors.New("Write after Close")
	}
	return w.fw.Write(p)
}

func (w *pooledFlateWriter) Close() error {
	w.mu.Lock()
	defer w.mu.Unlock()
	var err error
	if w.fw != nil {
		err = w.fw.Close()
		flateWriterPool.Put(w.fw)
		w.fw = nil

pkg syscall (freebsd-arm64), const LOCK_EX = 2
pkg syscall (freebsd-arm64), const LOCK_EX ideal-int
pkg syscall (freebsd-arm64), const LOCK_NB = 4
pkg syscall (freebsd-arm64), const LOCK_NB ideal-int
pkg syscall (freebsd-arm64), const LOCK_SH = 1
pkg syscall (freebsd-arm64), const LOCK_SH ideal-int
pkg syscall (freebsd-arm64), const LOCK_UN = 8
pkg syscall (freebsd-arm64), const LOCK_UN ideal-int

pkg syscall (darwin-arm64), const LOCK_EX = 2
pkg syscall (darwin-arm64), const LOCK_EX ideal-int
pkg syscall (darwin-arm64), const LOCK_NB = 4
pkg syscall (darwin-arm64), const LOCK_NB ideal-int
pkg syscall (darwin-arm64), const LOCK_SH = 1
pkg syscall (darwin-arm64), const LOCK_SH ideal-int
pkg syscall (darwin-arm64), const LOCK_UN = 8
pkg syscall (darwin-arm64), const LOCK_UN ideal-int

//
// pthread_t *t = NULL;
// pthread_mutex_t mu;
// int nts = 0;
// int all_done = 0;
//
// static void *aFn(void *vargp) {
//   int done = 0;
//   while (!done) {
//     usleep(100);
//     pthread_mutex_lock(&mu);
//     done = all_done;
//     pthread_mutex_unlock(&mu);
//   }
//   return NULL;
// }
//
// void trial(int argc) {
//   int i;
//   nts = argc;
//   t = calloc(nts, sizeof(pthread_t));

	MOVKW $(3905<<0), R21                      // MOVKW $3905, R21              // 35e88172
	MOVKW $(3905<<16), R21                     // MOVKW $255918080, R21         // 35e8a172
	MOVK $(3905<<32), R21                      // MOVK $16771847290880, R21     // 35e8c1f2
	MOVD $0, R5                                // e5031faa
	MSR $1, SPSel                              // bf4100d5
	MSR $9, DAIFSet                            // df4903d5

	MOVD	$0xffffffffffffaaaa, R1       // MOVD	$-21846, R1                 // a1aa8a92
	MOVW	$1, ZR                        // 3f008052
	MOVW	$1, R1
	MOVD	$1, ZR                        // 3f0080d2
	MOVD	$1, R1
	MOVK	$1, R1
	MOVD	$0x1000100010001000, RSP      // MOVD	$1152939097061330944, RSP   // ff8304b2
	MOVW	$0x10001000, RSP              // MOVW	$268439552, RSP             // ff830432

pkg syscall (freebsd-riscv64), const LOCK_EX = 2 #53466
pkg syscall (freebsd-riscv64), const LOCK_EX ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_NB = 4 #53466
pkg syscall (freebsd-riscv64), const LOCK_NB ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_SH = 1 #53466
pkg syscall (freebsd-riscv64), const LOCK_SH ideal-int #53466
pkg syscall (freebsd-riscv64), const LOCK_UN = 8 #53466

of an interface type or of elements of a composite type remains unchanged:
</p>

<pre>
// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }

// NewMutex has the same composition as Mutex but its method set is empty.