type unsafe.Pointer

3247 uses

	unsafe (current package)
		unsafe.go#L184: type Pointer *ArbitraryType

	crypto/internal/fips140/alias
		alias.go#L15: 		uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
		alias.go#L16: 		uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))

	crypto/internal/fips140/check
		check.go#L42: 		Start unsafe.Pointer
		check.go#L43: 		End   unsafe.Pointer

	crypto/internal/fips140/nistec
		p256_asm.go#L332: 	p256PrecomputedPtr := unsafe.Pointer(&p256PrecomputedEmbed)
		p256_asm.go#L338: 		p256PrecomputedPtr = unsafe.Pointer(&newTable)

	crypto/internal/fips140/sha3
		keccakf.go#L56: 		a = (*[25]uint64)(unsafe.Pointer(da))

	github.com/google/go-cmp/cmp
		export.go#L19: 	ve := reflect.NewAt(f.Type, unsafe.Pointer(uintptr(unsafe.Pointer(v.UnsafeAddr()))+f.Offset)).Elem()

	github.com/google/go-cmp/cmp/internal/value
		pointer.go#L14: 	p unsafe.Pointer
		pointer.go#L23: 	return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}

	github.com/valyala/fastjson
		util.go#L9: 	return *(*string)(unsafe.Pointer(&b))
		util.go#L13: 	strh := (*reflect.StringHeader)(unsafe.Pointer(&s))
		util.go#L14: 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&b))

	go.uber.org/atomic
		unsafe_pointer.go#L32: 	v unsafe.Pointer
		unsafe_pointer.go#L36: func NewUnsafePointer(val unsafe.Pointer) *UnsafePointer {
		unsafe_pointer.go#L41: func (p *UnsafePointer) Load() unsafe.Pointer {
		unsafe_pointer.go#L46: func (p *UnsafePointer) Store(val unsafe.Pointer) {
		unsafe_pointer.go#L51: func (p *UnsafePointer) Swap(val unsafe.Pointer) (old unsafe.Pointer) {
		unsafe_pointer.go#L58: func (p *UnsafePointer) CAS(old, new unsafe.Pointer) (swapped bool) {
		unsafe_pointer.go#L63: func (p *UnsafePointer) CompareAndSwap(old, new unsafe.Pointer) (swapped bool) {

	golang.org/x/sys/unix
		affinity_linux.go#L20: 	_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))
		auxv.go#L35: 	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
		fcntl.go#L31: 	_, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
		ifreq_linux.go#L57: 	raw := *(*RawSockaddrInet4)(unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]))
		ifreq_linux.go#L79: 		unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]),
		ifreq_linux.go#L91: 	return *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0]))
		ifreq_linux.go#L97: 	*(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0])) = v
		ifreq_linux.go#L102: 	return *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0]))
		ifreq_linux.go#L108: 	*(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0])) = v
		ifreq_linux.go#L129: 	data unsafe.Pointer
		ifreq_linux.go#L136: func (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {
		ioctl_linux.go#L22: 	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
		ioctl_linux.go#L28: 	err := ioctlPtr(fd, RTC_RD_TIME, unsafe.Pointer(&value))
		ioctl_linux.go#L33: 	return ioctlPtr(fd, RTC_SET_TIME, unsafe.Pointer(value))
		ioctl_linux.go#L38: 	err := ioctlPtr(fd, RTC_WKALM_RD, unsafe.Pointer(&value))
		ioctl_linux.go#L43: 	return ioctlPtr(fd, RTC_WKALM_SET, unsafe.Pointer(value))
		ioctl_linux.go#L55: 	ifrd := ifr.withData(unsafe.Pointer(&value))
		ioctl_linux.go#L70: 	ifrd := ifr.withData(unsafe.Pointer(&value))
		ioctl_linux.go#L85: 	ifrd := ifr.withData(unsafe.Pointer(&value))
		ioctl_linux.go#L98: 	ifrd := ifr.withData(unsafe.Pointer(cfg))
		ioctl_linux.go#L110: 	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
		ioctl_linux.go#L118: 	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
		ioctl_linux.go#L127: 	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
		ioctl_linux.go#L135: 	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
		ioctl_linux.go#L142: 	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
		ioctl_linux.go#L148: 	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
		ioctl_linux.go#L154: 	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
		ioctl_linux.go#L162: 	err := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))
		ioctl_linux.go#L178: 	return ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))
		ioctl_linux.go#L211: 	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
		ioctl_linux.go#L219: 		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
		ioctl_linux.go#L220: 			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
		ioctl_linux.go#L229: 	err := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))
		ioctl_linux.go#L233: 		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
		ioctl_linux.go#L234: 			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
		ioctl_linux.go#L247: 	return ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))
		ioctl_linux.go#L252: 	err := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))
		ioctl_linux.go#L258: 	err := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))
		ioctl_linux.go#L264: 	err := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))
		ioctl_linux.go#L270: 	err := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))
		ioctl_linux.go#L279: 	return ioctlPtr(fd, req, unsafe.Pointer(&value.raw))
		ioctl_linux.go#L289: 	return ioctlPtr(fd, req, unsafe.Pointer(value))
		ioctl_linux.go#L297: 	if err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {
		ioctl_linux.go#L307: 	return ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))
		ioctl_linux.go#L312: 	return ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))
		ioctl_linux.go#L319: 	if err := ioctlPtr(fd, LOOP_GET_STATUS64, unsafe.Pointer(&value)); err != nil {
		ioctl_linux.go#L328: 	return ioctlPtr(fd, LOOP_SET_STATUS64, unsafe.Pointer(value))
		ioctl_linux.go#L333: 	return ioctlPtr(fd, LOOP_CONFIGURE, unsafe.Pointer(value))
		ioctl_unsigned.go#L28: 	return ioctlPtr(fd, req, unsafe.Pointer(&v))
		ioctl_unsigned.go#L37: 	return ioctlPtr(fd, req, unsafe.Pointer(value))
		ioctl_unsigned.go#L45: 	return ioctlPtr(fd, req, unsafe.Pointer(value))
		ioctl_unsigned.go#L55: 	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
		ioctl_unsigned.go#L61: 	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
		ioctl_unsigned.go#L67: 	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
		mremap.go#L37: 	newAddr, errno := m.mremap(uintptr(unsafe.Pointer(&bOld[0])), uintptr(len(bOld)), uintptr(newLength), flags, 0)
		mremap.go#L41: 	bNew := unsafe.Slice((*byte)(unsafe.Pointer(newAddr)), newLength)
		mremap.go#L54: func MremapPtr(oldAddr unsafe.Pointer, oldSize uintptr, newAddr unsafe.Pointer, newSize uintptr, flags int) (ret unsafe.Pointer, err error) {
		mremap.go#L56: 	return unsafe.Pointer(xaddr), err
		race0.go#L15: func raceAcquire(addr unsafe.Pointer) {
		race0.go#L18: func raceReleaseMerge(addr unsafe.Pointer) {
		race0.go#L21: func raceReadRange(addr unsafe.Pointer, len int) {
		race0.go#L24: func raceWriteRange(addr unsafe.Pointer, len int) {
		sockcmsg_linux.go#L16: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_linux.go#L34: 	ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
		sockcmsg_linux.go#L41: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_linux.go#L52: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_linux.go#L66: 		pp := (*RawSockaddrInet4)(unsafe.Pointer(&m.Data[0]))
		sockcmsg_linux.go#L68: 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		sockcmsg_linux.go#L74: 		pp := (*RawSockaddrInet6)(unsafe.Pointer(&m.Data[0]))
		sockcmsg_linux.go#L76: 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		sockcmsg_unix.go#L27: func (h *Cmsghdr) data(offset uintptr) unsafe.Pointer {
		sockcmsg_unix.go#L28: 	return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)) + offset)
		sockcmsg_unix.go#L69: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_unix.go#L81: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_unix.go#L102: 		fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
		syscall.go#L78: 	for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
		syscall.go#L79: 		ptr = unsafe.Pointer(uintptr(ptr) + 1)
		syscall_linux.go#L210: 	err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
		syscall_linux.go#L214: 	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
		syscall_linux.go#L230: 	return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
		syscall_linux.go#L240: 	return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
		syscall_linux.go#L389: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L394: 	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
		syscall_linux.go#L398: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
		syscall_linux.go#L401: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L406: 	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
		syscall_linux.go#L411: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
		syscall_linux.go#L414: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L436: 	return unsafe.Pointer(&sa.raw), sl, nil
		syscall_linux.go#L450: func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L461: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
		syscall_linux.go#L473: func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L478: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
		syscall_linux.go#L489: func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L493: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil
		syscall_linux.go#L506: func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L508: 	psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
		syscall_linux.go#L514: 	cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
		syscall_linux.go#L518: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil
		syscall_linux.go#L555: func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L559: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil
		syscall_linux.go#L586: func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L592: 	rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
		syscall_linux.go#L596: 	tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
		syscall_linux.go#L600: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
		syscall_linux.go#L615: func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L621: 	n := (*[8]byte)(unsafe.Pointer(&sa.Name))
		syscall_linux.go#L625: 	p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
		syscall_linux.go#L630: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
		syscall_linux.go#L704: func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L720: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil
		syscall_linux.go#L739: func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L745: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
		syscall_linux.go#L756: func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L763: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil
		syscall_linux.go#L782: func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L790: 	*(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX
		syscall_linux.go#L808: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
		syscall_linux.go#L840: 	copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:])
		syscall_linux.go#L848: 	copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:])
		syscall_linux.go#L856: 	copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:])
		syscall_linux.go#L862: func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L870: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil
		syscall_linux.go#L880: func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L884: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil
		syscall_linux.go#L895: func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L900: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil
		syscall_linux.go#L910: func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L929: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil
		syscall_linux.go#L939: func (sa *SockaddrNFC) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L944: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrNFC, nil
		syscall_linux.go#L957: func (sa *SockaddrNFCLLCP) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L969: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrNFCLLCP, nil
		syscall_linux.go#L979: 		pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
		syscall_linux.go#L988: 		pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
		syscall_linux.go#L999: 		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
		syscall_linux.go#L1019: 		sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
		syscall_linux.go#L1030: 			pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa))
		syscall_linux.go#L1036: 			pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
		syscall_linux.go#L1038: 			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_linux.go#L1052: 			pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa))
		syscall_linux.go#L1059: 			pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
		syscall_linux.go#L1061: 			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_linux.go#L1069: 		pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
		syscall_linux.go#L1084: 			pp := (*RawSockaddrL2)(unsafe.Pointer(rsa))
		syscall_linux.go#L1093: 			pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa))
		syscall_linux.go#L1101: 		pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa))
		syscall_linux.go#L1110: 		pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa))
		syscall_linux.go#L1126: 		pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa))
		syscall_linux.go#L1136: 			sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr))
		syscall_linux.go#L1138: 			sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr))
		syscall_linux.go#L1140: 			sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr))
		syscall_linux.go#L1147: 		pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa))
		syscall_linux.go#L1169: 		pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa))
		syscall_linux.go#L1176: 			name := (*[8]byte)(unsafe.Pointer(&sa.Name))
		syscall_linux.go#L1180: 			pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
		syscall_linux.go#L1184: 			addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
		syscall_linux.go#L1191: 			rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
		syscall_linux.go#L1195: 			tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
		syscall_linux.go#L1208: 			pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa))
		syscall_linux.go#L1216: 			pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa))
		syscall_linux.go#L1281: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L1288: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L1295: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L1308: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
		syscall_linux.go#L1309: 	out := (*TCPVegasInfo)(unsafe.Pointer(&value[0]))
		syscall_linux.go#L1322: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
		syscall_linux.go#L1323: 	out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0]))
		syscall_linux.go#L1336: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
		syscall_linux.go#L1337: 	out := (*TCPBBRInfo)(unsafe.Pointer(&value[0]))
		syscall_linux.go#L1346: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
		syscall_linux.go#L1350: 			err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
		syscall_linux.go#L1362: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L1369: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L1374: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
		syscall_linux.go#L1378: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
		syscall_linux.go#L1384: 	return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog))
		syscall_linux.go#L1388: 	var p unsafe.Pointer
		syscall_linux.go#L1390: 		p = unsafe.Pointer(&filter[0])
		syscall_linux.go#L1396: 	return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
		syscall_linux.go#L1400: 	return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
		syscall_linux.go#L1407: 	return setsockopt(fd, level, opt, unsafe.Pointer(&o[0]), uintptr(SizeofTCPRepairOpt*len(o)))
		syscall_linux.go#L1411: 	return setsockopt(fd, level, opt, unsafe.Pointer(s), unsafe.Sizeof(*s))
		syscall_linux.go#L1551: 	msg.Name = (*byte)(unsafe.Pointer(rsa))
		syscall_linux.go#L1584: func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
		syscall_linux.go#L1646: 		err = ptracePtr(req, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
		syscall_linux.go#L1658: 		err = ptracePtr(req, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
		syscall_linux.go#L1690: 		err = ptracePtr(peekReq, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
		syscall_linux.go#L1695: 		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
		syscall_linux.go#L1705: 		word := *((*uintptr)(unsafe.Pointer(&data[0])))
		syscall_linux.go#L1717: 		err = ptracePtr(peekReq, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
		syscall_linux.go#L1722: 		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
		syscall_linux.go#L1752: 	iov.Base = (*byte)(unsafe.Pointer(regsout))
		syscall_linux.go#L1754: 	return ptracePtr(PTRACE_GETREGSET, pid, uintptr(elfNT_PRSTATUS), unsafe.Pointer(&iov))
		syscall_linux.go#L1759: 	iov.Base = (*byte)(unsafe.Pointer(regs))
		syscall_linux.go#L1761: 	return ptracePtr(PTRACE_SETREGSET, pid, uintptr(elfNT_PRSTATUS), unsafe.Pointer(&iov))
		syscall_linux.go#L1770: 	err = ptracePtr(PTRACE_GETEVENTMSG, pid, 0, unsafe.Pointer(&data))
		syscall_linux.go#L1842: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_linux.go#L2019: 	r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags))
		syscall_linux.go#L2176: 			v.Base = (*byte)(unsafe.Pointer(&_zero))
		syscall_linux.go#L2223: 			raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
		syscall_linux.go#L2227: 		raceAcquire(unsafe.Pointer(&ioSync))
		syscall_linux.go#L2235: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_linux.go#L2246: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_linux.go#L2258: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_linux.go#L2274: 			raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
		syscall_linux.go#L2299: 	var p unsafe.Pointer
		syscall_linux.go#L2301: 		p = unsafe.Pointer(&iovs[0])
		syscall_linux.go#L2436: 	fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
		syscall_linux.go#L2449: 	return unsafe.Slice((*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type))+4)), n)
		syscall_linux.go#L2462: 		fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
		syscall_linux.go#L2490: 	var p unsafe.Pointer
		syscall_unix.go#L117: 	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), length)
		syscall_unix.go#L142: 	if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
		syscall_unix.go#L157: func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) {
		syscall_unix.go#L159: 	return unsafe.Pointer(xaddr), err
		syscall_unix.go#L162: func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) {
		syscall_unix.go#L170: 			raceWriteRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L173: 			raceAcquire(unsafe.Pointer(&ioSync))
		syscall_unix.go#L181: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_unix.go#L185: 		raceReadRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L194: 			raceWriteRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L197: 			raceAcquire(unsafe.Pointer(&ioSync))
		syscall_unix.go#L205: 		raceReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_unix.go#L209: 		raceReadRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L220: 	sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
		syscall_unix.go#L272: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
		syscall_unix.go#L279: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
		syscall_unix.go#L285: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
		syscall_unix.go#L292: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_unix.go#L299: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_unix.go#L306: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_unix.go#L313: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_unix.go#L320: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen)
		syscall_unix.go#L327: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen)
		syscall_unix.go#L334: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
		syscall_unix.go#L388: 			iov[i].Base = (*byte)(unsafe.Pointer(&_zero))
		syscall_unix.go#L437: 	var ptr unsafe.Pointer
		syscall_unix.go#L458: 			iov[i].Base = (*byte)(unsafe.Pointer(&_zero))
		syscall_unix.go#L461: 	var ptr unsafe.Pointer
		syscall_unix.go#L477: 	var ptr unsafe.Pointer
		syscall_unix.go#L489: 	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
		syscall_unix.go#L494: 	return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
		syscall_unix.go#L498: 	return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
		syscall_unix.go#L502: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
		syscall_unix.go#L506: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
		syscall_unix.go#L510: 	return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
		syscall_unix.go#L514: 	return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
		syscall_unix.go#L518: 	var p unsafe.Pointer
		syscall_unix.go#L520: 		p = unsafe.Pointer(&[]byte(s)[0])
		syscall_unix.go#L526: 	return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
		syscall_unix.go#L530: 	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8)
		sysvshm_unix.go#L32: 	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.Segsz))
		sysvshm_unix.go#L44: 	return shmdt(uintptr(unsafe.Pointer(&data[0])))
		zptrace_x86_linux.go#L32: 	return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout))
		zptrace_x86_linux.go#L37: 	return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs))
		zptrace_x86_linux.go#L73: 	return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout))
		zptrace_x86_linux.go#L78: 	return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs))
		zsyscall_linux.go#L31: 	_, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux.go#L46: 	_, _, e1 := Syscall6(SYS_FCHMODAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
		zsyscall_linux.go#L65: func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
		zsyscall_linux.go#L86: 	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
		zsyscall_linux.go#L101: 	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
		zsyscall_linux.go#L117: 	r0, _, e1 := Syscall6(SYS_OPENAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size), 0, 0)
		zsyscall_linux.go#L128: 	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
		zsyscall_linux.go#L138: 	r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0)
		zsyscall_linux.go#L154: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L156: 		_p1 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L158: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L160: 	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
		zsyscall_linux.go#L181: 	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
		zsyscall_linux.go#L196: 	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
		zsyscall_linux.go#L211: 	_, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0)
		zsyscall_linux.go#L221: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L223: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L225: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L238: 	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
		zsyscall_linux.go#L249: 	_, _, e1 := Syscall6(SYS_WAITID, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0)
		zsyscall_linux.go#L270: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L272: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L274: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L292: 	r0, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0)
		zsyscall_linux.go#L313: 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(arg5), 0)
		zsyscall_linux.go#L324: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L326: 		_p0 = unsafe.Pointer(&payload[0])
		zsyscall_linux.go#L328: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L340: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L342: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L344: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L346: 	r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(arg2)), uintptr(_p0), uintptr(len(buf)), 0, 0)
		zsyscall_linux.go#L367: 	_, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0)
		zsyscall_linux.go#L396: func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
		zsyscall_linux.go#L412: 	_, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux.go#L437: 	_, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
		zsyscall_linux.go#L452: 	_, _, e1 := Syscall6(SYS_MOUNT_SETATTR, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(unsafe.Pointer(attr)), uintptr(size), 0)
		zsyscall_linux.go#L467: 	_, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux.go#L487: 	var _p2 unsafe.Pointer
		zsyscall_linux.go#L489: 		_p2 = unsafe.Pointer(&payload[0])
		zsyscall_linux.go#L491: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L493: 	r0, _, e1 := Syscall6(SYS_ADD_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(payload)), uintptr(ringid), 0)
		zsyscall_linux.go#L504: 	r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
		zsyscall_linux.go#L515: 	_, _, e1 := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
		zsyscall_linux.go#L525: 	_, _, e1 := RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
		zsyscall_linux.go#L540: 	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux.go#L555: 	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux.go#L565: 	r0, _, e1 := Syscall(SYS_CLOCK_ADJTIME, uintptr(clockid), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux.go#L576: 	_, _, e1 := Syscall(SYS_CLOCK_GETRES, uintptr(clockid), uintptr(unsafe.Pointer(res)), 0)
		zsyscall_linux.go#L586: 	_, _, e1 := Syscall(SYS_CLOCK_GETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
		zsyscall_linux.go#L596: 	_, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
		zsyscall_linux.go#L606: 	_, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
		zsyscall_linux.go#L636: 	r0, _, e1 := Syscall6(SYS_COPY_FILE_RANGE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
		zsyscall_linux.go#L652: 	_, _, e1 := Syscall(SYS_DELETE_MODULE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
		zsyscall_linux.go#L694: 	_, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
		zsyscall_linux.go#L747: 	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
		zsyscall_linux.go#L772: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L774: 		_p1 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L776: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L778: 	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), 0, 0)
		zsyscall_linux.go#L794: 	_, _, e1 := Syscall(SYS_FINIT_MODULE, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
		zsyscall_linux.go#L804: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L806: 		_p0 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L808: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L836: 	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), 0)
		zsyscall_linux.go#L851: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L853: 		_p1 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L855: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L857: 	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), uintptr(flags), 0)
		zsyscall_linux.go#L893: 	r0, _, e1 := Syscall(SYS_FSOPEN, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
		zsyscall_linux.go#L909: 	r0, _, e1 := Syscall(SYS_FSPICK, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
		zsyscall_linux.go#L920: 	_, _, e1 := Syscall6(SYS_FSCONFIG, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(value)), uintptr(aux), 0)
		zsyscall_linux.go#L930: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L932: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L934: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L985: 	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
		zsyscall_linux.go#L1024: 	var _p2 unsafe.Pointer
		zsyscall_linux.go#L1026: 		_p2 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L1028: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1030: 	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
		zsyscall_linux.go#L1041: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1043: 		_p0 = unsafe.Pointer(&moduleImage[0])
		zsyscall_linux.go#L1045: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1052: 	_, _, e1 := Syscall(SYS_INIT_MODULE, uintptr(_p0), uintptr(len(moduleImage)), uintptr(unsafe.Pointer(_p1)))
		zsyscall_linux.go#L1067: 	r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
		zsyscall_linux.go#L1110: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1112: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux.go#L1114: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1137: 	var _p2 unsafe.Pointer
		zsyscall_linux.go#L1139: 		_p2 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L1141: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1143: 	r0, _, e1 := Syscall6(SYS_LGETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
		zsyscall_linux.go#L1159: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L1161: 		_p1 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L1163: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1165: 	r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
		zsyscall_linux.go#L1181: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L1183: 		_p1 = unsafe.Pointer(&dest[0])
		zsyscall_linux.go#L1185: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1187: 	r0, _, e1 := Syscall(SYS_LLISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
		zsyscall_linux.go#L1208: 	_, _, e1 := Syscall(SYS_LREMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
		zsyscall_linux.go#L1228: 	var _p2 unsafe.Pointer
		zsyscall_linux.go#L1230: 		_p2 = unsafe.Pointer(&data[0])
		zsyscall_linux.go#L1232: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1234: 	_, _, e1 := Syscall6(SYS_LSETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
		zsyscall_linux.go#L1249: 	r0, _, e1 := Syscall(SYS_MEMFD_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
		zsyscall_linux.go#L1265: 	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux.go#L1280: 	_, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
		zsyscall_linux.go#L1300: 	_, _, e1 := Syscall6(SYS_MOVE_MOUNT, uintptr(fromDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(toDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
		zsyscall_linux.go#L1310: 	_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
		zsyscall_linux.go#L1325: 	r0, _, e1 := Syscall(SYS_OPEN_TREE, uintptr(dfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
		zsyscall_linux.go#L1336: 	r0, _, e1 := Syscall6(SYS_PERF_EVENT_OPEN, uintptr(unsafe.Pointer(attr)), uintptr(pid), uintptr(cpu), uintptr(groupFd), uintptr(flags), 0)
		zsyscall_linux.go#L1357: 	_, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
		zsyscall_linux.go#L1377: 	r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)))
		zsyscall_linux.go#L1388: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1390: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux.go#L1392: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1415: 	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
		zsyscall_linux.go#L1435: 	_, _, e1 := Syscall6(SYS_RENAMEAT2, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
		zsyscall_linux.go#L1460: 	r0, _, e1 := Syscall6(SYS_REQUEST_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(destRingid), 0, 0)
		zsyscall_linux.go#L1471: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1473: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux.go#L1475: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1487: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1489: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux.go#L1491: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1524: 	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
		zsyscall_linux.go#L1564: 	var _p2 unsafe.Pointer
		zsyscall_linux.go#L1566: 		_p2 = unsafe.Pointer(&data[0])
		zsyscall_linux.go#L1568: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1570: 	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
		zsyscall_linux.go#L1580: 	r0, _, e1 := Syscall6(SYS_SIGNALFD4, uintptr(fd), uintptr(unsafe.Pointer(sigmask)), uintptr(maskSize), uintptr(flags), 0, 0)
		zsyscall_linux.go#L1596: 	_, _, e1 := Syscall6(SYS_STATX, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mask), uintptr(unsafe.Pointer(stat)), 0)
		zsyscall_linux.go#L1623: 	_, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
		zsyscall_linux.go#L1644: 	_, _, e1 := RawSyscall(SYS_TIMERFD_GETTIME, uintptr(fd), uintptr(unsafe.Pointer(currValue)), 0)
		zsyscall_linux.go#L1654: 	_, _, e1 := RawSyscall6(SYS_TIMERFD_SETTIME, uintptr(fd), uintptr(flags), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)), 0, 0)
		zsyscall_linux.go#L1674: 	r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
		zsyscall_linux.go#L1693: 	_, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
		zsyscall_linux.go#L1708: 	_, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
		zsyscall_linux.go#L1728: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1730: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux.go#L1732: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1755: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1757: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1759: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1772: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1774: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1776: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1789: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1791: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1793: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1806: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1808: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1810: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1823: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1825: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1827: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1840: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1842: 		_p0 = unsafe.Pointer(&iovs[0])
		zsyscall_linux.go#L1844: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1878: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1880: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L1882: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1894: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1896: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L1898: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1910: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1912: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L1914: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1936: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1938: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L1940: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1952: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L1954: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L1956: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L1983: 	_, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux.go#L1998: 	_, _, e1 := Syscall6(SYS_FACCESSAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
		zsyscall_linux.go#L2013: 	_, _, e1 := Syscall6(SYS_NAME_TO_HANDLE_AT, uintptr(dirFD), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(fh)), uintptr(unsafe.Pointer(mountID)), uintptr(flags), 0)
		zsyscall_linux.go#L2023: 	r0, _, e1 := Syscall(SYS_OPEN_BY_HANDLE_AT, uintptr(mountFD), uintptr(unsafe.Pointer(fh)), uintptr(flags))
		zsyscall_linux.go#L2034: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L2036: 		_p0 = unsafe.Pointer(&localIov[0])
		zsyscall_linux.go#L2038: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L2040: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L2042: 		_p1 = unsafe.Pointer(&remoteIov[0])
		zsyscall_linux.go#L2044: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L2057: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L2059: 		_p0 = unsafe.Pointer(&localIov[0])
		zsyscall_linux.go#L2061: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L2063: 	var _p1 unsafe.Pointer
		zsyscall_linux.go#L2065: 		_p1 = unsafe.Pointer(&remoteIov[0])
		zsyscall_linux.go#L2067: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux.go#L2102: 	_, _, e1 := Syscall6(SYS_PIDFD_SEND_SIGNAL, uintptr(pidfd), uintptr(sig), uintptr(unsafe.Pointer(info)), uintptr(flags), 0, 0)
		zsyscall_linux.go#L2123: 	r0, _, e1 := Syscall(SYS_SHMCTL, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf)))
		zsyscall_linux.go#L2155: 	_, _, e1 := Syscall(SYS_GETITIMER, uintptr(which), uintptr(unsafe.Pointer(currValue)), 0)
		zsyscall_linux.go#L2165: 	_, _, e1 := Syscall(SYS_SETITIMER, uintptr(which), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)))
		zsyscall_linux.go#L2175: 	_, _, e1 := RawSyscall6(SYS_RT_SIGPROCMASK, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oldset)), uintptr(sigsetsize), 0, 0)
		zsyscall_linux.go#L2185: 	RawSyscallNoError(SYS_GETRESUID, uintptr(unsafe.Pointer(ruid)), uintptr(unsafe.Pointer(euid)), uintptr(unsafe.Pointer(suid)))
		zsyscall_linux.go#L2192: 	RawSyscallNoError(SYS_GETRESGID, uintptr(unsafe.Pointer(rgid)), uintptr(unsafe.Pointer(egid)), uintptr(unsafe.Pointer(sgid)))
		zsyscall_linux.go#L2199: 	_, _, e1 := Syscall(SYS_SCHED_SETATTR, uintptr(pid), uintptr(unsafe.Pointer(attr)), uintptr(flags))
		zsyscall_linux.go#L2209: 	_, _, e1 := Syscall6(SYS_SCHED_GETATTR, uintptr(pid), uintptr(unsafe.Pointer(attr)), uintptr(size), uintptr(flags), 0, 0)
		zsyscall_linux.go#L2219: 	_, _, e1 := Syscall6(SYS_CACHESTAT, uintptr(fd), uintptr(unsafe.Pointer(crange)), uintptr(unsafe.Pointer(cstat)), uintptr(flags), 0, 0)
		zsyscall_linux.go#L2229: 	var _p0 unsafe.Pointer
		zsyscall_linux.go#L2231: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux.go#L2233: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L18: 	_, _, e1 := Syscall6(SYS_FANOTIFY_MARK, uintptr(fd), uintptr(flags), uintptr(mask), uintptr(dirFd), uintptr(unsafe.Pointer(pathname)), 0)
		zsyscall_linux_amd64.go#L49: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L51: 		_p0 = unsafe.Pointer(&events[0])
		zsyscall_linux_amd64.go#L53: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L86: 	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
		zsyscall_linux_amd64.go#L101: 	_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L111: 	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L155: 	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
		zsyscall_linux_amd64.go#L198: 	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
		zsyscall_linux_amd64.go#L239: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L241: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L243: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L256: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L258: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L260: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L283: 	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
		zsyscall_linux_amd64.go#L304: 	r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
		zsyscall_linux_amd64.go#L347: 	r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
		zsyscall_linux_amd64.go#L363: 	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L388: 	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
		zsyscall_linux_amd64.go#L398: 	_, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
		zsyscall_linux_amd64.go#L408: 	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L418: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L428: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L439: 	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
		zsyscall_linux_amd64.go#L450: 	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
		zsyscall_linux_amd64.go#L459: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
		zsyscall_linux_amd64.go#L460: 	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
		zsyscall_linux_amd64.go#L469: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
		zsyscall_linux_amd64.go#L491: 	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
		zsyscall_linux_amd64.go#L501: 	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
		zsyscall_linux_amd64.go#L511: 	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
		zsyscall_linux_amd64.go#L521: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L523: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L525: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L527: 	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
		zsyscall_linux_amd64.go#L537: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L538: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L540: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L542: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L554: 	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
		zsyscall_linux_amd64.go#L565: 	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
		zsyscall_linux_amd64.go#L592: 	_, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
		zsyscall_linux_amd64.go#L607: 	_, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L622: 	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
		zsyscall_linux_amd64.go#L637: 	_, _, e1 := Syscall6(SYS_KEXEC_FILE_LOAD, uintptr(kernelFd), uintptr(initrdFd), uintptr(cmdlineLen), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)

	golang.org/x/tools/go/types/typeutil
		map.go#L392: 	ptr := uintptr(unsafe.Pointer(tname))

	golang.org/x/tools/internal/event/core
		export.go#L21: 	exporter unsafe.Pointer
		export.go#L28: 	p := unsafe.Pointer(&e)

	golang.org/x/tools/internal/event/label
		label.go#L100: type stringptr unsafe.Pointer
		label.go#L106: 	hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
		label.go#L120: 	hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))

	golang.org/x/tools/internal/typesinternal
		types.go#L30: 	addr := unsafe.Pointer(f.UnsafeAddr())

	google.golang.org/protobuf/internal/impl
		api_export_opaque.go#L76: 	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
		api_export_opaque.go#L80: 	return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
		api_export_opaque.go#L84: 	atomic.StorePointer((*unsafe.Pointer)(p.p), q.p)
		api_export_opaque.go#L106: 	*(*unsafe.Pointer)(unsafe.Pointer(dst)) = atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(ptr)))
		api_export_opaque.go#L115: 	if !atomic.CompareAndSwapPointer((*unsafe.Pointer)(ptr), unsafe.Pointer(nil), *(*unsafe.Pointer)(dst)) {
		api_export_opaque.go#L116: 		*(*unsafe.Pointer)(unsafe.Pointer(dst)) = atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(ptr)))
		pointer_unsafe.go#L18: type Pointer unsafe.Pointer
		pointer_unsafe.go#L39: type pointer struct{ p unsafe.Pointer }
		pointer_unsafe.go#L43: 	return pointer{p: unsafe.Pointer(p)}
		pointer_unsafe.go#L48: 	return pointer{p: unsafe.Pointer(v.Pointer())}
		pointer_unsafe.go#L54: 		Type unsafe.Pointer
		pointer_unsafe.go#L55: 		Data unsafe.Pointer
		pointer_unsafe.go#L57: 	return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
		pointer_unsafe.go#L71: 	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
		pointer_unsafe.go#L124: 	return pointer{p: *(*unsafe.Pointer)(p.p)}
		pointer_unsafe.go#L143: 	*(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
		pointer_unsafe.go#L187: const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
		pointer_unsafe.go#L191: 	return (*messageState)(unsafe.Pointer(p))
		pointer_unsafe.go#L195: 	return pointer{p: unsafe.Pointer(ms)}
		pointer_unsafe.go#L205: 	return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
		pointer_unsafe.go#L208: 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
		pointer_unsafe.go#L211: type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
		pointer_unsafe.go#L218: 	atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
		pointer_unsafe_opaque.go#L13: 	return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
		pointer_unsafe_opaque.go#L17: 	atomic.StorePointer((*unsafe.Pointer)(p.p), v.p)
		pointer_unsafe_opaque.go#L21: 	atomic.StorePointer((*unsafe.Pointer)(p.p), unsafe.Pointer(nil))
		pointer_unsafe_opaque.go#L25: 	if atomic.CompareAndSwapPointer((*unsafe.Pointer)(p.p), unsafe.Pointer(nil), v.p) {
		pointer_unsafe_opaque.go#L28: 	return pointer{p: atomic.LoadPointer((*unsafe.Pointer)(p.p))}
		pointer_unsafe_opaque.go#L34: 	return Pointer(atomic.LoadPointer((*unsafe.Pointer)(&mi.p)))
		pointer_unsafe_opaque.go#L38: 	if atomic.CompareAndSwapPointer((*unsafe.Pointer)(&mi.p), nil, unsafe.Pointer(p)) {
		presence.go#L18: 	P unsafe.Pointer
		presence.go#L30: 	return (*uint32)(unsafe.Pointer(uintptr(p.P) + offset))
		presence.go#L77: 		q := (*uint32)(unsafe.Pointer(uintptr(p.P) + o))
		presence.go#L89: 		q := (*uint32)(unsafe.Pointer(uintptr(p.P) + o))
		presence.go#L113: 	o := (uintptr(unsafe.Pointer(&template.a)) - uintptr(unsafe.Pointer(&template.d)))
		presence.go#L114: 	return (*RaceDetectHookData)(unsafe.Pointer(uintptr(p.P) - o))
		presence.go#L118: 	return (*[]byte)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
		presence.go#L121: 	atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(p)), nil, unsafe.Pointer(v))
		presence.go#L140: 	o := (uintptr(unsafe.Pointer(&template.a)) - uintptr(unsafe.Pointer(&template.d))) + uintptr(num/32)*unsafe.Sizeof(uint32(0))
		presence.go#L141: 	return (*RaceDetectHookData)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) - o))

	google.golang.org/protobuf/internal/protolazy
		pointer_unsafe.go#L13: 	return (*[]IndexEntry)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
		pointer_unsafe.go#L16: 	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))

	google.golang.org/protobuf/reflect/protoreflect
		value_unsafe.go#L16: 		Type unsafe.Pointer
		value_unsafe.go#L17: 		Data unsafe.Pointer
		value_unsafe.go#L37: func typeOf(t any) unsafe.Pointer {
		value_unsafe.go#L38: 	return (*ifaceHeader)(unsafe.Pointer(&t)).Type
		value_unsafe.go#L51: 	typ unsafe.Pointer // 8B
		value_unsafe.go#L54: 	ptr unsafe.Pointer // 8B
		value_unsafe.go#L65: 	return Value{typ: stringType, ptr: unsafe.Pointer(unsafe.StringData(v)), num: uint64(len(v))}
		value_unsafe.go#L68: 	return Value{typ: bytesType, ptr: unsafe.Pointer(unsafe.SliceData(v)), num: uint64(len(v))}
		value_unsafe.go#L71: 	p := (*ifaceHeader)(unsafe.Pointer(&v))
		value_unsafe.go#L82: 	*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}

	hash/crc32
		crc32_amd64.go#L153: 		delta := int(uintptr(unsafe.Pointer(&p[0])) & 7)

	hash/maphash
		maphash_runtime.go#L23: func runtime_memhash(p unsafe.Pointer, seed, s uintptr) uintptr
		maphash_runtime.go#L34: 		return uint64(runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed), uintptr(len)))
		maphash_runtime.go#L36: 	lo := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed), uintptr(len))
		maphash_runtime.go#L37: 	hi := runtime_memhash(unsafe.Pointer(&buf[0]), uintptr(seed>>32), uintptr(len))
		maphash_runtime.go#L54: 	var hasher func(unsafe.Pointer, uintptr) uintptr
		maphash_runtime.go#L56: 		hasher = (*abi.SwissMapType)(unsafe.Pointer(mTyp)).Hasher
		maphash_runtime.go#L58: 		hasher = (*abi.OldMapType)(unsafe.Pointer(mTyp)).Hasher
		maphash_runtime.go#L61: 		return uint64(hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s)))
		maphash_runtime.go#L63: 	lo := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s))
		maphash_runtime.go#L64: 	hi := hasher(abi.NoEscape(unsafe.Pointer(&v)), uintptr(s>>32))

	internal/abi
		abi.go#L38: 	Ptrs [IntArgRegs]unsafe.Pointer
		abi.go#L74: func (r *RegArgs) IntRegArgAddr(reg int, argSize uintptr) unsafe.Pointer {
		abi.go#L82: 	return unsafe.Pointer(uintptr(unsafe.Pointer(&r.Ints[reg])) + offset)
		escape.go#L19: func NoEscape(p unsafe.Pointer) unsafe.Pointer {
		escape.go#L21: 	return unsafe.Pointer(x ^ 0)
		iface.go#L26: 	Data unsafe.Pointer
		map_noswiss.go#L31: 	Hasher     func(unsafe.Pointer, uintptr) uintptr
		map_swiss.go#L38: 	Hasher    func(unsafe.Pointer, uintptr) uintptr
		type.go#L30: 	Equal func(unsafe.Pointer, unsafe.Pointer) bool
		type.go#L179: 	eface := *(*EmptyInterface)(unsafe.Pointer(&a))
		type.go#L185: 	return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
		type.go#L247: 	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.mcount > 0"))[:t.Mcount:t.Mcount]
		type.go#L254: 	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.xcount > 0"))[:t.Xcount:t.Xcount]
		type.go#L264: func addChecked(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
		type.go#L265: 	return unsafe.Pointer(uintptr(p) + x)
		type.go#L285: 		return int((*ArrayType)(unsafe.Pointer(t)).Len)
		type.go#L318: 		ch := (*ChanType)(unsafe.Pointer(t))
		type.go#L331: 		return &(*structTypeUncommon)(unsafe.Pointer(t)).u
		type.go#L337: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L343: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L349: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L355: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L361: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L367: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L373: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L379: 		return &(*u)(unsafe.Pointer(t)).u
		type.go#L387: 		tt := (*ArrayType)(unsafe.Pointer(t))
		type.go#L390: 		tt := (*ChanType)(unsafe.Pointer(t))
		type.go#L393: 		tt := (*mapType)(unsafe.Pointer(t))
		type.go#L396: 		tt := (*PtrType)(unsafe.Pointer(t))
		type.go#L399: 		tt := (*SliceType)(unsafe.Pointer(t))
		type.go#L410: 	return (*StructType)(unsafe.Pointer(t))
		type.go#L418: 	return (*mapType)(unsafe.Pointer(t))
		type.go#L426: 	return (*ArrayType)(unsafe.Pointer(t))
		type.go#L434: 	return (*FuncType)(unsafe.Pointer(t))
		type.go#L442: 	return (*InterfaceType)(unsafe.Pointer(t))
		type.go#L469: 		tt := (*InterfaceType)(unsafe.Pointer(t))
		type.go#L480: 		return (*mapType)(unsafe.Pointer(t)).Key
		type.go#L531: 	return (*[1 << 16]*Type)(addChecked(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.InCount:t.InCount]
		type.go#L542: 	return (*[1 << 17]*Type)(addChecked(unsafe.Pointer(t), uadd, "outCount > 0"))[t.InCount : t.InCount+outCount : t.InCount+outCount]
		type.go#L603: 	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), whySafe))
		type.go#L609: 	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), "the runtime doesn't need to give you a reason"))

	internal/asan
		noasan.go#L15: func Read(addr unsafe.Pointer, len uintptr) {}
		noasan.go#L17: func Write(addr unsafe.Pointer, len uintptr) {}

	internal/bytealg
		equal_native.go#L18: func abigen_runtime_memequal(a, b unsafe.Pointer, size uintptr) bool
		equal_native.go#L21: func abigen_runtime_memequal_varlen(a, b unsafe.Pointer) bool

	internal/chacha8rand
		chacha8_generic.go#L61: 	b := (*[16][2]uint64)(unsafe.Pointer(b32))
		chacha8_generic.go#L151: 	b := (*[16][4]uint32)(unsafe.Pointer(buf))

	internal/coverage/rtcov
		rtcov.go#L63: func AddMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {

	internal/godebug
		godebug.go#L301: 		write(2, unsafe.Pointer(&b[0]), int32(len(b)))
		godebug.go#L310: func write(fd uintptr, p unsafe.Pointer, n int32) int32

	internal/msan
		nomsan.go#L15: func Read(addr unsafe.Pointer, sz uintptr) {
		nomsan.go#L18: func Write(addr unsafe.Pointer, sz uintptr) {
		nomsan.go#L21: func Malloc(addr unsafe.Pointer, sz uintptr) {
		nomsan.go#L24: func Free(addr unsafe.Pointer, sz uintptr) {
		nomsan.go#L27: func Move(dst, src unsafe.Pointer, sz uintptr) {

	internal/poll
		fd_writev_unix.go#L20: 		r, _, e = syscall.Syscall(syscall.SYS_WRITEV, uintptr(fd), uintptr(unsafe.Pointer(&iovecs[0])), uintptr(len(iovecs)))

	internal/race
		norace.go#L16: func Acquire(addr unsafe.Pointer) {
		norace.go#L19: func Release(addr unsafe.Pointer) {
		norace.go#L22: func ReleaseMerge(addr unsafe.Pointer) {
		norace.go#L31: func Read(addr unsafe.Pointer) {
		norace.go#L34: func ReadPC(addr unsafe.Pointer, callerpc, pc uintptr) {
		norace.go#L37: func ReadObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
		norace.go#L40: func Write(addr unsafe.Pointer) {
		norace.go#L43: func WritePC(addr unsafe.Pointer, callerpc, pc uintptr) {
		norace.go#L46: func WriteObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
		norace.go#L49: func ReadRange(addr unsafe.Pointer, len int) {
		norace.go#L52: func WriteRange(addr unsafe.Pointer, len int) {

	internal/reflectlite
		swapper.go#L41: 			ps := *(*[]unsafe.Pointer)(v.ptr)
		type.go#L151: 	return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
		type.go#L209: 	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.DataChecked(off, "name offset field")))[:])
		type.go#L210: 	pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.Bytes), nameOff))}
		type.go#L224: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
		type.go#L231: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
		type.go#L234: 	return abi.Name{Bytes: (*byte)(resolveNameOff(unsafe.Pointer(t.Type), int32(off)))}
		type.go#L238: 	return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t.Type), int32(off)))
		type.go#L380: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
		type.go#L381: 	return unsafe.Pointer(uintptr(p) + x)
		type.go#L438: 		v := (*interfaceType)(unsafe.Pointer(V))
		type.go#L566: 		t := (*funcType)(unsafe.Pointer(T))
		type.go#L567: 		v := (*funcType)(unsafe.Pointer(V))
		type.go#L584: 		t := (*interfaceType)(unsafe.Pointer(T))
		type.go#L585: 		v := (*interfaceType)(unsafe.Pointer(V))
		type.go#L600: 		t := (*structType)(unsafe.Pointer(T))
		type.go#L601: 		v := (*structType)(unsafe.Pointer(V))
		value.go#L43: 	ptr unsafe.Pointer
		value.go#L97: 	return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
		value.go#L102: func (v Value) pointer() unsafe.Pointer {
		value.go#L107: 		return *(*unsafe.Pointer)(v.ptr)
		value.go#L116: 	e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
		value.go#L134: 		e.Data = *(*unsafe.Pointer)(v.ptr)
		value.go#L149: 	e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
		value.go#L248: 			ptr = *(*unsafe.Pointer)(ptr)
		value.go#L254: 		tt := (*ptrType)(unsafe.Pointer(v.typ()))
		value.go#L299: 			ptr = *(*unsafe.Pointer)(ptr)
		value.go#L305: 		return *(*unsafe.Pointer)(v.ptr) == nil
		value.go#L328: func chanlen(unsafe.Pointer) int
		value.go#L331: func maplen(unsafe.Pointer) int
		value.go#L339: 		tt := (*arrayType)(unsafe.Pointer(v.typ()))
		value.go#L369: 	var target unsafe.Pointer
		value.go#L377: 		*(*unsafe.Pointer)(v.ptr) = x.ptr
		value.go#L398: func unsafe_New(*abi.Type) unsafe.Pointer
		value.go#L412: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
		value.go#L455: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
		value.go#L459: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
		value.go#L464: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)

	internal/runtime/atomic
		atomic_amd64.go#L23: func Loadp(ptr unsafe.Pointer) unsafe.Pointer {
		atomic_amd64.go#L24: 	return *(*unsafe.Pointer)(ptr)
		atomic_amd64.go#L138: func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
		stubs.go#L15: func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
		types.go#L438: 	return *(*float64)(unsafe.Pointer(&r))
		types.go#L445: 	f.u.Store(*(*uint64)(unsafe.Pointer(&value)))
		types.go#L459: 	value  unsafe.Pointer
		types.go#L465: func (u *UnsafePointer) Load() unsafe.Pointer {
		types.go#L466: 	return Loadp(unsafe.Pointer(&u.value))
		types.go#L478: func (u *UnsafePointer) StoreNoWB(value unsafe.Pointer) {
		types.go#L479: 	StorepNoWB(unsafe.Pointer(&u.value), value)
		types.go#L483: func (u *UnsafePointer) Store(value unsafe.Pointer) {
		types.go#L490: func storePointer(ptr *unsafe.Pointer, new unsafe.Pointer)
		types.go#L504: func (u *UnsafePointer) CompareAndSwapNoWB(old, new unsafe.Pointer) bool {
		types.go#L511: func (u *UnsafePointer) CompareAndSwap(old, new unsafe.Pointer) bool {
		types.go#L515: func casPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
		types.go#L539: 	p.u.StoreNoWB(unsafe.Pointer(value))
		types.go#L546: 	p.u.Store(unsafe.Pointer(value))
		types.go#L562: 	return p.u.CompareAndSwapNoWB(unsafe.Pointer(old), unsafe.Pointer(new))
		types.go#L570: 	return p.u.CompareAndSwap(unsafe.Pointer(old), unsafe.Pointer(new))

	internal/runtime/maps
		group.go#L126: 		return *(*ctrl)(unsafe.Add(unsafe.Pointer(g), 7-i))
		group.go#L128: 	return *(*ctrl)(unsafe.Add(unsafe.Pointer(g), i))
		group.go#L134: 		*(*ctrl)(unsafe.Add(unsafe.Pointer(g), 7-i)) = c
		group.go#L137: 	*(*ctrl)(unsafe.Add(unsafe.Pointer(g), i)) = c
		group.go#L245: 	data unsafe.Pointer // data *typ.Group
		group.go#L278: func (g *groupReference) key(typ *abi.SwissMapType, i uintptr) unsafe.Pointer {
		group.go#L281: 	return unsafe.Pointer(uintptr(g.data) + offset)
		group.go#L285: func (g *groupReference) elem(typ *abi.SwissMapType, i uintptr) unsafe.Pointer {
		group.go#L288: 	return unsafe.Pointer(uintptr(g.data) + offset)
		group.go#L296: 	data unsafe.Pointer // data *[length]typ.Group
		group.go#L322: 		data: unsafe.Pointer(uintptr(g.data) + offset),
		map.go#L222: 	dirPtr unsafe.Pointer
		map.go#L316: 	m.dirPtr = unsafe.Pointer(&directory[0])
		map.go#L337: 	return *(**table)(unsafe.Pointer(uintptr(m.dirPtr) + goarch.PtrSize*i))
		map.go#L341: 	*(**table)(unsafe.Pointer(uintptr(m.dirPtr) + goarch.PtrSize*i)) = nt
		map.go#L374: 		m.dirPtr = unsafe.Pointer(&newDir[0])
		map.go#L394: func (m *Map) Get(typ *abi.SwissMapType, key unsafe.Pointer) (unsafe.Pointer, bool) {
		map.go#L398: func (m *Map) getWithKey(typ *abi.SwissMapType, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
		map.go#L417: func (m *Map) getWithoutKey(typ *abi.SwissMapType, key unsafe.Pointer) (unsafe.Pointer, bool) {
		map.go#L437: func (m *Map) getWithKeySmall(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
		map.go#L454: 			slotKey = *((*unsafe.Pointer)(slotKey))
		map.go#L460: 				slotElem = *((*unsafe.Pointer)(slotElem))
		map.go#L469: func (m *Map) Put(typ *abi.SwissMapType, key, elem unsafe.Pointer) {
		map.go#L478: func (m *Map) PutSlot(typ *abi.SwissMapType, key unsafe.Pointer) unsafe.Pointer {
		map.go#L528: func (m *Map) putSlotSmall(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) unsafe.Pointer {
		map.go#L541: 			slotKey = *((*unsafe.Pointer)(slotKey))
		map.go#L550: 				slotElem = *((*unsafe.Pointer)(slotElem))
		map.go#L572: 		*(*unsafe.Pointer)(slotKey) = kmem
		map.go#L580: 		*(*unsafe.Pointer)(slotElem) = emem
		map.go#L615: 			key = *((*unsafe.Pointer)(key))
		map.go#L620: 			elem = *((*unsafe.Pointer)(elem))
		map.go#L632: 	m.dirPtr = unsafe.Pointer(&directory[0])
		map.go#L639: func (m *Map) Delete(typ *abi.SwissMapType, key unsafe.Pointer) {
		map.go#L677: func (m *Map) deleteSmall(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) {
		map.go#L689: 			slotKey = *((*unsafe.Pointer)(slotKey))
		map.go#L696: 				*(*unsafe.Pointer)(origSlotKey) = nil
		map.go#L705: 				*(*unsafe.Pointer)(slotElem) = nil
		runtime.go#L21: func typedmemmove(typ *abi.Type, dst, src unsafe.Pointer)
		runtime.go#L24: func typedmemclr(typ *abi.Type, ptr unsafe.Pointer)
		runtime.go#L27: func newarray(typ *abi.Type, n int) unsafe.Pointer
		runtime.go#L30: func newobject(typ *abi.Type) unsafe.Pointer
		runtime_fast32_swiss.go#L17: func runtime_mapaccess1_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe.Pointer {
		runtime_fast32_swiss.go#L21: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast32_swiss.go#L25: 		return unsafe.Pointer(&zeroVal[0])
		runtime_fast32_swiss.go#L42: 				slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
		runtime_fast32_swiss.go#L45: 			slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_fast32_swiss.go#L48: 		return unsafe.Pointer(&zeroVal[0])
		runtime_fast32_swiss.go#L52: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast32_swiss.go#L70: 				slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
		runtime_fast32_swiss.go#L80: 			return unsafe.Pointer(&zeroVal[0])
		runtime_fast32_swiss.go#L86: func runtime_mapaccess2_fast32(typ *abi.SwissMapType, m *Map, key uint32) (unsafe.Pointer, bool) {
		runtime_fast32_swiss.go#L90: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast32_swiss.go#L94: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast32_swiss.go#L111: 				slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
		runtime_fast32_swiss.go#L114: 			slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_fast32_swiss.go#L117: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast32_swiss.go#L121: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast32_swiss.go#L139: 				slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
		runtime_fast32_swiss.go#L149: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast32_swiss.go#L154: func (m *Map) putSlotSmallFast32(typ *abi.SwissMapType, hash uintptr, key uint32) unsafe.Pointer {
		runtime_fast32_swiss.go#L195: func runtime_mapassign_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe.Pointer {
		runtime_fast32_swiss.go#L202: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast32_swiss.go#L209: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast32_swiss.go#L235: 	var slotElem unsafe.Pointer
		runtime_fast32_swiss.go#L329: func runtime_mapassign_fast32ptr(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
		runtime_fast32_swiss.go#L336: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast32_swiss.go#L343: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast32_swiss.go#L369: 	var slotElem unsafe.Pointer
		runtime_fast32_swiss.go#L392: 				if key == *(*unsafe.Pointer)(slotKey) {
		runtime_fast32_swiss.go#L431: 				*(*unsafe.Pointer)(slotKey) = key
		runtime_fast32_swiss.go#L462: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast32_swiss.go#L469: 	m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
		runtime_fast64_swiss.go#L17: func runtime_mapaccess1_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe.Pointer {
		runtime_fast64_swiss.go#L21: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast64_swiss.go#L25: 		return unsafe.Pointer(&zeroVal[0])
		runtime_fast64_swiss.go#L42: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
		runtime_fast64_swiss.go#L45: 			slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_fast64_swiss.go#L48: 		return unsafe.Pointer(&zeroVal[0])
		runtime_fast64_swiss.go#L52: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast64_swiss.go#L70: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
		runtime_fast64_swiss.go#L80: 			return unsafe.Pointer(&zeroVal[0])
		runtime_fast64_swiss.go#L86: func runtime_mapaccess2_fast64(typ *abi.SwissMapType, m *Map, key uint64) (unsafe.Pointer, bool) {
		runtime_fast64_swiss.go#L90: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast64_swiss.go#L94: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast64_swiss.go#L111: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
		runtime_fast64_swiss.go#L114: 			slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_fast64_swiss.go#L117: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast64_swiss.go#L121: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast64_swiss.go#L139: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
		runtime_fast64_swiss.go#L149: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_fast64_swiss.go#L154: func (m *Map) putSlotSmallFast64(typ *abi.SwissMapType, hash uintptr, key uint64) unsafe.Pointer {
		runtime_fast64_swiss.go#L195: func runtime_mapassign_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe.Pointer {
		runtime_fast64_swiss.go#L202: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast64_swiss.go#L209: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast64_swiss.go#L235: 	var slotElem unsafe.Pointer
		runtime_fast64_swiss.go#L324: func (m *Map) putSlotSmallFastPtr(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) unsafe.Pointer {
		runtime_fast64_swiss.go#L336: 		if key == *(*unsafe.Pointer)(slotKey) {
		runtime_fast64_swiss.go#L354: 	*(*unsafe.Pointer)(slotKey) = key
		runtime_fast64_swiss.go#L367: func runtime_mapassign_fast64ptr(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
		runtime_fast64_swiss.go#L374: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast64_swiss.go#L381: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_fast64_swiss.go#L407: 	var slotElem unsafe.Pointer
		runtime_fast64_swiss.go#L431: 				if key == *(*unsafe.Pointer)(slotKey) {
		runtime_fast64_swiss.go#L470: 				*(*unsafe.Pointer)(slotKey) = key
		runtime_fast64_swiss.go#L501: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_fast64_swiss.go#L508: 	m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
		runtime_faststr_swiss.go#L17: func (m *Map) getWithoutKeySmallFastStr(typ *abi.SwissMapType, key string) unsafe.Pointer {
		runtime_faststr_swiss.go#L42: 			slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_faststr_swiss.go#L52: 			return unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
		runtime_faststr_swiss.go#L59: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&key)), m.seed)
		runtime_faststr_swiss.go#L66: 			return unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
		runtime_faststr_swiss.go#L68: 		slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
		runtime_faststr_swiss.go#L87: 	x = unsafe.Pointer(uintptr(x) + uintptr(len(a)) - 8)
		runtime_faststr_swiss.go#L88: 	y = unsafe.Pointer(uintptr(y) + uintptr(len(a)) - 8)
		runtime_faststr_swiss.go#L94: func stringPtr(s string) unsafe.Pointer {
		runtime_faststr_swiss.go#L96: 		ptr unsafe.Pointer
		runtime_faststr_swiss.go#L99: 	return (*stringStruct)(unsafe.Pointer(&s)).ptr
		runtime_faststr_swiss.go#L103: func runtime_mapaccess1_faststr(typ *abi.SwissMapType, m *Map, key string) unsafe.Pointer {
		runtime_faststr_swiss.go#L107: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_faststr_swiss.go#L111: 		return unsafe.Pointer(&zeroVal[0])
		runtime_faststr_swiss.go#L122: 			return unsafe.Pointer(&zeroVal[0])
		runtime_faststr_swiss.go#L128: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_faststr_swiss.go#L146: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
		runtime_faststr_swiss.go#L156: 			return unsafe.Pointer(&zeroVal[0])
		runtime_faststr_swiss.go#L162: func runtime_mapaccess2_faststr(typ *abi.SwissMapType, m *Map, key string) (unsafe.Pointer, bool) {
		runtime_faststr_swiss.go#L166: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_faststr_swiss.go#L170: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_faststr_swiss.go#L181: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_faststr_swiss.go#L187: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_faststr_swiss.go#L205: 				slotElem := unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
		runtime_faststr_swiss.go#L215: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_faststr_swiss.go#L220: func (m *Map) putSlotSmallFastStr(typ *abi.SwissMapType, hash uintptr, key string) unsafe.Pointer {
		runtime_faststr_swiss.go#L263: func runtime_mapassign_faststr(typ *abi.SwissMapType, m *Map, key string) unsafe.Pointer {
		runtime_faststr_swiss.go#L270: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_faststr_swiss.go#L277: 	hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
		runtime_faststr_swiss.go#L303: 	var slotElem unsafe.Pointer
		runtime_faststr_swiss.go#L400: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_faststr_swiss.go#L407: 	m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
		runtime_swiss.go#L21: func mapKeyError(typ *abi.SwissMapType, p unsafe.Pointer) error
		runtime_swiss.go#L43: func runtime_mapaccess1(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
		runtime_swiss.go#L47: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_swiss.go#L61: 		return unsafe.Pointer(&zeroVal[0])
		runtime_swiss.go#L73: 			return unsafe.Pointer(&zeroVal[0])
		runtime_swiss.go#L95: 				slotKey = *((*unsafe.Pointer)(slotKey))
		runtime_swiss.go#L98: 				slotElem := unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
		runtime_swiss.go#L100: 					slotElem = *((*unsafe.Pointer)(slotElem))
		runtime_swiss.go#L111: 			return unsafe.Pointer(&zeroVal[0])
		runtime_swiss.go#L117: func runtime_mapaccess2(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) (unsafe.Pointer, bool) {
		runtime_swiss.go#L121: 		race.ReadPC(unsafe.Pointer(m), callerpc, pc)
		runtime_swiss.go#L135: 		return unsafe.Pointer(&zeroVal[0]), false
		runtime_swiss.go#L147: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_swiss.go#L169: 				slotKey = *((*unsafe.Pointer)(slotKey))
		runtime_swiss.go#L172: 				slotElem := unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
		runtime_swiss.go#L174: 					slotElem = *((*unsafe.Pointer)(slotElem))
		runtime_swiss.go#L185: 			return unsafe.Pointer(&zeroVal[0]), false
		runtime_swiss.go#L191: func runtime_mapassign(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
		runtime_swiss.go#L198: 		race.WritePC(unsafe.Pointer(m), callerpc, pc)
		runtime_swiss.go#L237: 	var slotElem unsafe.Pointer
		runtime_swiss.go#L263: 					slotKey = *((*unsafe.Pointer)(slotKey))
		runtime_swiss.go#L270: 					slotElem = unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
		runtime_swiss.go#L272: 						slotElem = *((*unsafe.Pointer)(slotElem))
		runtime_swiss.go#L307: 						*(*unsafe.Pointer)(slotKey) = kmem
		runtime_swiss.go#L312: 					slotElem = unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
		runtime_swiss.go#L315: 						*(*unsafe.Pointer)(slotElem) = emem
		table.go#L145: func (t *table) Get(typ *abi.SwissMapType, m *Map, key unsafe.Pointer) (unsafe.Pointer, bool) {
		table.go#L166: func (t *table) getWithKey(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
		table.go#L205: 				slotKey = *((*unsafe.Pointer)(slotKey))
		table.go#L210: 					slotElem = *((*unsafe.Pointer)(slotElem))
		table.go#L226: func (t *table) getWithoutKey(typ *abi.SwissMapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, bool) {
		table.go#L238: 				slotKey = *((*unsafe.Pointer)(slotKey))
		table.go#L243: 					slotElem = *((*unsafe.Pointer)(slotElem))
		table.go#L266: func (t *table) PutSlot(typ *abi.SwissMapType, m *Map, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, bool) {
		table.go#L284: 				slotKey = *((*unsafe.Pointer)(slotKey))
		table.go#L293: 					slotElem = *((*unsafe.Pointer)(slotElem))
		table.go#L334: 				*(*unsafe.Pointer)(slotKey) = kmem
		table.go#L342: 				*(*unsafe.Pointer)(slotElem) = emem
		table.go#L376: func (t *table) uncheckedPutSlot(typ *abi.SwissMapType, hash uintptr, key, elem unsafe.Pointer) {
		table.go#L395: 				*(*unsafe.Pointer)(slotKey) = key
		table.go#L402: 				*(*unsafe.Pointer)(slotElem) = elem
		table.go#L415: func (t *table) Delete(typ *abi.SwissMapType, m *Map, hash uintptr, key unsafe.Pointer) {
		table.go#L427: 				slotKey = *((*unsafe.Pointer)(slotKey))
		table.go#L436: 					*(*unsafe.Pointer)(origSlotKey) = nil
		table.go#L446: 					*(*unsafe.Pointer)(slotElem) = nil
		table.go#L506: 	key  unsafe.Pointer // Must be in first position.  Write nil to indicate iteration end (see cmd/compile/internal/walk/range.go).
		table.go#L507: 	elem unsafe.Pointer // Must be in second position (see cmd/compile/internal/walk/range.go).
		table.go#L578: func (it *Iter) Key() unsafe.Pointer {
		table.go#L586: func (it *Iter) Elem() unsafe.Pointer {
		table.go#L626: func (it *Iter) grownKeyElem(key unsafe.Pointer, slotIdx uintptr) (unsafe.Pointer, unsafe.Pointer, bool) {
		table.go#L655: 				elem = *((*unsafe.Pointer)(elem))
		table.go#L699: 				key = *((*unsafe.Pointer)(key))
		table.go#L707: 			var elem unsafe.Pointer
		table.go#L716: 							elem = *((*unsafe.Pointer)(elem))
		table.go#L728: 					elem = *((*unsafe.Pointer)(elem))
		table.go#L842: 				key = *((*unsafe.Pointer)(key))
		table.go#L846: 			var elem unsafe.Pointer
		table.go#L861: 					elem = *((*unsafe.Pointer)(elem))
		table.go#L935: 				key = *((*unsafe.Pointer)(key))
		table.go#L950: 			var elem unsafe.Pointer
		table.go#L976: 					elem = *((*unsafe.Pointer)(elem))
		table.go#L1064: 				key = *((*unsafe.Pointer)(key))
		table.go#L1069: 				elem = *((*unsafe.Pointer)(elem))
		table.go#L1105: 					key = *((*unsafe.Pointer)(key))
		table.go#L1110: 					elem = *((*unsafe.Pointer)(elem))
		table_debug.go#L39: 					key = *((*unsafe.Pointer)(key))
		table_debug.go#L125: func dump(ptr unsafe.Pointer, size uintptr) {
		table_debug.go#L128: 		ptr = unsafe.Pointer(uintptr(ptr) + 1)

	internal/runtime/syscall
		syscall_linux.go#L26: 	var ev unsafe.Pointer
		syscall_linux.go#L28: 		ev = unsafe.Pointer(&events[0])
		syscall_linux.go#L30: 		ev = unsafe.Pointer(&_zero)
		syscall_linux.go#L37: 	_, _, e := Syscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)

	internal/sync
		hashtriemap.go#L58: type hashFunc func(unsafe.Pointer, uintptr) uintptr
		hashtriemap.go#L59: type equalFunc func(unsafe.Pointer, unsafe.Pointer) bool
		hashtriemap.go#L66: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L90: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L169: 	oldHash := ht.keyHash(unsafe.Pointer(&oldEntry.key), ht.seed)
		hashtriemap.go#L207: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L285: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L311: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L373: 	hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
		hashtriemap.go#L591: 		if e.key == key && (valEqual == nil || valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&value)))) {
		hashtriemap.go#L633: 	if head.key == key && valEqual(unsafe.Pointer(&head.value), abi.NoEscape(unsafe.Pointer(&old))) {
		hashtriemap.go#L644: 		if e.key == key && valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&old))) {
		hashtriemap.go#L683: 	if head.key == key && valEqual(unsafe.Pointer(&head.value), abi.NoEscape(unsafe.Pointer(&value))) {
		hashtriemap.go#L690: 		if e.key == key && valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&value))) {
		hashtriemap.go#L710: 	return (*entry[K, V])(unsafe.Pointer(n))
		hashtriemap.go#L717: 	return (*indirect[K, V])(unsafe.Pointer(n))
		mutex.go#L65: 			race.Acquire(unsafe.Pointer(m))
		mutex.go#L90: 		race.Acquire(unsafe.Pointer(m))
		mutex.go#L180: 		race.Acquire(unsafe.Pointer(m))
		mutex.go#L190: 		race.Release(unsafe.Pointer(m))

	internal/syscall/unix
		at.go#L20: 	_, _, errno := syscall.Syscall(unlinkatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags))
		at.go#L34: 	fd, _, errno := syscall.Syscall6(openatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags), uintptr(perm), 0, 0)
		at.go#L47: 	var p1 unsafe.Pointer
		at.go#L49: 		p1 = unsafe.Pointer(&buf[0])
		at.go#L51: 		p1 = unsafe.Pointer(&_zero)
		at.go#L55: 		uintptr(unsafe.Pointer(p0)),
		at.go#L74: 		uintptr(unsafe.Pointer(p)),
		at_fstatat.go#L21: 	_, _, errno := syscall.Syscall6(fstatatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
		copy_file_range_unix.go#L17: 		uintptr(unsafe.Pointer(roff)),
		copy_file_range_unix.go#L19: 		uintptr(unsafe.Pointer(woff)),
		getrandom.go#L37: 		uintptr(unsafe.Pointer(unsafe.SliceData(p))),
		tcsetpgrp_linux.go#L16: 	_, _, errno := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(syscall.TIOCSPGRP), uintptr(unsafe.Pointer(&pgid)), 0, 0, 0)
		waitid_linux.go#L18: 	_, _, errno := syscall.Syscall6(syscall.SYS_WAITID, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0)

	internal/unsafeheader
		unsafeheader.go#L23: 	Data unsafe.Pointer
		unsafeheader.go#L35: 	Data unsafe.Pointer

	iter
		iter.go#L270: 		race.Acquire(unsafe.Pointer(&racer))
		iter.go#L272: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L284: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L286: 			race.Acquire(unsafe.Pointer(&racer))
		iter.go#L297: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L305: 		race.Write(unsafe.Pointer(&racer)) // detect races
		iter.go#L314: 		race.Release(unsafe.Pointer(&racer))
		iter.go#L316: 		race.Acquire(unsafe.Pointer(&racer))
		iter.go#L330: 		race.Write(unsafe.Pointer(&racer)) // detect races
		iter.go#L334: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L336: 			race.Acquire(unsafe.Pointer(&racer))
		iter.go#L386: 		race.Acquire(unsafe.Pointer(&racer))
		iter.go#L388: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L400: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L402: 			race.Acquire(unsafe.Pointer(&racer))
		iter.go#L413: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L422: 		race.Write(unsafe.Pointer(&racer)) // detect races
		iter.go#L431: 		race.Release(unsafe.Pointer(&racer))
		iter.go#L433: 		race.Acquire(unsafe.Pointer(&racer))
		iter.go#L447: 		race.Write(unsafe.Pointer(&racer)) // detect races
		iter.go#L451: 			race.Release(unsafe.Pointer(&racer))
		iter.go#L453: 			race.Acquire(unsafe.Pointer(&racer))

	math
		unsafe.go#L24: func Float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
		unsafe.go#L30: func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
		unsafe.go#L35: func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
		unsafe.go#L41: func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }

	net
		cgo_unix.go#L134: 	gerrno, err := _C_getaddrinfo(nil, (*_C_char)(unsafe.Pointer(&cservice[0])), hints, &res)
		cgo_unix.go#L153: 			sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(*_C_ai_addr(r)))
		cgo_unix.go#L154: 			p := (*[2]byte)(unsafe.Pointer(&sa.Port))
		cgo_unix.go#L157: 			sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(*_C_ai_addr(r)))
		cgo_unix.go#L158: 			p := (*[2]byte)(unsafe.Pointer(&sa.Port))
		cgo_unix.go#L182: 	gerrno, err := _C_getaddrinfo((*_C_char)(unsafe.Pointer(h)), nil, &hints, &res)
		cgo_unix.go#L223: 			sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(*_C_ai_addr(r)))
		cgo_unix.go#L227: 			sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(*_C_ai_addr(r)))
		cgo_unix.go#L336: 		state = (*_C_struct___res_state)(unsafe.Pointer(&memSlice[0]))
		cgo_unix.go#L353: 	defer _C_free(unsafe.Pointer(buf))
		cgo_unix.go#L362: 		size := _C_res_nsearch(state, (*_C_char)(unsafe.Pointer(s)), class, rtype, buf, bufSize)
		cgo_unix.go#L371: 		_C_free(unsafe.Pointer(buf))
		cgo_unix.go#L377: 	if _, err := p.Start(unsafe.Slice((*byte)(unsafe.Pointer(buf)), size)); err != nil {
		interface_linux.go#L32: 			ifim := (*syscall.IfInfomsg)(unsafe.Pointer(&m.Data[0]))
		interface_linux.go#L91: 			ifi.MTU = int(*(*uint32)(unsafe.Pointer(&a.Value[:4][0])))
		interface_linux.go#L147: 			ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
		interface_linux.go#L226: 				i := *(*uint32)(unsafe.Pointer(&b[:4][0]))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L16: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L74: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L105: var _cgo_77133bf98b3a_C2func_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_C2func_getaddrinfo)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L109: 	errno := _cgo_runtime_cgocall(_cgo_77133bf98b3a_C2func_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L122: var _cgo_77133bf98b3a_C2func_getnameinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_C2func_getnameinfo)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L126: 	errno := _cgo_runtime_cgocall(_cgo_77133bf98b3a_C2func_getnameinfo, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L148: func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L154: var _cgo_77133bf98b3a_Cfunc_free = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_free)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L157: func _Cfunc_free(p0 unsafe.Pointer) (r1 _Ctype_void) {
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L158: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_free, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L167: var _cgo_77133bf98b3a_Cfunc_freeaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_freeaddrinfo)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L171: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_freeaddrinfo, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L180: var _cgo_77133bf98b3a_Cfunc_gai_strerror = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_gai_strerror)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L184: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_gai_strerror, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L193: var _cgo_77133bf98b3a_Cfunc_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_getaddrinfo)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L197: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L209: var _cgo_77133bf98b3a_Cfunc_getnameinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_getnameinfo)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L213: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_getnameinfo, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L228: var _cgo_77133bf98b3a_Cfunc_res_search = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_res_search)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L232: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_res_search, uintptr(unsafe.Pointer(&p0)))
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L246: var _cgo_77133bf98b3a_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc__Cmalloc)
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L252: func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
		1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L253: 	_cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
		cgo_resnew.go#L23: 	gerrno, err := ( /*line :20:17*/_C2func_getnameinfo /*line :20:29*/)(sa, salen, (* /*line :20:44*/_Ctype_char /*line :20:50*/)(unsafe.Pointer(&b[0])),  /*line :20:76*/_Ctype_socklen_t /*line :20:87*/(len(b)), nil, 0, ( /*line :20:105*/_Ciconst_NI_NAMEREQD /*line :20:117*/))
		cgo_socknew.go#L28: 	return (* /*line :25:11*/_Ctype_struct_sockaddr /*line :25:28*/)(unsafe.Pointer(&sa))
		cgo_socknew.go#L34: 	return (* /*line :31:11*/_Ctype_struct_sockaddr /*line :31:28*/)(unsafe.Pointer(&sa))
		cgo_unix_cgo.go#L68: func _C_malloc(n uintptr) unsafe.Pointer { return ( /*line :65:51*/_Cfunc__CMalloc /*line :65:58*/)( /*line :65:60*/_Ctype_size_t /*line :65:68*/(n)) }
		cgo_unix_cgo.go#L69: func _C_free(p unsafe.Pointer)           { func() { _cgo0 := /*line :66:51*/p; _cgoCheckPointer(_cgo0, nil); /*line :66:53*/_Cfunc_free(_cgo0); }() }

	reflect
		abi.go#L224: 		tt := (*arrayType)(unsafe.Pointer(t))
		abi.go#L237: 		st := (*structType)(unsafe.Pointer(t))
		abi.go#L473: func intFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
		abi.go#L480: func intToReg(r *abi.RegArgs, reg int, argSize uintptr, from unsafe.Pointer) {
		abi.go#L487: func floatFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
		abi.go#L492: 		*(*float64)(to) = *(*float64)(unsafe.Pointer(&r.Floats[reg]))
		abi.go#L501: func floatToReg(r *abi.RegArgs, reg int, argSize uintptr, from unsafe.Pointer) {
		badlinkname.go#L130: func badlinkname_Value_pointer(Value) unsafe.Pointer
		deepequal.go#L19: 	a1  unsafe.Pointer
		deepequal.go#L20: 	a2  unsafe.Pointer
		deepequal.go#L63: 		ptrval := func(v Value) unsafe.Pointer {
		float32reg_generic.go#L18: 	return *(*float32)(unsafe.Pointer(&i))
		float32reg_generic.go#L22: 	return uint64(*(*uint32)(unsafe.Pointer(&val)))
		makefunc.go#L52: 	ftyp := (*funcType)(unsafe.Pointer(t))
		makefunc.go#L70: 	return Value{t, unsafe.Pointer(impl), flag(Func)}
		makefunc.go#L107: 	ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
		makefunc.go#L129: 	return Value{ftyp.Common(), unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
		makefunc.go#L168: 			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = arg
		makefunc.go#L173: 			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = 0
		map_swiss.go#L26: 	tt := (*mapType)(unsafe.Pointer(t))
		map_swiss.go#L53: 		mt := (*mapType)(unsafe.Pointer(tt))
		map_swiss.go#L65: 	var imap any = (map[unsafe.Pointer]unsafe.Pointer)(nil)
		map_swiss.go#L66: 	mt := **(**mapType)(unsafe.Pointer(&imap))
		map_swiss.go#L73: 	mt.Hasher = func(p unsafe.Pointer, seed uintptr) uintptr {
		map_swiss.go#L148: 	tt := (*mapType)(unsafe.Pointer(v.typ()))
		map_swiss.go#L158: 	var e unsafe.Pointer
		map_swiss.go#L164: 		var k unsafe.Pointer
		map_swiss.go#L168: 			k = unsafe.Pointer(&key.ptr)
		map_swiss.go#L187: 		race.ReadPC(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapIterStart))
		map_swiss.go#L200: 		race.ReadPC(unsafe.Pointer(it.Map()), callerpc, abi.FuncPCABIInternal(mapIterNext))
		map_swiss.go#L212: 	tt := (*mapType)(unsafe.Pointer(v.typ()))
		map_swiss.go#L265: 	t := (*mapType)(unsafe.Pointer(iter.m.typ()))
		map_swiss.go#L285: 	var target unsafe.Pointer
		map_swiss.go#L290: 	t := (*mapType)(unsafe.Pointer(iter.m.typ()))
		map_swiss.go#L309: 	t := (*mapType)(unsafe.Pointer(iter.m.typ()))
		map_swiss.go#L329: 	var target unsafe.Pointer
		map_swiss.go#L334: 	t := (*mapType)(unsafe.Pointer(iter.m.typ()))
		map_swiss.go#L351: 		t := (*mapType)(unsafe.Pointer(iter.m.typ()))
		map_swiss.go#L411: 	tt := (*mapType)(unsafe.Pointer(v.typ()))
		map_swiss.go#L421: 		var e unsafe.Pointer
		map_swiss.go#L425: 			e = unsafe.Pointer(&elem.ptr)
		map_swiss.go#L432: 	var k unsafe.Pointer
		map_swiss.go#L436: 		k = unsafe.Pointer(&key.ptr)
		map_swiss.go#L444: 	var e unsafe.Pointer
		map_swiss.go#L448: 		e = unsafe.Pointer(&elem.ptr)
		swapper.go#L42: 			ps := *(*[]unsafe.Pointer)(v.ptr)
		type.go#L423: 	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.DataChecked(off, "name offset field")))[:])
		type.go#L424: 	pkgPathName := abi.Name{Bytes: (*byte)(resolveTypeOff(unsafe.Pointer(n.Bytes), nameOff))}
		type.go#L502: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
		type.go#L509: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
		type.go#L516: func resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
		type.go#L532: func addReflectOff(ptr unsafe.Pointer) int32
		type.go#L537: 	return aNameOff(addReflectOff(unsafe.Pointer(n.Bytes)))
		type.go#L543: 	return aTypeOff(addReflectOff(unsafe.Pointer(t)))
		type.go#L549: func resolveReflectText(ptr unsafe.Pointer) aTextOff {
		type.go#L554: 	return abi.Name{Bytes: (*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
		type.go#L558: 	return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
		type.go#L561: func (t *rtype) textOff(off aTextOff) unsafe.Pointer {
		type.go#L562: 	return resolveTextOff(unsafe.Pointer(t), int32(off))
		type.go#L565: func textOffFor(t *abi.Type, off aTextOff) unsafe.Pointer {
		type.go#L606: 		tt := (*interfaceType)(unsafe.Pointer(t))
		type.go#L614: 		tt := (*interfaceType)(unsafe.Pointer(t))
		type.go#L626: 	ft := (*funcType)(unsafe.Pointer(mtyp))
		type.go#L639: 	fn := unsafe.Pointer(&tfn)
		type.go#L648: 		tt := (*interfaceType)(unsafe.Pointer(t))
		type.go#L720: 	tt := (*abi.ChanType)(unsafe.Pointer(t))
		type.go#L725: 	return (*rtype)(unsafe.Pointer(t))
		type.go#L744: 	tt := (*structType)(unsafe.Pointer(t))
		type.go#L752: 	tt := (*structType)(unsafe.Pointer(t))
		type.go#L760: 	tt := (*structType)(unsafe.Pointer(t))
		type.go#L768: 	tt := (*structType)(unsafe.Pointer(t))
		type.go#L776: 	tt := (*arrayType)(unsafe.Pointer(t))
		type.go#L784: 	tt := (*structType)(unsafe.Pointer(t))
		type.go#L792: 	tt := (*abi.FuncType)(unsafe.Pointer(t))
		type.go#L800: 	tt := (*abi.FuncType)(unsafe.Pointer(t))
		type.go#L808: 	tt := (*abi.FuncType)(unsafe.Pointer(t))
		type.go#L816: 	tt := (*abi.FuncType)(unsafe.Pointer(t))
		type.go#L824: 	tt := (*abi.FuncType)(unsafe.Pointer(t))
		type.go#L946: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
		type.go#L947: 	return unsafe.Pointer(uintptr(p) + x)
		type.go#L1122: 		p := unsafe.Pointer(&(*staticuint64s)[i])
		type.go#L1253: 				styp := (*structType)(unsafe.Pointer(ntyp))
		type.go#L1343: 		p := (*ptrType)(unsafe.Pointer(tt))
		type.go#L1353: 	var iptr any = (*unsafe.Pointer)(nil)
		type.go#L1354: 	prototype := *(**ptrType)(unsafe.Pointer(&iptr))
		type.go#L1419: 	t := (*interfaceType)(unsafe.Pointer(T))
		type.go#L1437: 		v := (*interfaceType)(unsafe.Pointer(V))
		type.go#L1573: 		t := (*funcType)(unsafe.Pointer(T))
		type.go#L1574: 		v := (*funcType)(unsafe.Pointer(V))
		type.go#L1591: 		t := (*interfaceType)(unsafe.Pointer(T))
		type.go#L1592: 		v := (*interfaceType)(unsafe.Pointer(V))
		type.go#L1607: 		t := (*structType)(unsafe.Pointer(T))
		type.go#L1608: 		v := (*structType)(unsafe.Pointer(V))
		type.go#L1659: func typelinks() (sections []unsafe.Pointer, offset [][]int32)
		type.go#L1670: func rtypeOff(section unsafe.Pointer, off int32) *abi.Type {
		type.go#L1789: 		ch := (*chanType)(unsafe.Pointer(tt))
		type.go#L1797: 	var ichan any = (chan unsafe.Pointer)(nil)
		type.go#L1798: 	prototype := *(**chanType)(unsafe.Pointer(&ichan))
		type.go#L1852: 	prototype := *(**funcType)(unsafe.Pointer(&ifunc))
		type.go#L1860: 	ft := (*funcType)(unsafe.Pointer(o.Field(0).Addr().Pointer()))
		type.go#L1861: 	args := unsafe.Slice((**rtype)(unsafe.Pointer(o.Field(1).Addr().Pointer())), n)[0:0:n]
		type.go#L1945: 			repr = append(repr, stringFor((*sliceType)(unsafe.Pointer(t)).Elem)...)
		type.go#L1978: 		tt := (*arrayType)(unsafe.Pointer(t))
		type.go#L1981: 		tt := (*structType)(unsafe.Pointer(t))
		type.go#L2005: 		tt := (*arrayType)(unsafe.Pointer(t))
		type.go#L2008: 		tt := (*structType)(unsafe.Pointer(t))
		type.go#L2027: 		tt := (*arrayType)(unsafe.Pointer(t))
		type.go#L2030: 		tt := (*structType)(unsafe.Pointer(t))
		type.go#L2072: 		slice := (*sliceType)(unsafe.Pointer(tt))
		type.go#L2080: 	var islice any = ([]unsafe.Pointer)(nil)
		type.go#L2081: 	prototype := *(**sliceType)(unsafe.Pointer(&islice))
		type.go#L2238: 				ift := (*interfaceType)(unsafe.Pointer(ft))
		type.go#L2245: 					fnStub := resolveReflectText(unsafe.Pointer(abi.FuncPCABIInternal(embeddedIfaceMethStub)))
		type.go#L2254: 				ptr := (*ptrType)(unsafe.Pointer(ft))
		type.go#L2419: 	prototype := *(**structType)(unsafe.Pointer(&istruct))
		type.go#L2493: 		typ.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
		type.go#L2498: 		typ.Equal = func(p, q unsafe.Pointer) bool {
		type.go#L2557: 		st := (*structType)(unsafe.Pointer(t))
		type.go#L2598: 		array := (*arrayType)(unsafe.Pointer(tt))
		type.go#L2606: 	var iarray any = [1]unsafe.Pointer{}
		type.go#L2607: 	prototype := *(**arrayType)(unsafe.Pointer(&iarray))
		type.go#L2659: 		array.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
		type.go#L2667: 		array.Equal = func(p, q unsafe.Pointer) bool {
		type.go#L2839: 		tt := (*arrayType)(unsafe.Pointer(t))
		type.go#L2846: 		tt := (*structType)(unsafe.Pointer(t))
		value.go#L46: 	ptr unsafe.Pointer
		value.go#L105: 	return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
		value.go#L111: func (v Value) pointer() unsafe.Pointer {
		value.go#L116: 		return *(*unsafe.Pointer)(v.ptr)
		value.go#L125: 	e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
		value.go#L143: 		e.Data = *(*unsafe.Pointer)(v.ptr)
		value.go#L158: 	e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
		value.go#L209: 	word unsafe.Pointer
		value.go#L322: 		n := int((*arrayType)(unsafe.Pointer(v.typ())).Len)
		value.go#L390: 	t := (*funcType)(unsafe.Pointer(v.typ()))
		value.go#L392: 		fn       unsafe.Pointer
		value.go#L400: 		fn = *(*unsafe.Pointer)(v.ptr)
		value.go#L474: 	var stackArgs unsafe.Pointer
		value.go#L477: 			stackArgs = framePool.Get().(unsafe.Pointer)
		value.go#L503: 			storeRcvr(rcvr, unsafe.Pointer(&regArgs.Ptrs[st.ireg]))
		value.go#L506: 			storeRcvr(rcvr, unsafe.Pointer(&regArgs.Ints[st.ireg]))
		value.go#L508: 			storeRcvr(rcvr, unsafe.Pointer(&regArgs.Floats[st.freg]))
		value.go#L532: 					*(*unsafe.Pointer)(addr) = v.ptr
		value.go#L544: 						regArgs.Ptrs[st.ireg] = *(*unsafe.Pointer)(offset)
		value.go#L658: 					*((*unsafe.Pointer)(s)) = regArgs.Ptrs[st.ireg]
		value.go#L695: func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
		value.go#L731: 				v.ptr = *(*unsafe.Pointer)(add(ptr, st.stkOff, "1-ptr"))
		value.go#L746: 						*((*unsafe.Pointer)(s)) = regs.Ptrs[st.ireg]
		value.go#L875: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *abi.Type, t *funcType, fn unsafe.Pointer) {
		value.go#L878: 		tt := (*interfaceType)(unsafe.Pointer(v.typ()))
		value.go#L891: 		fn = unsafe.Pointer(&unsafe.Slice(&iface.itab.Fun[0], i+1)[i])
		value.go#L892: 		t = (*funcType)(unsafe.Pointer(tt.typeOff(m.Typ)))
		value.go#L904: 		fn = unsafe.Pointer(&ifn)
		value.go#L905: 		t = (*funcType)(unsafe.Pointer(typeOffFor(v.typ(), m.Mtyp)))
		value.go#L914: func storeRcvr(v Value, p unsafe.Pointer) {
		value.go#L919: 		*(*unsafe.Pointer)(p) = iface.word
		value.go#L921: 		*(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
		value.go#L923: 		*(*unsafe.Pointer)(p) = v.ptr
		value.go#L952: func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
		value.go#L970: 	methodFrame := methodFramePool.Get().(unsafe.Pointer)
		value.go#L981: 		storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ptrs[st.ireg]))
		value.go#L984: 		storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ints[st.ireg]))
		value.go#L986: 		storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Floats[st.freg]))
		value.go#L1032: 					methodRegs.Ptrs[mStep.ireg] = *(*unsafe.Pointer)(from)
		value.go#L1051: 					*(*unsafe.Pointer)(to) = valueRegs.Ptrs[vStep.ireg]
		value.go#L1143: 	pc := *(*uintptr)(unsafe.Pointer(&f))
		value.go#L1183: 	tt := (*chanType)(unsafe.Pointer(v.typ()))
		value.go#L1253: 			ptr = *(*unsafe.Pointer)(ptr)
		value.go#L1259: 		tt := (*ptrType)(unsafe.Pointer(v.typ()))
		value.go#L1274: 	tt := (*structType)(unsafe.Pointer(v.typ()))
		value.go#L1397: 		tt := (*arrayType)(unsafe.Pointer(v.typ()))
		value.go#L1420: 		tt := (*sliceType)(unsafe.Pointer(v.typ()))
		value.go#L1553: 			ptr = *(*unsafe.Pointer)(ptr)
		value.go#L1559: 		return *(*unsafe.Pointer)(v.ptr) == nil
		value.go#L1591: 		typ := (*abi.ArrayType)(unsafe.Pointer(v.typ()))
		value.go#L1597: 			return typ.Equal(abi.NoEscape(v.ptr), unsafe.Pointer(&zeroVal[0]))
		value.go#L1619: 		typ := (*abi.StructType)(unsafe.Pointer(v.typ()))
		value.go#L1623: 			return typ.Equal(abi.NoEscape(v.ptr), unsafe.Pointer(&zeroVal[0]))
		value.go#L1653: 	for uintptr(unsafe.Pointer(&b[0]))%8 != 0 {
		value.go#L1671: 	w := unsafe.Slice((*uint64)(unsafe.Pointer(&b[0])), len(b)/8)
		value.go#L1738: 		*(*unsafe.Pointer)(v.ptr) = nil
		value.go#L1767: 		tt := (*arrayType)(unsafe.Pointer(v.typ()))
		value.go#L1787: func copyVal(typ *abi.Type, fl flag, ptr unsafe.Pointer) Value {
		value.go#L1795: 	return Value{typ, *(*unsafe.Pointer)(ptr), fl}
		value.go#L1856: 	tt := (*structType)(unsafe.Pointer(v.typ()))
		value.go#L1973: 			p = *(*unsafe.Pointer)(p)
		value.go#L1998: 	tt := (*chanType)(unsafe.Pointer(v.typ()))
		value.go#L2004: 	var p unsafe.Pointer
		value.go#L2010: 		p = unsafe.Pointer(&val.ptr)
		value.go#L2031: 	tt := (*chanType)(unsafe.Pointer(v.typ()))
		value.go#L2037: 	var p unsafe.Pointer
		value.go#L2041: 		p = unsafe.Pointer(&x.ptr)
		value.go#L2053: 	var target unsafe.Pointer
		value.go#L2059: 		if x.ptr == unsafe.Pointer(&zeroVal[0]) {
		value.go#L2065: 		*(*unsafe.Pointer)(v.ptr) = x.ptr
		value.go#L2206: func (v Value) SetPointer(x unsafe.Pointer) {
		value.go#L2209: 	*(*unsafe.Pointer)(v.ptr) = x
		value.go#L2227: 		base unsafe.Pointer
		value.go#L2237: 		tt := (*arrayType)(unsafe.Pointer(v.typ()))
		value.go#L2239: 		typ = (*sliceType)(unsafe.Pointer(tt.Slice))
		value.go#L2243: 		typ = (*sliceType)(unsafe.Pointer(v.typ()))
		value.go#L2257: 		return Value{v.typ(), unsafe.Pointer(&t), v.flag}
		value.go#L2265: 	var x []unsafe.Pointer
		value.go#L2268: 	s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
		value.go#L2279: 	return Value{typ.Common(), unsafe.Pointer(&x), fl}
		value.go#L2289: 		base unsafe.Pointer
		value.go#L2299: 		tt := (*arrayType)(unsafe.Pointer(v.typ()))
		value.go#L2301: 		typ = (*sliceType)(unsafe.Pointer(tt.Slice))
		value.go#L2305: 		typ = (*sliceType)(unsafe.Pointer(v.typ()))
		value.go#L2317: 	var x []unsafe.Pointer
		value.go#L2320: 	s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
		value.go#L2331: 	return Value{typ.Common(), unsafe.Pointer(&x), fl}
		value.go#L2381: 		return (*rtype)(abi.NoEscape(unsafe.Pointer(v.typ_))) // inline of toRType(v.typ()), for own inlining in inline test
		value.go#L2413: 		tt := (*interfaceType)(unsafe.Pointer(typ))
		value.go#L2496: func (v Value) UnsafePointer() unsafe.Pointer {
		value.go#L2506: 			return *(*unsafe.Pointer)(v.ptr)
		value.go#L2520: 			return *(*unsafe.Pointer)(unsafe.Pointer(&code))
		value.go#L2526: 			p = *(*unsafe.Pointer)(p)
		value.go#L2577: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
		value.go#L2620: 	v.ptr = unsafe.Pointer(s)
		value.go#L2635: 		st := (*sliceType)(unsafe.Pointer(v.typ()))
		value.go#L2732: 	ch  unsafe.Pointer // channel
		value.go#L2733: 	val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
		value.go#L2834: 			tt := (*chanType)(unsafe.Pointer(ch.typ()))
		value.go#L2849: 				rc.val = unsafe.Pointer(&v.ptr)
		value.go#L2865: 			tt := (*chanType)(unsafe.Pointer(ch.typ()))
		value.go#L2877: 		tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ))
		value.go#L2884: 			recv = Value{t, *(*unsafe.Pointer)(p), fl}
		value.go#L2897: func unsafe_New(*abi.Type) unsafe.Pointer
		value.go#L2900: func unsafe_NewArray(*abi.Type, int) unsafe.Pointer
		value.go#L2919: 	return Value{&typ.(*rtype).t, unsafe.Pointer(&s), flagIndir | flag(Slice)}
		value.go#L2926: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
		value.go#L2929: 	return Value{SliceOf(typ).common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
		value.go#L2995: 		var p unsafe.Pointer
		value.go#L2997: 			p = unsafe.Pointer(&zeroVal[0])
		value.go#L3028: func NewAt(typ Type, p unsafe.Pointer) Value {
		value.go#L3039: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
		value.go#L3552: func chancap(ch unsafe.Pointer) int
		value.go#L3555: func chanclose(ch unsafe.Pointer)
		value.go#L3558: func chanlen(ch unsafe.Pointer) int
		value.go#L3568: func chanrecv(ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool)
		value.go#L3571: func chansend0(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool
		value.go#L3573: func chansend(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool {
		value.go#L3578: func makechan(typ *abi.Type, size int) (ch unsafe.Pointer)
		value.go#L3579: func makemap(t *abi.Type, cap int) (m unsafe.Pointer)
		value.go#L3582: func mapaccess(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
		value.go#L3585: func mapaccess_faststr(t *abi.Type, m unsafe.Pointer, key string) (val unsafe.Pointer)
		value.go#L3588: func mapassign0(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer)
		value.go#L3600: func mapassign(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer) {
		value.go#L3607: func mapassign_faststr0(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer)
		value.go#L3609: func mapassign_faststr(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer) {
		value.go#L3610: 	contentEscapes((*unsafeheader.String)(unsafe.Pointer(&key)).Data)
		value.go#L3616: func mapdelete(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer)
		value.go#L3619: func mapdelete_faststr(t *abi.Type, m unsafe.Pointer, key string)
		value.go#L3622: func maplen(m unsafe.Pointer) int
		value.go#L3624: func mapclear(t *abi.Type, m unsafe.Pointer)
		value.go#L3652: func call(stackArgsType *abi.Type, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		value.go#L3654: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
		value.go#L3659: func memmove(dst, src unsafe.Pointer, size uintptr)
		value.go#L3664: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)
		value.go#L3669: func typedmemclr(t *abi.Type, ptr unsafe.Pointer)
		value.go#L3675: func typedmemclrpartial(t *abi.Type, ptr unsafe.Pointer, off, size uintptr)
		value.go#L3687: func typedarrayclear(elemType *abi.Type, ptr unsafe.Pointer, len int)
		value.go#L3690: func typehash(t *abi.Type, p unsafe.Pointer, h uintptr) uintptr
		value.go#L3698: func unsafeslice(t *abi.Type, ptr unsafe.Pointer, len int)
		value.go#L3718: func contentEscapes(x unsafe.Pointer) {

	runtime
		alg.go#L20: func memhash0(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L24: func memhash8(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L28: func memhash16(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L32: func memhash128(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L37: func memhash_varlen(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L39: 	size := *(*uintptr)(unsafe.Pointer(ptr + unsafe.Sizeof(h)))
		alg.go#L67: func memhash(p unsafe.Pointer, h, s uintptr) uintptr
		alg.go#L69: func memhash32(p unsafe.Pointer, h uintptr) uintptr
		alg.go#L71: func memhash64(p unsafe.Pointer, h uintptr) uintptr
		alg.go#L86: func strhash(p unsafe.Pointer, h uintptr) uintptr
		alg.go#L88: func strhashFallback(a unsafe.Pointer, h uintptr) uintptr {
		alg.go#L98: func f32hash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L110: func f64hash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L122: func c64hash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L124: 	return f32hash(unsafe.Pointer(&x[1]), f32hash(unsafe.Pointer(&x[0]), h))
		alg.go#L127: func c128hash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L129: 	return f64hash(unsafe.Pointer(&x[1]), f64hash(unsafe.Pointer(&x[0]), h))
		alg.go#L132: func interhash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L147: 		return c1 * typehash(t, unsafe.Pointer(&a.data), h^c0)
		alg.go#L163: func nilinterhash(p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L174: 		return c1 * typehash(t, unsafe.Pointer(&a.data), h^c0)
		alg.go#L201: func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L225: 		i := (*interfacetype)(unsafe.Pointer(t))
		alg.go#L231: 		a := (*arraytype)(unsafe.Pointer(t))
		alg.go#L237: 		s := (*structtype)(unsafe.Pointer(t))
		alg.go#L252: func mapKeyError(t *maptype, p unsafe.Pointer) error {
		alg.go#L259: func mapKeyError2(t *_type, p unsafe.Pointer) error {
		alg.go#L267: 		i := (*interfacetype)(unsafe.Pointer(t))
		alg.go#L269: 		var pdata *unsafe.Pointer
		alg.go#L291: 			return mapKeyError2(t, unsafe.Pointer(pdata))
		alg.go#L296: 		a := (*arraytype)(unsafe.Pointer(t))
		alg.go#L304: 		s := (*structtype)(unsafe.Pointer(t))
		alg.go#L321: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L325: func memequal0(p, q unsafe.Pointer) bool {
		alg.go#L328: func memequal8(p, q unsafe.Pointer) bool {
		alg.go#L331: func memequal16(p, q unsafe.Pointer) bool {
		alg.go#L334: func memequal32(p, q unsafe.Pointer) bool {
		alg.go#L337: func memequal64(p, q unsafe.Pointer) bool {
		alg.go#L340: func memequal128(p, q unsafe.Pointer) bool {
		alg.go#L343: func f32equal(p, q unsafe.Pointer) bool {
		alg.go#L346: func f64equal(p, q unsafe.Pointer) bool {
		alg.go#L349: func c64equal(p, q unsafe.Pointer) bool {
		alg.go#L352: func c128equal(p, q unsafe.Pointer) bool {
		alg.go#L355: func strequal(p, q unsafe.Pointer) bool {
		alg.go#L358: func interequal(p, q unsafe.Pointer) bool {
		alg.go#L363: func nilinterequal(p, q unsafe.Pointer) bool {
		alg.go#L368: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
		alg.go#L384: func ifaceeq(tab *itab, x, y unsafe.Pointer) bool {
		alg.go#L412: 	return strhash(noescape(unsafe.Pointer(&s)), seed)
		alg.go#L416: 	s := (*slice)(unsafe.Pointer(&b))
		alg.go#L421: 	return memhash32(noescape(unsafe.Pointer(&i)), seed)
		alg.go#L425: 	return memhash64(noescape(unsafe.Pointer(&i)), seed)
		alg.go#L429: 	return nilinterhash(noescape(unsafe.Pointer(&i)), seed)
		alg.go#L435: 	return interhash(noescape(unsafe.Pointer(&i)), seed)
		alg.go#L467: 	key := (*[hashRandomBytes / 8]uint64)(unsafe.Pointer(&aeskeysched))
		alg.go#L474: func readUnaligned32(p unsafe.Pointer) uint32 {
		alg.go#L482: func readUnaligned64(p unsafe.Pointer) uint64 {
		arena.go#L102: func arena_newArena() unsafe.Pointer {
		arena.go#L103: 	return unsafe.Pointer(newUserArena())
		arena.go#L112: func arena_arena_New(arena unsafe.Pointer, typ any) any {
		arena.go#L117: 	te := (*ptrtype)(unsafe.Pointer(t)).Elem
		arena.go#L129: func arena_arena_Slice(arena unsafe.Pointer, slice any, cap int) {
		arena.go#L136: func arena_arena_Free(arena unsafe.Pointer) {
		arena.go#L145: 	var v unsafe.Pointer
		arena.go#L173: 		et := (*slicetype)(unsafe.Pointer(t)).Elem
		arena.go#L178: 		xe.data = unsafe.Pointer(sl)
		arena.go#L180: 		et := (*ptrtype)(unsafe.Pointer(t)).Elem
		arena.go#L252: 	refs []unsafe.Pointer
		arena.go#L279: func (a *userArena) new(typ *_type) unsafe.Pointer {
		arena.go#L299: 	typ = (*ptrtype)(unsafe.Pointer(typ)).Elem
		arena.go#L303: 	typ = (*slicetype)(unsafe.Pointer(typ)).Elem
		arena.go#L367: func (a *userArena) alloc(typ *_type, cap int) unsafe.Pointer {
		arena.go#L369: 	var x unsafe.Pointer
		arena.go#L398: 	var x unsafe.Pointer
		arena.go#L428: 	x unsafe.Pointer
		arena.go#L449: func (s *mspan) userArenaNextFree(typ *_type, cap int) unsafe.Pointer {
		arena.go#L459: 		return unsafe.Pointer(&zerobase)
		arena.go#L482: 	var ptr unsafe.Pointer
		arena.go#L487: 			ptr = unsafe.Pointer(v)
		arena.go#L492: 			ptr = unsafe.Pointer(v)
		arena.go#L539: func userArenaHeapBitsSetSliceType(typ *_type, n int, ptr unsafe.Pointer, s *mspan) {
		arena.go#L553: func userArenaHeapBitsSetType(typ *_type, ptr unsafe.Pointer, s *mspan) {
		arena.go#L737: func newUserArenaChunk() (unsafe.Pointer, *mspan) {
		arena.go#L768: 	x := unsafe.Pointer(span.base())
		arena.go#L780: 		racemalloc(unsafe.Pointer(span.base()), span.elemsize)
		arena.go#L785: 		msanmalloc(unsafe.Pointer(span.base()), span.elemsize)
		arena.go#L792: 		asanpoison(unsafe.Pointer(rzStart), span.limit-rzStart)
		arena.go#L793: 		asanunpoison(unsafe.Pointer(span.base()), span.elemsize)
		arena.go#L805: 			profilealloc(mp, unsafe.Pointer(span.base()), userArenaChunkBytes)
		arena.go#L878: 	sysFault(unsafe.Pointer(s.base()), s.npages*pageSize)
		arena.go#L907: 		racefree(unsafe.Pointer(s.base()), s.elemsize)
		arena.go#L934: func freeUserArenaChunk(s *mspan, x unsafe.Pointer) {
		arena.go#L945: 		racefree(unsafe.Pointer(s.base()), s.elemsize)
		arena.go#L948: 		msanfree(unsafe.Pointer(s.base()), s.elemsize)
		arena.go#L951: 		asanpoison(unsafe.Pointer(s.base()), s.elemsize)
		arena.go#L1044: 	sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased)
		arena.go#L1045: 	sysUsed(unsafe.Pointer(base), userArenaChunkBytes, userArenaChunkBytes)
		arena.go#L1101: 	memclrNoHeapPointers(unsafe.Pointer(s.base()), s.elemsize)
		arena.go#L1115: 	*(*uintptr)(unsafe.Pointer(&s.largeType)) = uintptr(unsafe.Pointer(s.limit))
		arena.go#L1116: 	*(*uintptr)(unsafe.Pointer(&s.largeType.GCData)) = s.limit + unsafe.Sizeof(_type{})
		asan0.go#L19: func asanread(addr unsafe.Pointer, sz uintptr)            { throw("asan") }
		asan0.go#L20: func asanwrite(addr unsafe.Pointer, sz uintptr)           { throw("asan") }
		asan0.go#L21: func asanunpoison(addr unsafe.Pointer, sz uintptr)        { throw("asan") }
		asan0.go#L22: func asanpoison(addr unsafe.Pointer, sz uintptr)          { throw("asan") }
		asan0.go#L23: func asanregisterglobals(addr unsafe.Pointer, sz uintptr) { throw("asan") }
		atomic_pointer.go#L32: func atomicwb(ptr *unsafe.Pointer, new unsafe.Pointer) {
		atomic_pointer.go#L33: 	slot := (*uintptr)(unsafe.Pointer(ptr))
		atomic_pointer.go#L42: func atomicstorep(ptr unsafe.Pointer, new unsafe.Pointer) {
		atomic_pointer.go#L44: 		atomicwb((*unsafe.Pointer)(ptr), new)
		atomic_pointer.go#L47: 		cgoCheckPtrWrite((*unsafe.Pointer)(ptr), new)
		atomic_pointer.go#L57: func atomic_storePointer(ptr *unsafe.Pointer, new unsafe.Pointer) {
		atomic_pointer.go#L58: 	atomicstorep(unsafe.Pointer(ptr), new)
		atomic_pointer.go#L66: func atomic_casPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool {
		atomic_pointer.go#L85: func sync_atomic_StorePointer(ptr *unsafe.Pointer, new unsafe.Pointer) {
		atomic_pointer.go#L92: 	sync_atomic_StoreUintptr((*uintptr)(unsafe.Pointer(ptr)), uintptr(new))
		atomic_pointer.go#L100: func sync_atomic_SwapPointer(ptr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer {
		atomic_pointer.go#L107: 	old := unsafe.Pointer(sync_atomic_SwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(new)))
		atomic_pointer.go#L116: func sync_atomic_CompareAndSwapPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool {
		atomic_pointer.go#L123: 	return sync_atomic_CompareAndSwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(old), uintptr(new))
		cgo.go#L25: 	_cgo_init                     unsafe.Pointer
		cgo.go#L26: 	_cgo_thread_start             unsafe.Pointer
		cgo.go#L27: 	_cgo_sys_thread_create        unsafe.Pointer
		cgo.go#L28: 	_cgo_notify_runtime_init_done unsafe.Pointer
		cgo.go#L29: 	_cgo_callers                  unsafe.Pointer
		cgo.go#L30: 	_cgo_set_context_function     unsafe.Pointer
		cgo.go#L31: 	_cgo_yield                    unsafe.Pointer
		cgo.go#L32: 	_cgo_pthread_key_created      unsafe.Pointer
		cgo.go#L33: 	_cgo_bindm                    unsafe.Pointer
		cgo.go#L34: 	_cgo_getstackbound            unsafe.Pointer
		cgo_mmap.go#L17: var _cgo_mmap unsafe.Pointer
		cgo_mmap.go#L23: var _cgo_munmap unsafe.Pointer
		cgo_mmap.go#L31: func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
		cgo_mmap.go#L45: 		return unsafe.Pointer(ret), 0
		cgo_mmap.go#L50: func munmap(addr unsafe.Pointer, n uintptr) {
		cgo_mmap.go#L59: func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
		cgo_mmap.go#L63: func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr
		cgo_mmap.go#L66: func sysMunmap(addr unsafe.Pointer, n uintptr)
		cgo_mmap.go#L70: func callCgoMunmap(addr unsafe.Pointer, n uintptr)
		cgo_sigaction.go#L17: var _cgo_sigaction unsafe.Pointer
		cgo_sigaction.go#L29: 		msanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
		cgo_sigaction.go#L32: 		asanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
		cgo_sigaction.go#L49: 		sp := uintptr(unsafe.Pointer(&sig))
		cgo_sigaction.go#L83: 		msanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
		cgo_sigaction.go#L86: 		asanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
		cgocall.go#L101: 	args   unsafe.Pointer
		cgocall.go#L110: func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
		cgocall.go#L111: 	as := argset{args: unsafe.Pointer(&args[0])}
		cgocall.go#L112: 	cgocall(fn, unsafe.Pointer(&as))
		cgocall.go#L134: func cgocall(fn, arg unsafe.Pointer) int32 {
		cgocall.go#L144: 		racereleasemerge(unsafe.Pointer(&racecgosync))
		cgocall.go#L205: 		raceacquire(unsafe.Pointer(&racecgosync))
		cgocall.go#L279: 		asmcgocall(_cgo_getstackbound, unsafe.Pointer(&bounds))
		cgocall.go#L301: func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
		cgocall.go#L335: 	savedsp := unsafe.Pointer(gp.syscallsp)
		cgocall.go#L337: 	savedbp := unsafe.Pointer(gp.syscallbp)
		cgocall.go#L382: func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
		cgocall.go#L399: 		p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
		cgocall.go#L400: 		atomicstorep(unsafe.Pointer(&p.array), unsafe.Pointer(&s[0]))
		cgocall.go#L406: 			p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
		cgocall.go#L438: 		raceacquire(unsafe.Pointer(&racecgosync))
		cgocall.go#L443: 	var cb func(frame unsafe.Pointer)
		cgocall.go#L445: 	*(*unsafe.Pointer)(unsafe.Pointer(&cb)) = noescape(unsafe.Pointer(&cbFV))
		cgocall.go#L449: 		racereleasemerge(unsafe.Pointer(&racecgosync))
		cgocall.go#L468: 		sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))
		cgocall.go#L549: 			p = *(*unsafe.Pointer)(p)
		cgocall.go#L561: 			pt := (*ptrtype)(unsafe.Pointer(t))
		cgocall.go#L579: 			pt := (*abi.PtrType)(unsafe.Pointer(aep._type))
		cgocall.go#L602: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
		cgocall.go#L612: 		at := (*arraytype)(unsafe.Pointer(t))
		cgocall.go#L631: 			p = *(*unsafe.Pointer)(p)
		cgocall.go#L645: 		if inheap(uintptr(unsafe.Pointer(it))) {
		cgocall.go#L648: 		p = *(*unsafe.Pointer)(add(p, goarch.PtrSize))
		cgocall.go#L657: 		st := (*slicetype)(unsafe.Pointer(t))
		cgocall.go#L682: 		st := (*structtype)(unsafe.Pointer(t))
		cgocall.go#L698: 			p = *(*unsafe.Pointer)(p)
		cgocall.go#L719: func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
		cgocall.go#L732: 			pp := *(*unsafe.Pointer)(unsafe.Pointer(addr))
		cgocall.go#L759: func cgoIsGoPointer(p unsafe.Pointer) bool {
		cgocall.go#L781: func cgoInRange(p unsafe.Pointer, start, end uintptr) bool {
		cgocheck.go#L25: func cgoCheckPtrWrite(dst *unsafe.Pointer, src unsafe.Pointer) {
		cgocheck.go#L35: 	if cgoIsGoPointer(unsafe.Pointer(dst)) {
		cgocheck.go#L61: 	if inPersistentAlloc(uintptr(unsafe.Pointer(dst))) {
		cgocheck.go#L66: 		println("write of unpinned Go pointer", hex(uintptr(src)), "to non-Go memory", hex(uintptr(unsafe.Pointer(dst))))
		cgocheck.go#L79: func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer) {
		cgocheck.go#L91: func cgoCheckMemmove2(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
		cgocheck.go#L112: func cgoCheckSliceCopy(typ *_type, dst, src unsafe.Pointer, n int) {
		cgocheck.go#L135: func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr) {
		cgocheck.go#L153: func cgoCheckBits(src unsafe.Pointer, gcbits *byte, off, size uintptr) {
		cgocheck.go#L172: 				v := *(*unsafe.Pointer)(add(src, i))
		cgocheck.go#L189: func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr) {
		chan.go#L37: 	buf      unsafe.Pointer // points to an array of dataqsiz elements
		chan.go#L106: 		c.buf = add(unsafe.Pointer(c), hchanSize)
		chan.go#L138: func chanbuf(c *hchan, i uint) unsafe.Pointer {
		chan.go#L160: func chansend1(c *hchan, elem unsafe.Pointer) {
		chan.go#L176: func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
		chan.go#L283: 	gopark(chanparkcommit, unsafe.Pointer(&c.lock), reason, traceBlockChanSend, 2)
		chan.go#L318: func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
		chan.go#L345: 	gp.param = unsafe.Pointer(sg)
		chan.go#L392: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
		chan.go#L405: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
		chan.go#L449: 		gp.param = unsafe.Pointer(sg)
		chan.go#L468: 		gp.param = unsafe.Pointer(sg)
		chan.go#L492: 		return atomic.Loadp(unsafe.Pointer(&c.sendq.first)) == nil
		chan.go#L505: func chanrecv1(c *hchan, elem unsafe.Pointer) {
		chan.go#L510: func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
		chan.go#L521: func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
		chan.go#L664: 	gopark(chanparkcommit, unsafe.Pointer(&c.lock), reason, traceBlockChanRecv, 2)
		chan.go#L699: func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
		chan.go#L737: 	gp.param = unsafe.Pointer(sg)
		chan.go#L745: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
		chan.go#L781: func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
		chan.go#L801: func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected, received bool) {
		chan.go#L806: func reflect_chansend(c *hchan, elem unsafe.Pointer, nb bool) (selected bool) {
		chan.go#L811: func reflect_chanrecv(c *hchan, nb bool, elem unsafe.Pointer) (selected bool, received bool) {
		chan.go#L918: func (c *hchan) raceaddr() unsafe.Pointer {
		chan.go#L924: 	return unsafe.Pointer(&c.buf)
		checkptr.go#L9: func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
		checkptr.go#L32: func checkptrStraddles(ptr unsafe.Pointer, size uintptr) bool {
		checkptr.go#L50: func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
		checkptr.go#L89: func checkptrBase(p unsafe.Pointer) uintptr {
		coro.go#L50: 		startfv := *(**funcval)(unsafe.Pointer(&start))
		coro.go#L125: 			print("coro: got thread ", unsafe.Pointer(mp), ", want ", unsafe.Pointer(c.mp), "\n")
		covercounter.go#L21: 			Counters: (*uint32)(unsafe.Pointer(datap.covctrs)),
		covermeta.go#L14: func addCovMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {
		cpuprof.go#L106: func (p *cpuProfile) add(tagPtr *unsafe.Pointer, stk []uintptr) {
		cpuprof.go#L243: func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
		debug.go#L49: 	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
		debug.go#L59: 	for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
		debug.go#L139: 	p.Pin(unsafe.Pointer(p))
		debugcall.go#L128: 		newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), gp, callerpc, false, waitReasonZero)
		debugcall.go#L133: 		newg.param = unsafe.Pointer(args)
		debugcall.go#L266: 	*(*unsafe.Pointer)(unsafe.Pointer(&dispatchF)) = noescape(unsafe.Pointer(&dispatchFV))
		debuglog.go#L84: 		allp := (*uintptr)(unsafe.Pointer(&allDloggers))
		debuglog.go#L85: 		all := (*dloggerImpl)(unsafe.Pointer(atomic.Loaduintptr(allp)))
		debuglog.go#L106: 		headp := (*uintptr)(unsafe.Pointer(&allDloggers))
		debuglog.go#L109: 			l.allLink = (*dloggerImpl)(unsafe.Pointer(head))
		debuglog.go#L110: 			if atomic.Casuintptr(headp, head, uintptr(unsafe.Pointer(l))) {
		debuglog.go#L346: 	if len(x) > 4 && datap.etext <= uintptr(unsafe.Pointer(strData)) && uintptr(unsafe.Pointer(strData)) < datap.end {
		debuglog.go#L352: 		l.w.uvarint(uint64(uintptr(unsafe.Pointer(strData)) - datap.etext))
		debuglog.go#L358: 		bb := (*slice)(unsafe.Pointer(&b))
		debuglog.go#L359: 		bb.array = unsafe.Pointer(strData)
		debuglog.go#L714: 			str: unsafe.Pointer(ptr),
		debuglog.go#L717: 		s := *(*string)(unsafe.Pointer(&str))
		debuglog.go#L755: 	allp := (*uintptr)(unsafe.Pointer(&allDloggers))
		debuglog.go#L756: 	all := (*dloggerImpl)(unsafe.Pointer(atomic.Loaduintptr(allp)))
		debuglog.go#L837: 		print(slicebytetostringtmp((*byte)(noescape(unsafe.Pointer(&pnanoBytes[0]))), len(pnanoBytes)))
		env_posix.go#L54: var _cgo_setenv unsafe.Pointer // pointer to C function
		env_posix.go#L65: var _cgo_unsetenv unsafe.Pointer // pointer to C function
		env_posix.go#L72: 	arg := [2]unsafe.Pointer{cstring(k), cstring(v)}
		env_posix.go#L73: 	asmcgocall(_cgo_setenv, unsafe.Pointer(&arg))
		env_posix.go#L81: 	arg := [1]unsafe.Pointer{cstring(k)}
		env_posix.go#L82: 	asmcgocall(_cgo_unsetenv, unsafe.Pointer(&arg))
		env_posix.go#L85: func cstring(s string) unsafe.Pointer {
		env_posix.go#L88: 	return unsafe.Pointer(&p[0])
		float.go#L47: 	return *(*uint64)(unsafe.Pointer(&f))
		float.go#L53: 	return *(*float64)(unsafe.Pointer(&b))
		hash64.go#L21: func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
		hash64.go#L67: func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
		hash64.go#L72: func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
		hash64.go#L82: func r4(p unsafe.Pointer) uintptr {
		hash64.go#L86: func r8(p unsafe.Pointer) uintptr {
		heapdump.go#L78: func dwrite(data unsafe.Pointer, len uintptr) {
		heapdump.go#L88: 	write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
		heapdump.go#L99: 	dwrite(unsafe.Pointer(&b), 1)
		heapdump.go#L103: 	write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
		heapdump.go#L135: 	dwrite(unsafe.Pointer(&buf), uintptr(n))
		heapdump.go#L147: func dumpmemrange(data unsafe.Pointer, len uintptr) {
		heapdump.go#L155: 		dwrite(unsafe.Pointer(&b[0]), uintptr(len(b)))
		heapdump.go#L160: 	dumpmemrange(unsafe.Pointer(unsafe.StringData(s)), uintptr(len(s)))
		heapdump.go#L195: 	dumpint(uint64(uintptr(unsafe.Pointer(t))))
		heapdump.go#L204: 		dwrite(unsafe.Pointer(unsafe.StringData(pkgpath)), uintptr(len(pkgpath)))
		heapdump.go#L206: 		dwrite(unsafe.Pointer(unsafe.StringData(name)), uintptr(len(name)))
		heapdump.go#L212: func dumpobj(obj unsafe.Pointer, size uintptr, bv bitvector) {
		heapdump.go#L219: func dumpotherroot(description string, to unsafe.Pointer) {
		heapdump.go#L225: func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype) {
		heapdump.go#L228: 	dumpint(uint64(uintptr(unsafe.Pointer(fn))))
		heapdump.go#L229: 	dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
		heapdump.go#L230: 	dumpint(uint64(uintptr(unsafe.Pointer(fint))))
		heapdump.go#L231: 	dumpint(uint64(uintptr(unsafe.Pointer(ot))))
		heapdump.go#L283: 	dumpint(uint64(uintptr(unsafe.Pointer(child.sp)))) // sp of child, or 0 if bottom of stack
		heapdump.go#L284: 	dumpmemrange(unsafe.Pointer(s.sp), s.fp-s.sp)      // frame contents
		heapdump.go#L329: 	child.sp = (*uint8)(unsafe.Pointer(s.sp))
		heapdump.go#L353: 	dumpint(uint64(uintptr(unsafe.Pointer(gp))))
		heapdump.go#L363: 	dumpint(uint64(uintptr(unsafe.Pointer(gp.m))))
		heapdump.go#L364: 	dumpint(uint64(uintptr(unsafe.Pointer(gp._defer))))
		heapdump.go#L365: 	dumpint(uint64(uintptr(unsafe.Pointer(gp._panic))))
		heapdump.go#L381: 		dumpint(uint64(uintptr(unsafe.Pointer(d))))
		heapdump.go#L382: 		dumpint(uint64(uintptr(unsafe.Pointer(gp))))
		heapdump.go#L385: 		fn := *(**funcval)(unsafe.Pointer(&d.fn))
		heapdump.go#L386: 		dumpint(uint64(uintptr(unsafe.Pointer(fn))))
		heapdump.go#L391: 			dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
		heapdump.go#L393: 		dumpint(uint64(uintptr(unsafe.Pointer(d.link))))
		heapdump.go#L397: 		dumpint(uint64(uintptr(unsafe.Pointer(p))))
		heapdump.go#L398: 		dumpint(uint64(uintptr(unsafe.Pointer(gp))))
		heapdump.go#L400: 		dumpint(uint64(uintptr(unsafe.Pointer(eface._type))))
		heapdump.go#L403: 		dumpint(uint64(uintptr(unsafe.Pointer(p.link))))
		heapdump.go#L427: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
		heapdump.go#L430: 	dumpint(uint64(uintptr(unsafe.Pointer(fn))))
		heapdump.go#L431: 	dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
		heapdump.go#L432: 	dumpint(uint64(uintptr(unsafe.Pointer(fint))))
		heapdump.go#L433: 	dumpint(uint64(uintptr(unsafe.Pointer(ot))))
		heapdump.go#L444: 	dumpmemrange(unsafe.Pointer(firstmoduledata.data), firstmoduledata.edata-firstmoduledata.data)
		heapdump.go#L450: 	dumpmemrange(unsafe.Pointer(firstmoduledata.bss), firstmoduledata.ebss-firstmoduledata.bss)
		heapdump.go#L461: 				spf := (*specialfinalizer)(unsafe.Pointer(sp))
		heapdump.go#L462: 				p := unsafe.Pointer(s.base() + uintptr(spf.special.offset))
		heapdump.go#L502: 			dumpobj(unsafe.Pointer(p), size, makeheapobjbv(p, size))
		heapdump.go#L510: 	if *(*byte)(unsafe.Pointer(&x)) == 1 {
		heapdump.go#L545: 	dumpint(uint64(uintptr(unsafe.Pointer(tab))))
		heapdump.go#L546: 	dumpint(uint64(uintptr(unsafe.Pointer(t))))
		heapdump.go#L556: 		dumpint(uint64(uintptr(unsafe.Pointer(mp))))
		heapdump.go#L601: 	stk := (*[100000]uintptr)(unsafe.Pointer(pstk))
		heapdump.go#L603: 	dumpint(uint64(uintptr(unsafe.Pointer(b))))
		heapdump.go#L660: 			spp := (*specialprofile)(unsafe.Pointer(sp))
		heapdump.go#L664: 			dumpint(uint64(uintptr(unsafe.Pointer(spp.b))))
		heapdump.go#L680: 	memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
		heapdump.go#L681: 	dwrite(unsafe.Pointer(&dumphdr[0]), uintptr(len(dumphdr)))
		heapdump.go#L709: 		sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
		heapdump.go#L727: 			sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
		histogram.go#L157: 	return *(*float64)(unsafe.Pointer(&inf))
		histogram.go#L162: 	return *(*float64)(unsafe.Pointer(&inf))
		iface.go#L64: 	t := (*itabTableType)(atomic.Loadp(unsafe.Pointer(&itabTable)))
		iface.go#L114: 		p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
		iface.go#L118: 		m := (*itab)(atomic.Loadp(unsafe.Pointer(p)))
		iface.go#L159: 		atomicstorep(unsafe.Pointer(&itabTable), unsafe.Pointer(t2))
		iface.go#L175: 		p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
		iface.go#L189: 			atomic.StorepNoWB(unsafe.Pointer(p), unsafe.Pointer(m))
		iface.go#L215: 	xmhdr := (*[1 << 16]abi.Method)(add(unsafe.Pointer(x), uintptr(x.Moff)))[:nt:nt]
		iface.go#L217: 	methods := (*[1 << 16]unsafe.Pointer)(unsafe.Pointer(&m.Fun[0]))[:ni:ni]
		iface.go#L218: 	var fun0 unsafe.Pointer
		iface.go#L334: func convT(t *_type, v unsafe.Pointer) unsafe.Pointer {
		iface.go#L348: func convTnoptr(t *_type, v unsafe.Pointer) unsafe.Pointer {
		iface.go#L365: func convT16(val uint16) (x unsafe.Pointer) {
		iface.go#L367: 		x = unsafe.Pointer(&staticuint64s[val])
		iface.go#L378: func convT32(val uint32) (x unsafe.Pointer) {
		iface.go#L380: 		x = unsafe.Pointer(&staticuint64s[val])
		iface.go#L400: func convT64(val uint64) (x unsafe.Pointer) {
		iface.go#L402: 		x = unsafe.Pointer(&staticuint64s[val])
		iface.go#L419: func convTstring(val string) (x unsafe.Pointer) {
		iface.go#L421: 		x = unsafe.Pointer(&zeroVal[0])
		iface.go#L438: func convTslice(val []byte) (x unsafe.Pointer) {
		iface.go#L440: 	if (*slice)(unsafe.Pointer(&val)).array == nil {
		iface.go#L441: 		x = unsafe.Pointer(&zeroVal[0])
		iface.go#L488: 	oldC := (*abi.TypeAssertCache)(atomic.Loadp(unsafe.Pointer(&s.Cache)))
		iface.go#L502: 	atomic_casPointer((*unsafe.Pointer)(unsafe.Pointer(&s.Cache)), unsafe.Pointer(oldC), unsafe.Pointer(newC))
		iface.go#L535: 				newEntries[h].Typ = uintptr(unsafe.Pointer(typ))
		iface.go#L536: 				newEntries[h].Itab = uintptr(unsafe.Pointer(tab))
		iface.go#L544: 			addEntry((*_type)(unsafe.Pointer(e.Typ)), (*itab)(unsafe.Pointer(e.Itab)))
		iface.go#L590: 	oldC := (*abi.InterfaceSwitchCache)(atomic.Loadp(unsafe.Pointer(&s.Cache)))
		iface.go#L605: 	atomic_casPointer((*unsafe.Pointer)(unsafe.Pointer(&s.Cache)), unsafe.Pointer(oldC), unsafe.Pointer(newC))
		iface.go#L641: 				newEntries[h].Typ = uintptr(unsafe.Pointer(typ))
		iface.go#L643: 				newEntries[h].Itab = uintptr(unsafe.Pointer(tab))
		iface.go#L651: 			addEntry((*_type)(unsafe.Pointer(e.Typ)), e.Case, (*itab)(unsafe.Pointer(e.Itab)))
		iface.go#L687: 		m := *(**itab)(add(unsafe.Pointer(&t.entries), i*goarch.PtrSize))
		lfstack.go#L40: func (head *lfstack) pop() unsafe.Pointer {
		lfstack.go#L49: 			return unsafe.Pointer(node)
		lfstack.go#L61: 	if base, _, _ := findObject(uintptr(unsafe.Pointer(node)), 0, 0); base != 0 {
		lfstack.go#L66: 		println("runtime: bad lfnode address", hex(uintptr(unsafe.Pointer(node))))
		lfstack.go#L72: 	return uint64(taggedPointerPack(unsafe.Pointer(node), cnt))
		linkname_swiss.go#L65: 	key  unsafe.Pointer
		linkname_swiss.go#L66: 	elem unsafe.Pointer
		linkname_swiss.go#L94: 		racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapiterinit))
		linkname_swiss.go#L147: 		racereadpc(unsafe.Pointer(it.it.Map()), callerpc, abi.FuncPCABIInternal(mapiternext))
		linkname_swiss.go#L191: func reflect_mapiterkey(it *linknameIter) unsafe.Pointer {
		linkname_swiss.go#L209: func reflect_mapiterelem(it *linknameIter) unsafe.Pointer {
		lock_futex.go#L18: 	return (*uint32)(unsafe.Pointer(p))
		lock_spinbit.go#L75: 		return &(*[8]uint8)(unsafe.Pointer(p))[goarch.PtrSize/1-1]
		lock_spinbit.go#L77: 	return &(*[8]uint8)(unsafe.Pointer(p))[0]
		lock_spinbit.go#L112: 	} else if m0bits := muintptr(unsafe.Pointer(&m0)); highBits == uintptr(m0bits)&^mutexMMask {
		lock_spinbit.go#L234: 		next := (uintptr(unsafe.Pointer(gp.m)) &^ mutexMMask) | v&mutexMMask | mutexSleeping
		malloc.go#L610: 			a, size := sysReserveAligned(unsafe.Pointer(p), arenaSize, heapArenaBytes)
		malloc.go#L650: func (h *mheap) sysAlloc(n uintptr, hintList **arenaHint, register bool) (v unsafe.Pointer, size uintptr) {
		malloc.go#L682: 			v = sysReserve(unsafe.Pointer(p), n)
		malloc.go#L703: 		h.arenaHintAlloc.free(unsafe.Pointer(hint))
		malloc.go#L773: 				sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
		malloc.go#L775: 				sysNoHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
		malloc.go#L777: 			atomic.StorepNoWB(unsafe.Pointer(&h.arenas[ri.l1()]), unsafe.Pointer(l2))
		malloc.go#L804: 				*(*notInHeapSlice)(unsafe.Pointer(&h.allArenas)) = notInHeapSlice{newArray, len(h.allArenas), int(size / goarch.PtrSize)}
		malloc.go#L819: 		atomic.StorepNoWB(unsafe.Pointer(&l2[ri.l2()]), unsafe.Pointer(r))
		malloc.go#L833: func sysReserveAligned(v unsafe.Pointer, size, align uintptr) (unsafe.Pointer, uintptr) {
		malloc.go#L850: 		return unsafe.Pointer(p), size + align
		malloc.go#L856: 		sysFreeOS(unsafe.Pointer(p), size+align)
		malloc.go#L858: 		p2 := sysReserve(unsafe.Pointer(p), size)
		malloc.go#L872: 		sysFreeOS(unsafe.Pointer(p), pAligned-p)
		malloc.go#L876: 			sysFreeOS(unsafe.Pointer(end), endLen)
		malloc.go#L878: 		return unsafe.Pointer(pAligned), size
		malloc.go#L914: 		l2 := (*[1 << arenaL2Bits]*heapArena)(atomic.Loadp(unsafe.Pointer(&h.arenas[i])))
		malloc.go#L918: 		sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
		malloc.go#L1010: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		malloc.go#L1019: 		return unsafe.Pointer(&zerobase)
		malloc.go#L1048: 	var x unsafe.Pointer
		malloc.go#L1098: func mallocgcTiny(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
		malloc.go#L1163: 		x := unsafe.Pointer(c.tiny + off)
		malloc.go#L1177: 	x := unsafe.Pointer(v)
		malloc.go#L1254: func mallocgcSmallNoscan(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
		malloc.go#L1285: 	x := unsafe.Pointer(v)
		malloc.go#L1340: func mallocgcSmallScanNoHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
		malloc.go#L1368: 	x := unsafe.Pointer(v)
		malloc.go#L1431: func mallocgcSmallScanHeader(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
		malloc.go#L1466: 	x := unsafe.Pointer(v)
		malloc.go#L1524: func mallocgcLarge(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
		malloc.go#L1545: 	x := unsafe.Pointer(span.base())
		malloc.go#L1614: func preMallocgcDebug(size uintptr, typ *_type) unsafe.Pointer {
		malloc.go#L1644: func postMallocgcDebug(x unsafe.Pointer, elemsize uintptr, typ *_type) {
		malloc.go#L1691: func memclrNoHeapPointersChunked(size uintptr, x unsafe.Pointer) {
		malloc.go#L1706: 		memclrNoHeapPointers(unsafe.Pointer(voff), n)
		malloc.go#L1713: func newobject(typ *_type) unsafe.Pointer {
		malloc.go#L1718: func maps_newobject(typ *_type) unsafe.Pointer {
		malloc.go#L1734: func reflect_unsafe_New(typ *_type) unsafe.Pointer {
		malloc.go#L1739: func reflectlite_unsafe_New(typ *_type) unsafe.Pointer {
		malloc.go#L1756: func newarray(typ *_type, n int) unsafe.Pointer {
		malloc.go#L1782: func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer {
		malloc.go#L1787: func maps_newarray(typ *_type, n int) unsafe.Pointer {
		malloc.go#L1795: func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
		malloc.go#L1907: func persistentalloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
		malloc.go#L1912: 	return unsafe.Pointer(p)
		malloc.go#L1962: 			chunks := uintptr(unsafe.Pointer(persistentChunks))
		malloc.go#L1963: 			*(*uintptr)(unsafe.Pointer(persistent.base)) = chunks
		malloc.go#L1964: 			if atomic.Casuintptr((*uintptr)(unsafe.Pointer(&persistentChunks)), chunks, uintptr(unsafe.Pointer(persistent.base))) {
		malloc.go#L1990: 	chunk := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&persistentChunks)))
		malloc.go#L1995: 		chunk = *(*uintptr)(unsafe.Pointer(chunk))
		malloc.go#L2026: func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
		malloc.go#L2036: 			sysMap(unsafe.Pointer(l.mapped), n, sysStat)
		malloc.go#L2037: 			sysUsed(unsafe.Pointer(l.mapped), n, n)
		malloc.go#L2041: 	return unsafe.Pointer(p)
		malloc.go#L2055: 	return (*notInHeap)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + bytes))
		map_fast32_swiss.go#L18: func mapaccess1_fast32(t *abi.SwissMapType, m *maps.Map, key uint32) unsafe.Pointer
		map_fast32_swiss.go#L29: func mapaccess2_fast32(t *abi.SwissMapType, m *maps.Map, key uint32) (unsafe.Pointer, bool)
		map_fast32_swiss.go#L41: func mapassign_fast32(t *abi.SwissMapType, m *maps.Map, key uint32) unsafe.Pointer
		map_fast32_swiss.go#L52: func mapassign_fast32ptr(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
		map_fast64_swiss.go#L18: func mapaccess1_fast64(t *abi.SwissMapType, m *maps.Map, key uint64) unsafe.Pointer
		map_fast64_swiss.go#L29: func mapaccess2_fast64(t *abi.SwissMapType, m *maps.Map, key uint64) (unsafe.Pointer, bool)
		map_fast64_swiss.go#L41: func mapassign_fast64(t *abi.SwissMapType, m *maps.Map, key uint64) unsafe.Pointer
		map_fast64_swiss.go#L53: func mapassign_fast64ptr(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
		map_faststr_swiss.go#L18: func mapaccess1_faststr(t *abi.SwissMapType, m *maps.Map, ky string) unsafe.Pointer
		map_faststr_swiss.go#L29: func mapaccess2_faststr(t *abi.SwissMapType, m *maps.Map, ky string) (unsafe.Pointer, bool)
		map_faststr_swiss.go#L41: func mapassign_faststr(t *abi.SwissMapType, m *maps.Map, s string) unsafe.Pointer
		map_swiss.go#L28: func maps_mapKeyError(t *abi.SwissMapType, p unsafe.Pointer) error {
		map_swiss.go#L89: func mapaccess1(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
		map_swiss.go#L100: func mapaccess2(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) (unsafe.Pointer, bool)
		map_swiss.go#L102: func mapaccess1_fat(t *abi.SwissMapType, m *maps.Map, key, zero unsafe.Pointer) unsafe.Pointer {
		map_swiss.go#L104: 	if e == unsafe.Pointer(&zeroVal[0]) {
		map_swiss.go#L110: func mapaccess2_fat(t *abi.SwissMapType, m *maps.Map, key, zero unsafe.Pointer) (unsafe.Pointer, bool) {
		map_swiss.go#L112: 	if e == unsafe.Pointer(&zeroVal[0]) {
		map_swiss.go#L133: func mapassign(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
		map_swiss.go#L144: func mapdelete(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) {
		map_swiss.go#L148: 		racewritepc(unsafe.Pointer(m), callerpc, pc)
		map_swiss.go#L168: 		racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapIterStart))
		map_swiss.go#L180: 		racereadpc(unsafe.Pointer(it.Map()), callerpc, abi.FuncPCABIInternal(mapIterNext))
		map_swiss.go#L191: 		racewritepc(unsafe.Pointer(m), callerpc, pc)
		map_swiss.go#L234: func reflect_mapaccess(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer {
		map_swiss.go#L244: func reflect_mapaccess_faststr(t *abi.SwissMapType, m *maps.Map, key string) unsafe.Pointer {
		map_swiss.go#L262: func reflect_mapassign(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer, elem unsafe.Pointer) {
		map_swiss.go#L268: func reflect_mapassign_faststr(t *abi.SwissMapType, m *maps.Map, key string, elem unsafe.Pointer) {
		map_swiss.go#L274: func reflect_mapdelete(t *abi.SwissMapType, m *maps.Map, key unsafe.Pointer) {
		map_swiss.go#L299: 		racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(reflect_maplen))
		map_swiss.go#L316: 		racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(reflect_maplen))
		map_swiss.go#L333: 	e.data = unsafe.Pointer(mapclone2((*abi.SwissMapType)(unsafe.Pointer(e._type)), (*maps.Map)(e.data)))
		map_swiss.go#L352: func keys(m any, p unsafe.Pointer) {
		map_swiss.go#L360: func values(m any, p unsafe.Pointer) {
		mbarrier.go#L150: func typedmemmove(typ *abi.Type, dst, src unsafe.Pointer) {
		mbarrier.go#L179: func wbZero(typ *_type, dst unsafe.Pointer) {
		mbarrier.go#L192: func wbMove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L213: func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L230: func reflectlite_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L235: func maps_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L249: func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
		mbarrier.go#L261: 			regs.Ptrs[i] = unsafe.Pointer(regs.Ints[i])
		mbarrier.go#L276: func typedslicecopy(typ *_type, dstPtr unsafe.Pointer, dstLen int, srcPtr unsafe.Pointer, srcLen int) int {
		mbarrier.go#L361: func typedmemclr(typ *_type, ptr unsafe.Pointer) {
		mbarrier.go#L380: func reflect_typedmemclr(typ *_type, ptr unsafe.Pointer) {
		mbarrier.go#L385: func maps_typedmemclr(typ *_type, ptr unsafe.Pointer) {
		mbarrier.go#L390: func reflect_typedmemclrpartial(typ *_type, ptr unsafe.Pointer, off, size uintptr) {
		mbarrier.go#L402: func reflect_typedarrayclear(typ *_type, ptr unsafe.Pointer, len int) {
		mbarrier.go#L427: func memclrHasPointers(ptr unsafe.Pointer, n uintptr) {
		mbitmap.go#L191: 		typ = *(**_type)(unsafe.Pointer(addr))
		mbitmap.go#L470: 			dstx := (*uintptr)(unsafe.Pointer(addr))
		mbitmap.go#L480: 			dstx := (*uintptr)(unsafe.Pointer(addr))
		mbitmap.go#L481: 			srcx := (*uintptr)(unsafe.Pointer(src + (addr - dst)))
		mbitmap.go#L530: 		srcx := (*uintptr)(unsafe.Pointer(addr - dst + src))
		mbitmap.go#L591: 	sl = notInHeapSlice{(*notInHeap)(unsafe.Pointer(spanBase + spanSize - bitmapSize)), elems, elems}
		mbitmap.go#L592: 	return *(*[]uintptr)(unsafe.Pointer(&sl))
		mbitmap.go#L604: 	hbits := (*byte)(unsafe.Pointer(span.base() + spanSize - bitmapSize))
		mbitmap.go#L617: 	word0 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+0))))
		mbitmap.go#L618: 	word1 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+1))))
		mbitmap.go#L670: 	dst := unsafe.Pointer(span.base() + pageSize - pageSize/goarch.PtrSize/8)
		mbitmap.go#L819: 	print("runtime: typ=", unsafe.Pointer(typ), " typ.PtrBytes=", typ.PtrBytes, "\n")
		mbitmap.go#L960: 	print("runtime: tp.elem=", hex(tp.elem), " tp.typ=", unsafe.Pointer(tp.typ), "\n")
		mbitmap.go#L980: 	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + n))
		mbitmap.go#L991: 	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - n))
		mbitmap.go#L1002: 	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 1))
		mbitmap.go#L1015: 	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - 1))
		mbitmap.go#L1044: 	bytes := (*[8]uint8)(unsafe.Pointer(s.allocBits.bytep(uintptr(whichByte))))
		mbitmap.go#L1205: 		m.bytep = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(m.bytep)) + 1))
		mbitmap.go#L1343: 			dstx := (*uintptr)(unsafe.Pointer(dst + i))
		mbitmap.go#L1348: 				srcx := (*uintptr)(unsafe.Pointer(src + i))
		mbitmap.go#L1394: 			dstx := (*uintptr)(unsafe.Pointer(dst + i))
		mbitmap.go#L1395: 			srcx := (*uintptr)(unsafe.Pointer(src + i))
		mbitmap.go#L1417: 		mrkBits := *(*uint64)(unsafe.Pointer(s.gcmarkBits.bytep(i)))
		mbitmap.go#L1426: 	x := *(*uintptr)(unsafe.Pointer(p))
		mbitmap.go#L1657: 	totalBits := (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*8 + nbits
		mbitmap.go#L1734: 	et = (*ptrtype)(unsafe.Pointer(t)).Elem
		mbitmap.go#L1790: 			if *(*byte)(unsafe.Pointer(i)) != 0 {
		mbitmap.go#L1871: 			n := (*ptrtype)(unsafe.Pointer(t)).Elem.Size_
		mcache.go#L75: 	return (*gclink)(unsafe.Pointer(p))
		mcache.go#L118: 		mheap_.cachealloc.free(unsafe.Pointer(c))
		mcleanup.go#L77: 	usptr := uintptr(unsafe.Pointer(ptr))
		mcleanup.go#L81: 		if unsafe.Pointer(ptr) == *((*unsafe.Pointer)(unsafe.Pointer(&arg))) {
		mcleanup.go#L100: 	fv := *(**funcval)(unsafe.Pointer(&fn))
		mcleanup.go#L106: 		if isGoPointerWithoutSpan(unsafe.Pointer(ptr)) {
		mcleanup.go#L116: 	id := addCleanup(unsafe.Pointer(ptr), fv)
		mcleanup.go#L142: 	span := spanOfHeap(uintptr(unsafe.Pointer(c.ptr)))
		mcleanup.go#L152: 	offset := uintptr(unsafe.Pointer(c.ptr)) - span.base()
		mcleanup.go#L166: 				(*specialCleanup)(unsafe.Pointer(s)).id == c.id {
		mcleanup.go#L191: 	mheap_.specialCleanupAlloc.free(unsafe.Pointer(found))
		mem.go#L49: func sysAlloc(n uintptr, sysStat *sysMemStat) unsafe.Pointer {
		mem.go#L60: func sysUnused(v unsafe.Pointer, n uintptr) {
		mem.go#L75: func sysUsed(v unsafe.Pointer, n, prepared uintptr) {
		mem.go#L83: func sysHugePage(v unsafe.Pointer, n uintptr) {
		mem.go#L90: func sysNoHugePage(v unsafe.Pointer, n uintptr) {
		mem.go#L96: func sysHugePageCollapse(v unsafe.Pointer, n uintptr) {
		mem.go#L113: func sysFree(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
		mem.go#L128: func sysFault(v unsafe.Pointer, n uintptr) {
		mem.go#L145: func sysReserve(v unsafe.Pointer, n uintptr) unsafe.Pointer {
		mem.go#L153: func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
		mem_linux.go#L21: func sysAllocOS(n uintptr) unsafe.Pointer {
		mem_linux.go#L41: func sysUnusedOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L84: func sysUsedOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L97: func sysHugePageOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L105: 			madvise(unsafe.Pointer(beg), end-beg, _MADV_HUGEPAGE)
		mem_linux.go#L110: func sysNoHugePageOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L119: func sysHugePageCollapseOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L148: func sysFreeOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L152: func sysFaultOS(v unsafe.Pointer, n uintptr) {
		mem_linux.go#L157: func sysReserveOS(v unsafe.Pointer, n uintptr) unsafe.Pointer {
		mem_linux.go#L165: func sysMapOS(v unsafe.Pointer, n uintptr) {
		mem_nonsbrk.go#L13: func sysReserveAlignedSbrk(size, align uintptr) (unsafe.Pointer, uintptr) {
		metrics.go#L46: 		raceacquire(unsafe.Pointer(&metricsSema))
		metrics.go#L52: 		racerelease(unsafe.Pointer(&metricsSema))
		metrics.go#L768: 	pointer unsafe.Pointer // contains non-scalar values.
		metrics.go#L781: 		v.pointer = unsafe.Pointer(hist)
		metrics.go#L833: func readMetrics(samplesp unsafe.Pointer, len int, cap int) {
		metrics.go#L848: func readMetricsLocked(samplesp unsafe.Pointer, len int, cap int) {
		metrics.go#L851: 	samples := *(*[]metricSample)(unsafe.Pointer(&sl))
		mfinal.go#L57: 	arg  unsafe.Pointer // ptr to object (may be a heap pointer)
		mfinal.go#L97: func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
		mfinal.go#L147: func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
		mfinal.go#L170: func finalizercommit(gp *g, lock unsafe.Pointer) bool {
		mfinal.go#L181: 		frame    unsafe.Pointer
		mfinal.go#L196: 			gopark(finalizercommit, unsafe.Pointer(&finlock), waitReasonFinalizerWait, traceBlockSystemGoroutine, 1)
		mfinal.go#L211: 					fn := unsafe.Pointer(f.fn)
		mfinal.go#L212: 					cleanup = *(*func())(unsafe.Pointer(&fn))
		mfinal.go#L249: 					r = unsafe.Pointer(&regs.Ints)
		mfinal.go#L260: 					*(*unsafe.Pointer)(r) = f.arg
		mfinal.go#L262: 					ityp := (*interfacetype)(unsafe.Pointer(f.fint))
		mfinal.go#L275: 				reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), &regs)
		mfinal.go#L297: func isGoPointerWithoutSpan(p unsafe.Pointer) bool {
		mfinal.go#L299: 	if p == unsafe.Pointer(&zerobase) {
		mfinal.go#L443: 	ot := (*ptrtype)(unsafe.Pointer(etyp))
		mfinal.go#L493: 	ft := (*functype)(unsafe.Pointer(ftyp))
		mfinal.go#L506: 		if (fint.Uncommon() == nil || etyp.Uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).Elem == ot.Elem {
		mfinal.go#L512: 		ityp := (*interfacetype)(unsafe.Pointer(fint))
		mfixalloc.go#L33: 	first  func(arg, p unsafe.Pointer) // called first time p is returned
		mfixalloc.go#L34: 	arg    unsafe.Pointer
		mfixalloc.go#L56: func (f *fixalloc) init(size uintptr, first func(arg, p unsafe.Pointer), arg unsafe.Pointer, stat *sysMemStat) {
		mfixalloc.go#L74: func (f *fixalloc) alloc() unsafe.Pointer {
		mfixalloc.go#L81: 		v := unsafe.Pointer(f.list)
		mfixalloc.go#L94: 	v := unsafe.Pointer(f.chunk)
		mfixalloc.go#L104: func (f *fixalloc) free(p unsafe.Pointer) {
		mgc.go#L1423: 		gopark(func(g *g, nodep unsafe.Pointer) bool {
		mgc.go#L1450: 		}, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceBlockSystemGoroutine, 0)
		mgc.go#L1765: var boringCaches []unsafe.Pointer  // for crypto/internal/boring
		mgc.go#L1783: func boring_registerCache(p unsafe.Pointer) {
		mgc.go#L1905: func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
		mgc.go#L1951: 		mheap_.specialReachableAlloc.free(unsafe.Pointer(s))
		mgc.go#L1966: func gcTestPointerClass(p unsafe.Pointer) string {
		mgcmark.go#L183: 			scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
		mgcmark.go#L278: 	ptrmask := (*uint8)(add(unsafe.Pointer(ptrmask0), uintptr(shard)*(rootBlockBytes/(8*goarch.PtrSize))))
		mgcmark.go#L389: 					spf := (*specialfinalizer)(unsafe.Pointer(sp))
		mgcmark.go#L401: 					scanblock(uintptr(unsafe.Pointer(&spf.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mgcmark.go#L404: 					spw := (*specialWeakHandle)(unsafe.Pointer(sp))
		mgcmark.go#L405: 					scanblock(uintptr(unsafe.Pointer(&spw.handle)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mgcmark.go#L407: 					spc := (*specialCleanup)(unsafe.Pointer(sp))
		mgcmark.go#L409: 					scanblock(uintptr(unsafe.Pointer(&spc.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mgcmark.go#L697: 		gp.param = unsafe.Pointer(gp)
		mgcmark.go#L899: 		scanblock(uintptr(unsafe.Pointer(&gp.sched.ctxt)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
		mgcmark.go#L916: 			scanblock(uintptr(unsafe.Pointer(&d.fn)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
		mgcmark.go#L921: 			scanblock(uintptr(unsafe.Pointer(&d.link)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
		mgcmark.go#L927: 			scanblock(uintptr(unsafe.Pointer(&d)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
		mgcmark.go#L932: 		state.putPtr(uintptr(unsafe.Pointer(gp._panic)), false)
		mgcmark.go#L990: 		putempty((*workbuf)(unsafe.Pointer(x)))
		mgcmark.go#L1360: 				p := *(*uintptr)(unsafe.Pointer(b + i))
		mgcmark.go#L1448: 		obj := *(*uintptr)(unsafe.Pointer(addr))
		mgcmark.go#L1492: 			val := *(*uintptr)(unsafe.Pointer(p))
		mgcmark.go#L1532: 		val := *(*uintptr)(unsafe.Pointer(b + i))
		mgcmark.go#L1673: 		print(" *(", label, "+", i, ") = ", hex(*(*uintptr)(unsafe.Pointer(obj + i))))
		mgcscavenge.go#L778: 				sysUnused(unsafe.Pointer(addr), uintptr(npages)*pageSize)
		mgcstack.go#L163: 	*(*uintptr)(unsafe.Pointer(&obj.r)) = uintptr(unsafe.Pointer(r))
		mgcstack.go#L213: 		buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
		mgcstack.go#L222: 			buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
		mgcstack.go#L247: 				putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
		mgcstack.go#L263: 		putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
		mgcstack.go#L274: 		x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
		mgcstack.go#L284: 		y := (*stackObjectBuf)(unsafe.Pointer(getempty()))
		mgcsweep.go#L576: 						freeSpecial(special, unsafe.Pointer(p), size)
		mgcsweep.go#L591: 					freeSpecial(special, unsafe.Pointer(p), size)
		mgcsweep.go#L598: 				(*specialReachable)(unsafe.Pointer(special)).reachable = true
		mgcsweep.go#L599: 				freeSpecial(special, unsafe.Pointer(p), size)
		mgcsweep.go#L625: 					clobberfree(unsafe.Pointer(x), size)
		mgcsweep.go#L629: 					racefree(unsafe.Pointer(x), size)
		mgcsweep.go#L632: 					msanfree(unsafe.Pointer(x), size)
		mgcsweep.go#L635: 					asanpoison(unsafe.Pointer(x), size)
		mgcsweep.go#L816: 				sysFault(unsafe.Pointer(s.base()), size)
		mgcsweep.go#L954: func clobberfree(x unsafe.Pointer, size uintptr) {
		mgcwork.go#L391: 			newb := (*workbuf)(unsafe.Pointer(s.base() + i))
		mgcwork.go#L443: 	memmove(unsafe.Pointer(&b1.obj[0]), unsafe.Pointer(&b.obj[b.nobj]), uintptr(n)*unsafe.Sizeof(b1.obj[0]))
		mheap.go#L524: func recordspan(vh unsafe.Pointer, p unsafe.Pointer) {
		mheap.go#L536: 		sp := (*slice)(unsafe.Pointer(&new))
		mheap.go#L547: 		*(*notInHeapSlice)(unsafe.Pointer(&h.allspans)) = *(*notInHeapSlice)(unsafe.Pointer(&new))
		mheap.go#L549: 			sysFree(unsafe.Pointer(&oldAllspans[0]), uintptr(cap(oldAllspans))*unsafe.Sizeof(oldAllspans[0]), &memstats.other_sys)
		mheap.go#L750: 	h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
		mheap.go#L1157: 	h.spanalloc.free(unsafe.Pointer(s))
		mheap.go#L1353: 		sysUsed(unsafe.Pointer(base), nbytes, scav)
		mheap.go#L1518: 				sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased)
		mheap.go#L1549: 	sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased)
		mheap.go#L1579: 			base := unsafe.Pointer(s.base())
		mheap.go#L1585: 			base := unsafe.Pointer(s.base())
		mheap.go#L1871: func addspecial(p unsafe.Pointer, s *special, force bool) bool {
		mheap.go#L1909: func removespecial(p unsafe.Pointer, kind uint8) *special {
		mheap.go#L1978: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
		mheap.go#L2003: 			scanblock(uintptr(unsafe.Pointer(&s.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mheap.go#L2011: 	mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
		mheap.go#L2017: func removefinalizer(p unsafe.Pointer) {
		mheap.go#L2018: 	s := (*specialfinalizer)(unsafe.Pointer(removespecial(p, _KindSpecialFinalizer)))
		mheap.go#L2023: 	mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
		mheap.go#L2040: func addCleanup(p unsafe.Pointer, f *funcval) uint64 {
		mheap.go#L2060: 		scanblock(uintptr(unsafe.Pointer(&s.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mheap.go#L2104: func internal_weak_runtime_registerWeakPointer(p unsafe.Pointer) unsafe.Pointer {
		mheap.go#L2105: 	return unsafe.Pointer(getOrAddWeakHandle(unsafe.Pointer(p)))
		mheap.go#L2109: func internal_weak_runtime_makeStrongFromWeak(u unsafe.Pointer) unsafe.Pointer {
		mheap.go#L2146: 	ptr := unsafe.Pointer(handle.Load())
		mheap.go#L2202: func getOrAddWeakHandle(p unsafe.Pointer) *atomic.Uintptr {
		mheap.go#L2229: 			scanblock(uintptr(unsafe.Pointer(&s.handle)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
		mheap.go#L2252: 	mheap_.specialWeakHandleAlloc.free(unsafe.Pointer(s))
		mheap.go#L2269: func getWeakHandle(p unsafe.Pointer) *atomic.Uintptr {
		mheap.go#L2289: 		handle = ((*specialWeakHandle)(unsafe.Pointer(*iter))).handle
		mheap.go#L2308: func setprofilebucket(p unsafe.Pointer, b *bucket) {
		mheap.go#L2363: func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
		mheap.go#L2366: 		sf := (*specialfinalizer)(unsafe.Pointer(s))
		mheap.go#L2369: 		mheap_.specialfinalizeralloc.free(unsafe.Pointer(sf))
		mheap.go#L2372: 		sw := (*specialWeakHandle)(unsafe.Pointer(s))
		mheap.go#L2375: 		mheap_.specialWeakHandleAlloc.free(unsafe.Pointer(s))
		mheap.go#L2378: 		sp := (*specialprofile)(unsafe.Pointer(s))
		mheap.go#L2381: 		mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
		mheap.go#L2384: 		sp := (*specialReachable)(unsafe.Pointer(s))
		mheap.go#L2389: 		mheap_.specialPinCounterAlloc.free(unsafe.Pointer(s))
		mheap.go#L2392: 		sc := (*specialCleanup)(unsafe.Pointer(s))
		mheap.go#L2398: 		mheap_.specialCleanupAlloc.free(unsafe.Pointer(sc))
		mheap.go#L2470: 	head := (*gcBitsArena)(atomic.Loadp(unsafe.Pointer(&gcBitsArenas.next)))
		mheap.go#L2509: 	atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), unsafe.Pointer(fresh))
		mheap.go#L2555: 	atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), nil) // newMarkBits calls newArena when needed
		mheap.go#L2573: 		memclrNoHeapPointers(unsafe.Pointer(result), gcBitsChunkBytes)
		mheap.go#L2581: 		result.free = 8 - (uintptr(unsafe.Pointer(&result.bits[0])) & 7)
		minmax.go#L57: 		*(*uint32)(unsafe.Pointer(&x)) |= *(*uint32)(unsafe.Pointer(&y))
		minmax.go#L59: 		*(*uint64)(unsafe.Pointer(&x)) |= *(*uint64)(unsafe.Pointer(&y))
		minmax.go#L67: 		*(*uint32)(unsafe.Pointer(&x)) &= *(*uint32)(unsafe.Pointer(&y))
		minmax.go#L69: 		*(*uint64)(unsafe.Pointer(&x)) &= *(*uint64)(unsafe.Pointer(&y))
		mpagealloc.go#L420: 			*(*uintptr)(unsafe.Pointer(&p.chunks[c.l1()])) = uintptr(r)
		mpagealloc.go#L472: 			sysHugePage(unsafe.Pointer(p.chunks[i]), unsafe.Sizeof(*p.chunks[0]))
		mpagealloc_64bit.go#L86: 		p.summary[l] = *(*[]pallocSum)(unsafe.Pointer(&sl))
		mpagealloc_64bit.go#L120: 		base := unsafe.Pointer(&p.summary[level][0])
		mpagealloc_64bit.go#L179: 		sysMap(unsafe.Pointer(need.base.addr()), need.size(), p.sysStat)
		mpagealloc_64bit.go#L180: 		sysUsed(unsafe.Pointer(need.base.addr()), need.size(), need.size())
		mpagealloc_64bit.go#L222: 	chunksBase := uintptr(unsafe.Pointer(&s.chunks[0]))
		mpagealloc_64bit.go#L232: 		sysMap(unsafe.Pointer(need.base.addr()), need.size(), sysStat)
		mpagealloc_64bit.go#L233: 		sysUsed(unsafe.Pointer(need.base.addr()), need.size(), need.size())
		mpagealloc_64bit.go#L253: 	s.chunks = *(*[]atomicScavChunkData)(unsafe.Pointer(&sl))
		mprof.go#L248: 	stk := (*[maxProfStackDepth]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
		mprof.go#L261: 	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
		mprof.go#L270: 	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
		mprof.go#L286: 			buckhash.StoreNoWB(unsafe.Pointer(bh))
		mprof.go#L345: 	bh[i].StoreNoWB(unsafe.Pointer(b))
		mprof.go#L346: 	allnext.StoreNoWB(unsafe.Pointer(b))
		mprof.go#L437: func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
		mprof.go#L563: 			nstk = fpTracebackPartialExpand(skip, unsafe.Pointer(getfp()), mp.profStack)
		mprof.go#L566: 			nstk = 1 + fpTracebackPartialExpand(skip, unsafe.Pointer(gp.m.curg.sched.bp), mp.profStack[1:])
		mprof.go#L578: func fpTracebackPartialExpand(skip int, fp unsafe.Pointer, pcBuf []uintptr) int {
		mprof.go#L592: 		pc := *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))
		mprof.go#L615: 		fp = unsafe.Pointer(*(*uintptr)(fp))
		mprof.go#L738: 	if uintptr(unsafe.Pointer(l)) == prof.pending {
		mprof.go#L765: 	prof.pending = uintptr(unsafe.Pointer(l))
		mprof.go#L773: 	if uintptr(unsafe.Pointer(l)) == prof.pending {
		mprof.go#L1083: 		racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(MemProfile))
		mprof.go#L1086: 		msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
		mprof.go#L1089: 		asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
		mprof.go#L1197: 		racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(BlockProfile))
		mprof.go#L1200: 		msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
		mprof.go#L1203: 		asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
		mprof.go#L1290: 	first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
		mprof.go#L1313: func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
		mprof.go#L1318: func goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
		mprof.go#L1331: 	labels  []unsafe.Pointer
		mprof.go#L1369: func goroutineProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
		mprof.go#L1465: 		raceacquire(unsafe.Pointer(&labelSync))
		mprof.go#L1583: func goroutineProfileWithLabelsSync(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
		mprof.go#L1646: 		raceacquire(unsafe.Pointer(&labelSync))
		mranges.go#L255: 	ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
		mranges.go#L382: 			ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
		mranges.go#L452: 		ranges := (*notInHeapSlice)(unsafe.Pointer(&b.ranges))
		msan0.go#L19: func msanread(addr unsafe.Pointer, sz uintptr)     { throw("msan") }
		msan0.go#L20: func msanwrite(addr unsafe.Pointer, sz uintptr)    { throw("msan") }
		msan0.go#L21: func msanmalloc(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
		msan0.go#L22: func msanfree(addr unsafe.Pointer, sz uintptr)     { throw("msan") }
		msan0.go#L23: func msanmove(dst, src unsafe.Pointer, sz uintptr) { throw("msan") }
		mspanset.go#L294: 	p unsafe.Pointer
		mspanset.go#L403: 	p.p.StoreNoWB(unsafe.Pointer(s))
		mwbbuf.go#L79: 	start := uintptr(unsafe.Pointer(&b.buf[0]))
		mwbbuf.go#L85: 		b.end = uintptr(unsafe.Pointer(&b.buf[wbMaxEntriesPerCall+1]))
		mwbbuf.go#L101: 	b.next = uintptr(unsafe.Pointer(&b.buf[0]))
		mwbbuf.go#L106: 	return b.next == uintptr(unsafe.Pointer(&b.buf[0]))
		mwbbuf.go#L135: 	p := (*[1]uintptr)(unsafe.Pointer(b.next))
		mwbbuf.go#L146: 	p := (*[2]uintptr)(unsafe.Pointer(b.next))
		mwbbuf.go#L197: 	start := uintptr(unsafe.Pointer(&pp.wbBuf.buf[0]))
		netpoll.go#L529: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
		netpoll.go#L530: 	r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
		netpoll.go#L575: 		gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceBlockNet, 5)
		netpoll.go#L617: 			return (*g)(unsafe.Pointer(old))
		netpoll.go#L720: 	x := (*eface)(unsafe.Pointer(&i))
		netpoll.go#L722: 	x.data = unsafe.Pointer(&pd.self)
		netpoll_epoll.go#L36: 	*(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollEventFd
		netpoll_epoll.go#L52: 	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
		netpoll_epoll.go#L53: 	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
		netpoll_epoll.go#L76: 		n := write(netpollEventFd, noescape(unsafe.Pointer(&one)), oneSize)
		netpoll_epoll.go#L140: 		if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollEventFd {
		netpoll_epoll.go#L152: 				read(int32(netpollEventFd), noescape(unsafe.Pointer(&one)), int32(unsafe.Sizeof(one)))
		netpoll_epoll.go#L166: 			tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
		os_linux.go#L43: func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32
		os_linux.go#L75: 		futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, nil, nil, 0)
		os_linux.go#L81: 	futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, unsafe.Pointer(&ts), nil, 0)
		os_linux.go#L88: 	ret := futex(unsafe.Pointer(addr), _FUTEX_WAKE_PRIVATE, cnt, nil, nil, 0)
		os_linux.go#L100: 	*(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
		os_linux.go#L167: func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32
		os_linux.go#L173: 	stk := unsafe.Pointer(mp.g0.stack.hi)
		os_linux.go#L186: 		r := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(abi.FuncPCABI0(mstart)))
		os_linux.go#L208: func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
		os_linux.go#L214: 	ret := clone(cloneFlags, unsafe.Pointer(uintptr(stack)+stacksize), nil, nil, fn)
		os_linux.go#L235: func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
		os_linux.go#L251: 	auxvp := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*goarch.PtrSize))
		os_linux.go#L272: 			err := mincore(unsafe.Pointer(uintptr(p)+n), 1, &addrspace_vec[0])
		os_linux.go#L285: 	n = read(fd, noescape(unsafe.Pointer(&auxvreadbuf[0])), int32(unsafe.Sizeof(auxvreadbuf)))
		os_linux.go#L314: 			startupRand = (*[16]byte)(unsafe.Pointer(val))[:]
		os_linux.go#L337: 	ptr := noescape(unsafe.Pointer(&numbuf[0]))
		os_linux.go#L368: 	n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
		os_linux.go#L527: 	*(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
		os_linux.go#L923: func mprotect(addr unsafe.Pointer, n uintptr, prot int32) (ret int32, errno int32) {
		panic.go#L416: 	return (*_defer)(unsafe.Pointer(uintptr(1)))
		panic.go#L424: 		racewritepc(unsafe.Pointer(head), sys.GetCallerPC(), abi.FuncPCABIInternal(deferprocat))
		panic.go#L448: 		racereadpc(unsafe.Pointer(head), sys.GetCallerPC(), abi.FuncPCABIInternal(deferconvert))
		panic.go#L506: 	*(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
		panic.go#L507: 	*(*uintptr)(unsafe.Pointer(&d.head)) = 0
		panic.go#L508: 	*(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))
		panic.go#L604: 	p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
		panic.go#L630: 	p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
		panic.go#L692: func readvarintUnsafe(fd unsafe.Pointer) (uint32, unsafe.Pointer) {
		panic.go#L786: 	p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
		panic.go#L818: func (p *_panic) start(pc uintptr, sp unsafe.Pointer) {
		panic.go#L826: 	p.startSP = unsafe.Pointer(sys.GetCallerSP())
		panic.go#L846: 	gp._panic = (*_panic)(noescape(unsafe.Pointer(p)))
		panic.go#L965: 			if p.initOpenCodedDefers(u.frame.fn, unsafe.Pointer(u.frame.varp)) {
		panic.go#L973: 		p.sp = unsafe.Pointer(u.frame.sp)
		panic.go#L974: 		p.fp = unsafe.Pointer(u.frame.fp)
		panic.go#L982: func (p *_panic) initOpenCodedDefers(fn funcInfo, varp unsafe.Pointer) bool {
		panic.go#L1192: 		gp.param = unsafe.Pointer(&savedOpenDeferState{
		panic.go#L1198: 			deferBitsOffset: uintptr(unsafe.Pointer(p0.deferBitsPtr)) - uintptr(p0.sp),
		pinner.go#L83: 	pinnerRefStoreSize = (pinnerSize - unsafe.Sizeof([]unsafe.Pointer{})) / unsafe.Sizeof(unsafe.Pointer(nil))
		pinner.go#L87: 	refs     []unsafe.Pointer
		pinner.go#L88: 	refStore [pinnerRefStoreSize]unsafe.Pointer
		pinner.go#L101: 	p.refStore = [pinnerRefStoreSize]unsafe.Pointer{}
		pinner.go#L105: func pinnerGetPtr(i *any) unsafe.Pointer {
		pinner.go#L125: func isPinned(ptr unsafe.Pointer) bool {
		pinner.go#L149: func setPinned(ptr unsafe.Pointer, pin bool) bool {
		pinner.go#L285: 	return (*pinnerBits)(atomic.Loadp(unsafe.Pointer(&s.pinnerBits)))
		pinner.go#L289: 	atomicstorep(unsafe.Pointer(&s.pinnerBits), unsafe.Pointer(p))
		pinner.go#L308: 	for _, x := range unsafe.Slice((*uint64)(unsafe.Pointer(&p.x)), bytes/8) {
		pinner.go#L317: 		memmove(unsafe.Pointer(&newPinnerBits.x), unsafe.Pointer(&p.x), bytes)
		pinner.go#L337: 		*ref = (*special)(unsafe.Pointer(rec))
		pinner.go#L340: 		rec = (*specialPinCounter)(unsafe.Pointer(*ref))
		pinner.go#L352: 	counter := (*specialPinCounter)(unsafe.Pointer(*ref))
		pinner.go#L360: 		mheap_.specialPinCounterAlloc.free(unsafe.Pointer(counter))
		pinner.go#L368: func pinnerGetPinCounter(addr unsafe.Pointer) *uintptr {
		pinner.go#L375: 	counter := (*specialPinCounter)(unsafe.Pointer(*t))
		plugin.go#L84: 		symName := resolveNameOff(unsafe.Pointer(md.types), ptab.name)
		plugin.go#L85: 		t := toRType((*_type)(unsafe.Pointer(md.types))).typeOff(ptab.typ) // TODO can this stack of conversions be simpler?
		plugin.go#L87: 		valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&val))
		plugin.go#L88: 		(*valp)[0] = unsafe.Pointer(t)
		plugin.go#L107: 		f := funcInfo{(*_func)(unsafe.Pointer(&md.pclntable[md.ftab[i].funcoff])), md}
		print.go#L17: 	rp := (*slice)(unsafe.Pointer(&ret))
		print.go#L238: func printpointer(p unsafe.Pointer) {
		print.go#L250: 	sp := (*slice)(unsafe.Pointer(&s))
		print.go#L288: 		val := *(*uintptr)(unsafe.Pointer(p + i))
		proc.go#L418: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceReason traceBlockReason, traceskip int) {
		proc.go#L441: 	gopark(parkunlock_c, unsafe.Pointer(lock), reason, traceReason, traceskip)
		proc.go#L669: 		atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
		proc.go#L692: 	ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
		proc.go#L698: 	return *(**g)(add(unsafe.Pointer(ptr), i*goarch.PtrSize))
		proc.go#L971: 	atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
		proc.go#L1809: 		gp.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
		proc.go#L1847: 	gp.sched.g = guintptr(unsafe.Pointer(gp))
		proc.go#L2186: var cgoThreadStart unsafe.Pointer
		proc.go#L2191: 	fn  unsafe.Pointer
		proc.go#L2437: 	gp.sched.g = guintptr(unsafe.Pointer(gp))
		proc.go#L2620: 		asmcgocall(_cgo_bindm, unsafe.Pointer(g))
		proc.go#L2636: 	return uintptr(unsafe.Pointer(getg().m))
		proc.go#L2685: 			return (*m)(unsafe.Pointer(old))
		proc.go#L2695: 	extraM.Store(uintptr(unsafe.Pointer(mp)))
		proc.go#L2833: 		ts.tls = (*uint64)(unsafe.Pointer(&mp.tls[0]))
		proc.go#L2834: 		ts.fn = unsafe.Pointer(abi.FuncPCABI0(mstart))
		proc.go#L2836: 			msanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
		proc.go#L2839: 			asanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
		proc.go#L2842: 		asmcgocall(_cgo_thread_start, unsafe.Pointer(&ts))
		proc.go#L4105: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
		proc.go#L5030: 		*(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
		proc.go#L5082: 		*(*uintptr)(unsafe.Pointer(sp)) = 0
		proc.go#L5087: 		*(*uintptr)(unsafe.Pointer(sp - goarch.PtrSize)) = 0
		proc.go#L5090: 	memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
		proc.go#L5094: 	newg.sched.g = guintptr(unsafe.Pointer(newg))
		proc.go#L5155: 			racereleasemergeg(newg, unsafe.Pointer(&labelSync))
		proc.go#L5287: 			racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5290: 			msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5293: 			asanunpoison(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5569: 		var tagPtr *unsafe.Pointer
		proc.go#L5707: 			mheap_.spanalloc.free(unsafe.Pointer(pp.mspancache.buf[i]))
		proc.go#L5809: 		atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
		proc.go#L5883: 	atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
		proc.go#L6740: 		runnext := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&pp.runnext)))
		proc.go#L6782: 		if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
		proc.go#L7367: 		firstFunc := add(unsafe.Pointer(t), 8)
		proc.go#L7370: 			f := *(*func())(unsafe.Pointer(&p))
		proc.go#L7379: 			f := *(*func())(unsafe.Pointer(&firstFunc))
		profbuf.go#L97: 	tags    []unsafe.Pointer
		profbuf.go#L230: 	b.tags = make([]unsafe.Pointer, tags)
		profbuf.go#L303: func (b *profBuf) write(tagPtr *unsafe.Pointer, now int64, hdr []uint64, stk []uintptr) {
		profbuf.go#L351: 		*(*uintptr)(unsafe.Pointer(&b.tags[wt])) = uintptr(*tagPtr)
		profbuf.go#L427: var overflowTag [1]unsafe.Pointer // always nil
		profbuf.go#L429: func (b *profBuf) read(mode profBufReadMode) (data []uint64, tags []unsafe.Pointer, eof bool) {
		profbuf.go#L553: 		raceacquire(unsafe.Pointer(&labelSync))
		proflabel.go#L20: func runtime_setProfLabel(labels unsafe.Pointer) {
		proflabel.go#L40: 		racereleasemerge(unsafe.Pointer(&labelSync))
		proflabel.go#L54: func runtime_getProfLabel() unsafe.Pointer {
		race0.go#L19: func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr)  { throw("race") }
		race0.go#L20: func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
		race0.go#L25: func racemapshadow(addr unsafe.Pointer, size uintptr)                       { throw("race") }
		race0.go#L26: func racewritepc(addr unsafe.Pointer, callerpc, pc uintptr)                 { throw("race") }
		race0.go#L27: func racereadpc(addr unsafe.Pointer, callerpc, pc uintptr)                  { throw("race") }
		race0.go#L28: func racereadrangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr)         { throw("race") }
		race0.go#L29: func racewriterangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr)        { throw("race") }
		race0.go#L30: func raceacquire(addr unsafe.Pointer)                                       { throw("race") }
		race0.go#L31: func raceacquireg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L32: func raceacquirectx(racectx uintptr, addr unsafe.Pointer)                   { throw("race") }
		race0.go#L33: func racerelease(addr unsafe.Pointer)                                       { throw("race") }
		race0.go#L34: func racereleaseg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L35: func racereleaseacquire(addr unsafe.Pointer)                                { throw("race") }
		race0.go#L36: func racereleaseacquireg(gp *g, addr unsafe.Pointer)                        { throw("race") }
		race0.go#L37: func racereleasemerge(addr unsafe.Pointer)                                  { throw("race") }
		race0.go#L38: func racereleasemergeg(gp *g, addr unsafe.Pointer)                          { throw("race") }
		race0.go#L40: func racemalloc(p unsafe.Pointer, sz uintptr)                               { throw("race") }
		race0.go#L41: func racefree(p unsafe.Pointer, sz uintptr)                                 { throw("race") }
		rand.go#L245: 	t := (*[2]uint32)(unsafe.Pointer(&mp.cheaprand))
		runtime.go#L174: 			racereleasemerge(unsafe.Pointer(&g.inc))
		runtime.go#L181: 		raceacquire(unsafe.Pointer(&g.inc))
		runtime.go#L232: 	write(2, unsafe.Pointer(data), n)
		runtime.go#L239: 			write(fd, unsafe.Pointer(data), n)
		runtime1.go#L63: 	return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*goarch.PtrSize))
		runtime1.go#L154: 		k     unsafe.Pointer
		runtime1.go#L255: 	*(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
		runtime1.go#L263: 	*(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
		runtime1.go#L271: 	*(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
		runtime1.go#L279: 	*(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
		runtime1.go#L636: func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
		runtime1.go#L638: 	sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
		runtime1.go#L641: 		sections = append(sections, unsafe.Pointer(md.types))
		runtime1.go#L658: func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
		runtime1.go#L659: 	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
		runtime1.go#L676: func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
		runtime1.go#L677: 	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
		runtime1.go#L691: func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
		runtime1.go#L698: func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
		runtime1.go#L699: 	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
		runtime1.go#L705: func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
		runtime1.go#L706: 	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
		runtime1.go#L712: func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
		runtime1.go#L715: 		reflectOffs.m = make(map[int32]unsafe.Pointer)
		runtime1.go#L716: 		reflectOffs.minv = make(map[unsafe.Pointer]int32)
		runtime2.go#L181: 	data unsafe.Pointer
		runtime2.go#L186: 	data  unsafe.Pointer
		runtime2.go#L190: 	return (*eface)(unsafe.Pointer(ep))
		runtime2.go#L240: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
		runtime2.go#L243: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
		runtime2.go#L247: 	return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
		runtime2.go#L252: 	return guintptr(unsafe.Pointer(gp))
		runtime2.go#L261: 	(*guintptr)(unsafe.Pointer(gp)).set(new)
		runtime2.go#L267: func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
		runtime2.go#L270: func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
		runtime2.go#L284: func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
		runtime2.go#L287: func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
		runtime2.go#L295: 	(*muintptr)(unsafe.Pointer(mp)).set(new)
		runtime2.go#L314: 	ctxt unsafe.Pointer
		runtime2.go#L339: 	elem unsafe.Pointer // data element (may point to stack)
		runtime2.go#L429: 	param        unsafe.Pointer
		runtime2.go#L483: 	labels        unsafe.Pointer // profiler labels
		runtime2.go#L583: 	waitunlockf          func(*g, unsafe.Pointer) bool
		runtime2.go#L584: 	waitlock             unsafe.Pointer
		runtime2.go#L997: 	argp unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
		runtime2.go#L1003: 	startSP unsafe.Pointer
		runtime2.go#L1006: 	sp unsafe.Pointer
		runtime2.go#L1008: 	fp unsafe.Pointer
		runtime2.go#L1016: 	slotsPtr     unsafe.Pointer
		runtime2.go#L1306: 		fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's FP.
		runtime2.go#L1307: 		fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's caller's FP.
		select.go#L22: 	elem unsafe.Pointer // data element
		select.go#L63: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
		select.go#L130: 	cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
		select.go#L131: 	order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
		select.go#L144: 		pc1 := (*[1 << 16]uintptr)(unsafe.Pointer(pc0))
		select.go#L260: 		qp     unsafe.Pointer
		select.go#L546: 	return uintptr(unsafe.Pointer(c))
		select.go#L553: 	typ unsafe.Pointer // channel type (not used here)
		select.go#L555: 	val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
		sema.go#L57: 	return &t[(uintptr(unsafe.Pointer(addr))>>3)%semTabSize].root
		sema.go#L297: 	s.elem = unsafe.Pointer(addr)
		sema.go#L305: 		if t.elem == unsafe.Pointer(addr) {
		sema.go#L351: 		if uintptr(unsafe.Pointer(addr)) < uintptr(t.elem) {
		sema.go#L397: 		if s.elem == unsafe.Pointer(addr) {
		sema.go#L400: 		if uintptr(unsafe.Pointer(addr)) < uintptr(s.elem) {
		signal_amd64.go#L54: 		pc := (*[4]byte)(unsafe.Pointer(gp.sigpc))
		signal_amd64.go#L72: 	if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
		signal_amd64.go#L84: 	*(*uintptr)(unsafe.Pointer(sp)) = resumePC
		signal_linux_amd64.go#L14: 	ctxt unsafe.Pointer
		signal_linux_amd64.go#L20: 	return (*sigcontext)(unsafe.Pointer(&(*ucontext)(c.ctxt).uc_mcontext))
		signal_linux_amd64.go#L55: 	*(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x)
		signal_unix.go#L411: 				gp := *(**g)(unsafe.Pointer(s.base()))
		signal_unix.go#L431: func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
		signal_unix.go#L515: func sigprofNonGo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
		signal_unix.go#L556: 	sp := uintptr(unsafe.Pointer(&sig))
		signal_unix.go#L563: 	stsp := uintptr(unsafe.Pointer(st.ss_sp))
		signal_unix.go#L640: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
		signal_unix.go#L668: 	if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
		signal_unix.go#L879: 		b := (*[maxN]byte)(unsafe.Pointer(pc))
		signal_unix.go#L1141: 		*(*uintptr)(unsafe.Pointer(uintptr(123))) = 2
		signal_unix.go#L1153: func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
		signal_unix.go#L1162: func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
		signal_unix.go#L1425: 	stsp := uintptr(unsafe.Pointer(st.ss_sp))
		slice.go#L16: 	array unsafe.Pointer
		slice.go#L38: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
		slice.go#L55: 	var to unsafe.Pointer
		slice.go#L101: func makeslice(et *_type, len, cap int) unsafe.Pointer {
		slice.go#L119: func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
		slice.go#L177: func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
		slice.go#L197: 		return slice{unsafe.Pointer(&zerobase), newLen, newLen}
		slice.go#L262: 	var p unsafe.Pointer
		slice.go#L355: func slicecopy(toPtr unsafe.Pointer, toLen int, fromPtr unsafe.Pointer, fromLen int, width uintptr) int {
		stack.go#L363: 	var v unsafe.Pointer
		stack.go#L390: 		v = unsafe.Pointer(x)
		stack.go#L415: 		v = unsafe.Pointer(s.base())
		stack.go#L448: 	v := unsafe.Pointer(stk.lo)
		stack.go#L579: func adjustpointer(adjinfo *adjustinfo, vpp unsafe.Pointer) {
		stack.go#L611: func adjustpointers(scanp unsafe.Pointer, bv *bitvector, adjinfo *adjustinfo, f funcInfo) {
		stack.go#L647: 					ppu := (*unsafe.Pointer)(unsafe.Pointer(pp))
		stack.go#L648: 					if !atomic.Casp1(ppu, unsafe.Pointer(p), unsafe.Pointer(p+delta)) {
		stack.go#L678: 			bp := *(*uintptr)(unsafe.Pointer(frame.varp))
		stack.go#L689: 		adjustpointer(adjinfo, unsafe.Pointer(frame.varp))
		stack.go#L697: 		adjustpointers(unsafe.Pointer(frame.varp-size), &locals, adjinfo, f)
		stack.go#L705: 		adjustpointers(unsafe.Pointer(frame.argp), &args, adjinfo, funcInfo{})
		stack.go#L728: 					adjustpointer(adjinfo, unsafe.Pointer(p+i))
		stack.go#L736: 	adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.ctxt))
		stack.go#L749: 	adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.bp))
		stack.go#L755: 			memmove(unsafe.Pointer(gp.sched.bp), unsafe.Pointer(oldfp), goarch.PtrSize)
		stack.go#L756: 			adjustpointer(adjinfo, unsafe.Pointer(gp.sched.bp))
		stack.go#L765: 	adjustpointer(adjinfo, unsafe.Pointer(&gp._defer))
		stack.go#L767: 		adjustpointer(adjinfo, unsafe.Pointer(&d.fn))
		stack.go#L768: 		adjustpointer(adjinfo, unsafe.Pointer(&d.sp))
		stack.go#L769: 		adjustpointer(adjinfo, unsafe.Pointer(&d.link))
		stack.go#L776: 	adjustpointer(adjinfo, unsafe.Pointer(&gp._panic))
		stack.go#L783: 		adjustpointer(adjinfo, unsafe.Pointer(&s.elem))
		stack.go#L789: 		*(*byte)(unsafe.Pointer(p)) = b
		stack.go#L841: 		memmove(unsafe.Pointer(newBot), unsafe.Pointer(oldBot), sgsize)
		stack.go#L914: 	memmove(unsafe.Pointer(new.hi-ncopy), unsafe.Pointer(old.hi-ncopy), ncopy)
		stack.go#L1132: 	var fn unsafe.Pointer
		stack.go#L1134: 		fn = unsafe.Pointer(fv.fn)
		stack.go#L1136: 		fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
		stack.go#L1138: 	gostartcall(gobuf, fn, unsafe.Pointer(fv))
		stack.go#L1289: 	ptr := uintptr(unsafe.Pointer(r))
		stack.go#L1301: 	return uintptr(r.ptrBytes), (*byte)(unsafe.Pointer(res))
		stkframe.go#L133: 		mv := *(**reflectMethodValue)(unsafe.Pointer(arg0))
		stkframe.go#L137: 		retValid := *(*bool)(unsafe.Pointer(arg0 + 4*goarch.PtrSize))
		stkframe.go#L269: 	ptr := uintptr(unsafe.Pointer(&methodValueCallFrameObjs[0]))
		stkframe.go#L284: 		gcdataoff: uint32(uintptr(unsafe.Pointer(getGCMask(abiRegArgsType))) - mod.rodata),
		string.go#L133: 		racereadrangepc(unsafe.Pointer(ptr),
		string.go#L139: 		msanread(unsafe.Pointer(ptr), uintptr(n))
		string.go#L142: 		asanread(unsafe.Pointer(ptr), uintptr(n))
		string.go#L145: 		p := unsafe.Pointer(&staticuint64s[*ptr])
		string.go#L152: 	var p unsafe.Pointer
		string.go#L154: 		p = unsafe.Pointer(buf)
		string.go#L158: 	memmove(p, unsafe.Pointer(ptr), uintptr(n))
		string.go#L165: 	ptr := uintptr(unsafe.Pointer(unsafe.StringData(s)))
		string.go#L196: 		racereadrangepc(unsafe.Pointer(ptr),
		string.go#L202: 		msanread(unsafe.Pointer(ptr), uintptr(n))
		string.go#L205: 		asanread(unsafe.Pointer(ptr), uintptr(n))
		string.go#L248: 		racereadrangepc(unsafe.Pointer(&a[0]),
		string.go#L254: 		msanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
		string.go#L257: 		asanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
		string.go#L277: 	str unsafe.Pointer
		string.go#L288: 	return (*stringStruct)(unsafe.Pointer(sp))
		string.go#L323: 	*(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
		string.go#L338: 	*(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(mem / 4)}
		string.go#L353: 	memmove(bp, unsafe.Pointer(p), uintptr(n))
		string.go#L355: 	*(*slice)(unsafe.Pointer(&b)) = slice{bp, n, n}
		string.go#L368: 	memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
		string.go#L384: 	memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
		string.go#L553: 		p := (*[maxAlloc/2 - 1]byte)(unsafe.Pointer(s))
		string.go#L568: 	ptr := unsafe.Pointer(s)
		string.go#L575: 		t := *(*string)(unsafe.Pointer(&stringStruct{ptr, safeLen}))
		string.go#L581: 		ptr = unsafe.Pointer(uintptr(ptr) + uintptr(safeLen))
		string.go#L591: 	p := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(s))
		string.go#L601: 	ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
		string.go#L602: 	s := *(*string)(unsafe.Pointer(&ss))
		string.go#L608: 	str := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(strw))
		stubs.go#L24: func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
		stubs.go#L25: 	return unsafe.Pointer(uintptr(p) + x)
		stubs.go#L108: func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
		stubs.go#L111: func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
		stubs.go#L145: func memmove(to, from unsafe.Pointer, n uintptr)
		stubs.go#L148: func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
		stubs.go#L167: func memequal(a, b unsafe.Pointer, size uintptr) bool
		stubs.go#L189: func noescape(p unsafe.Pointer) unsafe.Pointer {
		stubs.go#L191: 	return unsafe.Pointer(x ^ 0)
		stubs.go#L199: 	x := uintptr(unsafe.Pointer(p))
		stubs.go#L200: 	return (*T)(unsafe.Pointer(x ^ 0))
		stubs.go#L264: func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L311: func asmcgocall(fn, arg unsafe.Pointer) int32
		stubs.go#L339: func call16(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L340: func call32(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L341: func call64(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L342: func call128(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L343: func call256(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L344: func call512(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L345: func call1024(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L346: func call2048(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L347: func call4096(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L348: func call8192(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L349: func call16384(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L350: func call32768(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L351: func call65536(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L352: func call131072(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L353: func call262144(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L354: func call524288(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L355: func call1048576(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L356: func call2097152(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L357: func call4194304(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L358: func call8388608(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L359: func call16777216(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L360: func call33554432(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L361: func call67108864(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L362: func call134217728(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L363: func call268435456(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L364: func call536870912(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L365: func call1073741824(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		stubs.go#L395: func memequal_varlen(a, b unsafe.Pointer) bool
		stubs.go#L401: 	return int(*(*uint8)(unsafe.Pointer(&x)))
		stubs2.go#L16: func read(fd int32, p unsafe.Pointer, n int32) int32
		stubs2.go#L32: func write1(fd uintptr, p unsafe.Pointer, n int32) int32
		stubs2.go#L38: func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32
		stubs_amd64.go#L42: func asmcgocall_no_g(fn, arg unsafe.Pointer)
		stubs_linux.go#L19: func connect(fd int32, addr unsafe.Pointer, len int32) int32
		symtab.go#L347: 	return (*_func)(unsafe.Pointer(f))
		symtab.go#L358: 	ptr := uintptr(unsafe.Pointer(f))
		symtab.go#L364: 		base := uintptr(unsafe.Pointer(&datap.pclntable[0]))
		symtab.go#L510: 	p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
		symtab.go#L544: 			md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), scanDataSize)
		symtab.go#L546: 			md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), scanBSSSize)
		symtab.go#L568: 	atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
		symtab.go#L631: 			f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap}
		symtab.go#L632: 			f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap}
		symtab.go#L639: 				println("\t", hex(datap.ftab[j].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}))
		symtab.go#L777: 	return (*Func)(unsafe.Pointer(fi))
		symtab.go#L787: 		fi := (*funcinl)(unsafe.Pointer(fn))
		symtab.go#L797: 		fi := (*funcinl)(unsafe.Pointer(fn))
		symtab.go#L810: 		fi := (*funcinl)(unsafe.Pointer(fn))
		symtab.go#L824: 		fi := (*funcinl)(unsafe.Pointer(fn))
		symtab.go#L855: 	return (*Func)(unsafe.Pointer(f._func))
		symtab.go#L910: 	ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
		symtab.go#L919: 	return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap}
		symtab.go#L1200: 	return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
		symtab.go#L1229: func funcdata(f funcInfo, i uint8) unsafe.Pointer {
		symtab.go#L1234: 	p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4
		symtab.go#L1235: 	off := *(*uint32)(unsafe.Pointer(p))
		symtab.go#L1244: 	return unsafe.Pointer(raw & mask)
		synctest.go#L145: func (sg *synctestGroup) raceaddr() unsafe.Pointer {
		synctest.go#L150: 	return unsafe.Pointer(sg)
		synctest.go#L177: 	fv := *(**funcval)(unsafe.Pointer(&f))
		synctest.go#L218: func synctestidle_c(gp *g, _ unsafe.Pointer) bool {
		synctest.go#L265: func synctestwait_c(gp *g, _ unsafe.Pointer) bool {
		sys_x86.go#L16: func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
		sys_x86.go#L19: 	*(*uintptr)(unsafe.Pointer(sp)) = buf.pc
		tagptr_64bit.go#L57: func taggedPointerPack(ptr unsafe.Pointer, tag uintptr) taggedPointer {
		tagptr_64bit.go#L71: func (tp taggedPointer) pointer() unsafe.Pointer {
		tagptr_64bit.go#L75: 		return unsafe.Pointer(uintptr(int64(tp) >> tagBits << 3))
		tagptr_64bit.go#L78: 		return unsafe.Pointer(uintptr((tp >> aixTagBits << 3) | 0xa<<56))
		tagptr_64bit.go#L81: 		return unsafe.Pointer(uintptr(tp >> riscv64TagBits << 3))
		tagptr_64bit.go#L83: 	return unsafe.Pointer(uintptr(tp >> tagBits << 3))
		time.go#L346: func resetForSleep(gp *g, _ unsafe.Pointer) bool {
		time.go#L355: 	c    unsafe.Pointer // <-chan time.Time
		time.go#L369: 		racerelease(unsafe.Pointer(&t.timer))
		time.go#L405: 		racerelease(unsafe.Pointer(&t.timer))
		time.go#L1076: 		raceacquirectx(tsLocal.raceCtx, unsafe.Pointer(t))
		time_nofake.go#L48: var overrideWrite func(fd uintptr, p unsafe.Pointer, n int32) int32
		time_nofake.go#L53: func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
		trace.go#L652: 		raceacquire(unsafe.Pointer(&trace.doneSema[gen%2]))
		trace.go#L673: 				sysFree(unsafe.Pointer(buf), unsafe.Sizeof(*buf), &memstats.other_sys)
		trace.go#L758: 		gopark(func(gp *g, _ unsafe.Pointer) bool {
		trace.go#L858: 					racerelease(unsafe.Pointer(&trace.doneSema[gen%2]))
		trace.go#L878: 				racerelease(unsafe.Pointer(&trace.doneSema[gen%2]))
		trace.go#L1016: 		raceacquire(unsafe.Pointer(&s.lock))
		trace.go#L1020: 		racerelease(unsafe.Pointer(&s.lock))
		trace.go#L1035: 		raceacquire(unsafe.Pointer(&s.lock))
		trace.go#L1049: 		racerelease(unsafe.Pointer(&s.lock))
		trace.go#L1065: 		raceacquire(unsafe.Pointer(&s.lock))
		trace.go#L1074: 		racerelease(unsafe.Pointer(&s.lock))
		traceback.go#L178: 			frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
		traceback.go#L181: 			frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
		traceback.go#L373: 				frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
		traceback.go#L378: 				frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
		traceback.go#L502: 		x := *(*uintptr)(unsafe.Pointer(frame.sp))
		traceback.go#L656: func printArgs(f funcInfo, argp unsafe.Pointer, pc uintptr) {
		traceback.go#L995: 				argp := unsafe.Pointer(u.frame.argp)
		traceback.go#L1522: func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer) {
		traceback.go#L1544: var cgoTraceback unsafe.Pointer
		traceback.go#L1545: var cgoContext unsafe.Pointer
		traceback.go#L1546: var cgoSymbolizer unsafe.Pointer
		traceback.go#L1637: 		msanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
		traceback.go#L1640: 		asanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
		traceback.go#L1642: 	call(cgoSymbolizer, noescape(unsafe.Pointer(arg)))
		traceback.go#L1658: 		buf:     (*uintptr)(noescape(unsafe.Pointer(&buf[0]))),
		traceback.go#L1662: 		msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
		traceback.go#L1665: 		asanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
		traceback.go#L1667: 	call(cgoTraceback, noescape(unsafe.Pointer(&arg)))
		tracemap.go#L67: func (tab *traceMap) put(data unsafe.Pointer, size uintptr) (uint64, bool) {
		tracemap.go#L97: 			if m.CompareAndSwapNoWB(nil, unsafe.Pointer(newNode)) {
		tracemap.go#L106: 			if memequal(unsafe.Pointer(&n.data[0]), data, size) {
		tracemap.go#L115: func (tab *traceMap) newTraceMapNode(data unsafe.Pointer, size, hash uintptr, id uint64) *traceMapNode {
		tracemap.go#L122: 	memmove(unsafe.Pointer(sl.array), data, size)
		tracemap.go#L125: 	meta := (*traceMapNode)(unsafe.Pointer(tab.mem.alloc(unsafe.Sizeof(traceMapNode{}))))
		tracemap.go#L126: 	*(*notInHeapSlice)(unsafe.Pointer(&meta.data)) = sl
		traceregion.go#L57: 			return (*notInHeap)(unsafe.Pointer(&block.data[r-n]))
		traceregion.go#L71: 			return (*notInHeap)(unsafe.Pointer(&block.data[r-n]))
		traceregion.go#L88: 	x := (*notInHeap)(unsafe.Pointer(&block.data[0]))
		traceregion.go#L91: 	a.current.Store(unsafe.Pointer(block))
		traceregion.go#L105: 		sysFree(unsafe.Pointer(block), unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys)
		tracestack.go#L64: 				print("runtime: gp=", unsafe.Pointer(gp), " gp.goid=", gp.goid, " status=", gStatusStrings[status], "\n")
		tracestack.go#L93: 			nstk += fpTracebackPCs(unsafe.Pointer(getfp()), pcBuf[1:])
		tracestack.go#L113: 				nstk += 1 + fpTracebackPCs(unsafe.Pointer(gp.syscallbp), pcBuf[2:])
		tracestack.go#L116: 				nstk += 1 + fpTracebackPCs(unsafe.Pointer(gp.sched.bp), pcBuf[2:])
		tracestack.go#L142: 	id, _ := t.tab.put(noescape(unsafe.Pointer(&pcs[0])), uintptr(len(pcs))*unsafe.Sizeof(uintptr(0)))
		tracestack.go#L160: 	stack := unsafe.Slice((*uintptr)(unsafe.Pointer(&node.data[0])), uintptr(len(node.data))/unsafe.Sizeof(uintptr(0)))
		tracestack.go#L255: func fpTracebackPCs(fp unsafe.Pointer, pcBuf []uintptr) (i int) {
		tracestack.go#L258: 		pcBuf[i] = *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))
		tracestack.go#L260: 		fp = unsafe.Pointer(*(*uintptr)(fp))
		tracetype.go#L30: 	id, _ := t.tab.put(noescape(unsafe.Pointer(&typ)), goarch.PtrSize)
		tracetype.go#L47: 	typ := (*abi.Type)(*(*unsafe.Pointer)(unsafe.Pointer(&node.data[0])))
		tracetype.go#L67: 	w.varint(uint64(uintptr(unsafe.Pointer(typ))))
		type.go#L69: 		st := (*structtype)(unsafe.Pointer(t.Type))
		type.go#L72: 		it := (*interfacetype)(unsafe.Pointer(t.Type))
		type.go#L105: 	addr := unsafe.Pointer(t.GCData)
		type.go#L124: 			if !atomic.Casp1((*unsafe.Pointer)(addr), nil, unsafe.Pointer(&inProgress)) {
		type.go#L136: 			atomic.StorepNoWB(addr, unsafe.Pointer(p))
		type.go#L272: 	m    map[int32]unsafe.Pointer
		type.go#L273: 	minv map[unsafe.Pointer]int32
		type.go#L279: 		raceacquire(unsafe.Pointer(&reflectOffs.lock))
		type.go#L285: 		racerelease(unsafe.Pointer(&reflectOffs.lock))
		type.go#L290: func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {
		type.go#L302: 			return name{Bytes: (*byte)(unsafe.Pointer(res))}
		type.go#L321: 	return resolveNameOff(unsafe.Pointer(t.Type), off)
		type.go#L324: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
		type.go#L359: 	return (*_type)(unsafe.Pointer(res))
		type.go#L363: 	return resolveTypeOff(unsafe.Pointer(t.Type), off)
		type.go#L366: func (t rtype) textOff(off textOff) unsafe.Pointer {
		type.go#L370: 		return unsafe.Pointer(abi.FuncPCABIInternal(unreachableMethod))
		type.go#L372: 	base := uintptr(unsafe.Pointer(t.Type))
		type.go#L394: 	return unsafe.Pointer(res)
		type.go#L426: 	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.Data(off)))[:])
		type.go#L427: 	pkgPathName := resolveNameOff(unsafe.Pointer(n.Bytes), nameOff)
		type.go#L447: 				t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
		type.go#L469: 				t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
		type.go#L547: 		at := (*arraytype)(unsafe.Pointer(t))
		type.go#L548: 		av := (*arraytype)(unsafe.Pointer(v))
		type.go#L551: 		ct := (*chantype)(unsafe.Pointer(t))
		type.go#L552: 		cv := (*chantype)(unsafe.Pointer(v))
		type.go#L555: 		ft := (*functype)(unsafe.Pointer(t))
		type.go#L556: 		fv := (*functype)(unsafe.Pointer(v))
		type.go#L574: 		it := (*interfacetype)(unsafe.Pointer(t))
		type.go#L575: 		iv := (*interfacetype)(unsafe.Pointer(v))
		type.go#L587: 			tname := resolveNameOff(unsafe.Pointer(tm), tm.Name)
		type.go#L588: 			vname := resolveNameOff(unsafe.Pointer(vm), vm.Name)
		type.go#L595: 			tityp := resolveTypeOff(unsafe.Pointer(tm), tm.Typ)
		type.go#L596: 			vityp := resolveTypeOff(unsafe.Pointer(vm), vm.Typ)
		type.go#L604: 			mt := (*abi.SwissMapType)(unsafe.Pointer(t))
		type.go#L605: 			mv := (*abi.SwissMapType)(unsafe.Pointer(v))
		type.go#L608: 		mt := (*abi.OldMapType)(unsafe.Pointer(t))
		type.go#L609: 		mv := (*abi.OldMapType)(unsafe.Pointer(v))
		type.go#L612: 		pt := (*ptrtype)(unsafe.Pointer(t))
		type.go#L613: 		pv := (*ptrtype)(unsafe.Pointer(v))
		type.go#L616: 		st := (*slicetype)(unsafe.Pointer(t))
		type.go#L617: 		sv := (*slicetype)(unsafe.Pointer(v))
		type.go#L620: 		st := (*structtype)(unsafe.Pointer(t))
		type.go#L621: 		sv := (*structtype)(unsafe.Pointer(v))
		unsafe.go#L13: func unsafestring(ptr unsafe.Pointer, len int) {
		unsafe.go#L27: func unsafestring64(ptr unsafe.Pointer, len64 int64) {
		unsafe.go#L35: func unsafestringcheckptr(ptr unsafe.Pointer, len64 int64) {
		unsafe.go#L54: func unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
		unsafe.go#L75: func unsafeslice64(et *_type, ptr unsafe.Pointer, len64 int64) {
		unsafe.go#L83: func unsafeslicecheckptr(et *_type, ptr unsafe.Pointer, len64 int64) {
		unsafe.go#L118: func reflect_unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
		vdso_linux.go#L106: 	info.loadAddr = uintptr(unsafe.Pointer(hdr))
		vdso_linux.go#L108: 	pt := unsafe.Pointer(info.loadAddr + uintptr(hdr.e_phoff))
		vdso_linux.go#L126: 			dyn = (*[vdsoDynSize]elfDyn)(unsafe.Pointer(info.loadAddr + uintptr(pt.p_offset)))
		vdso_linux.go#L146: 			info.symstrings = (*[vdsoSymStringsSize]byte)(unsafe.Pointer(p))
		vdso_linux.go#L148: 			info.symtab = (*[vdsoSymTabSize]elfSym)(unsafe.Pointer(p))
		vdso_linux.go#L150: 			hash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
		vdso_linux.go#L152: 			gnuhash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
		vdso_linux.go#L154: 			info.versym = (*[vdsoVerSymSize]uint16)(unsafe.Pointer(p))
		vdso_linux.go#L156: 			info.verdef = (*elfVerdef)(unsafe.Pointer(p))
		vdso_linux.go#L196: 			aux := (*elfVerdaux)(add(unsafe.Pointer(def), uintptr(def.vd_aux)))
		vdso_linux.go#L205: 		def = (*elfVerdef)(add(unsafe.Pointer(def), uintptr(def.vd_next)))
		vdso_linux.go#L282: 		info1 := (*vdsoInfo)(noescape(unsafe.Pointer(&info)))
		vdso_linux.go#L283: 		vdsoInitFromSysinfoEhdr(info1, (*elfEhdr)(unsafe.Pointer(val)))
		vgetrandom_linux.go#L36: 	if vgetrandom1(nil, 0, 0, uintptr(unsafe.Pointer(&params)), ^uintptr(0)) != 0 {

	runtime/cgo
		callbacks.go#L140: var _cgo_yield unsafe.Pointer
		linux.go#L26: var cgo_libc_setegid = unsafe.Pointer(&_cgo_libc_setegid)
		linux.go#L32: var cgo_libc_seteuid = unsafe.Pointer(&_cgo_libc_seteuid)
		linux.go#L38: var cgo_libc_setregid = unsafe.Pointer(&_cgo_libc_setregid)
		linux.go#L44: var cgo_libc_setresgid = unsafe.Pointer(&_cgo_libc_setresgid)
		linux.go#L50: var cgo_libc_setresuid = unsafe.Pointer(&_cgo_libc_setresuid)
		linux.go#L56: var cgo_libc_setreuid = unsafe.Pointer(&_cgo_libc_setreuid)
		linux.go#L62: var cgo_libc_setgroups = unsafe.Pointer(&_cgo_libc_setgroups)
		linux.go#L68: var cgo_libc_setgid = unsafe.Pointer(&_cgo_libc_setgid)
		linux.go#L74: var cgo_libc_setuid = unsafe.Pointer(&_cgo_libc_setuid)
		35ecbc01c116bd35989833b4c19548bb631e16537a61f6cf6fc2841cdb0db557-d#L10: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
		35ecbc01c116bd35989833b4c19548bb631e16537a61f6cf6fc2841cdb0db557-d#L24: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32

	runtime/pprof
		map.go#L24: 	tag      unsafe.Pointer
		map.go#L28: func (m *profMap) lookup(stk []uint64, tag unsafe.Pointer) *profMapEntry {
		pprof.go#L740: 	return writeRuntimeProfile(w, debug, "threadcreate", func(p []profilerecord.StackRecord, _ []unsafe.Pointer) (n int, ok bool) {
		pprof.go#L779: func writeRuntimeProfile(w io.Writer, debug int, name string, fetch func([]profilerecord.StackRecord, []unsafe.Pointer) (int, bool)) error {
		pprof.go#L787: 	var labels []unsafe.Pointer
		pprof.go#L795: 		labels = make([]unsafe.Pointer, n+10)
		pprof.go#L809: 	labels []unsafe.Pointer
		pprof.go#L865: func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
		pprof.go#L978: func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool)
		proto.go#L278: func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
		runtime.go#L27: func runtime_setProfLabel(labels unsafe.Pointer)
		runtime.go#L30: func runtime_getProfLabel() unsafe.Pointer
		runtime.go#L37: 	runtime_setProfLabel(unsafe.Pointer(ctxLabels))

	slices
		slices.go#L454: 	return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
		slices.go#L455: 		uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)

	strings
		builder.go#L33: 		b.addr = (*Builder)(abi.NoEscape(unsafe.Pointer(b)))

	sync
		cond.go#L104: 	if uintptr(*c) != uintptr(unsafe.Pointer(c)) &&
		cond.go#L105: 		!atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) &&
		cond.go#L106: 		uintptr(*c) != uintptr(unsafe.Pointer(c)) {
		pool.go#L54: 	local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
		pool.go#L57: 	victim     unsafe.Pointer // local from previous cycle
		pool.go#L92: func poolRaceAddr(x any) unsafe.Pointer {
		pool.go#L93: 	ptr := uintptr((*[2]unsafe.Pointer)(unsafe.Pointer(&x))[1])
		pool.go#L95: 	return unsafe.Pointer(&poolRaceHash[h%uint32(len(poolRaceHash))])
		pool.go#L242: 	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
		pool.go#L300: func indexLocal(l unsafe.Pointer, i int) *poolLocal {
		pool.go#L301: 	lp := unsafe.Pointer(uintptr(l) + uintptr(i)*unsafe.Sizeof(poolLocal{}))
		poolqueue.go#L48: 	typ, val unsafe.Pointer
		poolqueue.go#L101: 	*(*any)(unsafe.Pointer(slot)) = val
		poolqueue.go#L134: 	val := *(*any)(unsafe.Pointer(slot))
		poolqueue.go#L169: 	val := *(*any)(unsafe.Pointer(slot))
		runtime2.go#L17: 	head   unsafe.Pointer
		runtime2.go#L18: 	tail   unsafe.Pointer
		rwmutex.go#L69: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L78: 		race.Acquire(unsafe.Pointer(&rw.readerSem))
		rwmutex.go#L89: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L103: 				race.Acquire(unsafe.Pointer(&rw.readerSem))
		rwmutex.go#L116: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L117: 		race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
		rwmutex.go#L146: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L159: 		race.Acquire(unsafe.Pointer(&rw.readerSem))
		rwmutex.go#L160: 		race.Acquire(unsafe.Pointer(&rw.writerSem))
		rwmutex.go#L171: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L189: 		race.Acquire(unsafe.Pointer(&rw.readerSem))
		rwmutex.go#L190: 		race.Acquire(unsafe.Pointer(&rw.writerSem))
		rwmutex.go#L203: 		race.Read(unsafe.Pointer(&rw.w))
		rwmutex.go#L204: 		race.Release(unsafe.Pointer(&rw.readerSem))
		waitgroup.go#L49: 			race.ReleaseMerge(unsafe.Pointer(wg))
		waitgroup.go#L61: 		race.Read(unsafe.Pointer(&wg.sema))
		waitgroup.go#L105: 				race.Acquire(unsafe.Pointer(wg))
		waitgroup.go#L116: 				race.Write(unsafe.Pointer(&wg.sema))
		waitgroup.go#L124: 				race.Acquire(unsafe.Pointer(wg))

	sync/atomic
		doc.go#L87: func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
		doc.go#L109: func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
		doc.go#L193: func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
		doc.go#L215: func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
		type.go#L50: 	v unsafe.Pointer
		type.go#L57: func (x *Pointer[T]) Store(val *T) { StorePointer(&x.v, unsafe.Pointer(val)) }
		type.go#L60: func (x *Pointer[T]) Swap(new *T) (old *T) { return (*T)(SwapPointer(&x.v, unsafe.Pointer(new))) }
		type.go#L64: 	return CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
		value.go#L22: 	typ  unsafe.Pointer
		value.go#L23: 	data unsafe.Pointer
		value.go#L29: 	vp := (*efaceWords)(unsafe.Pointer(v))
		value.go#L31: 	if typ == nil || typ == unsafe.Pointer(&firstStoreInProgress) {
		value.go#L36: 	vlp := (*efaceWords)(unsafe.Pointer(&val))
		value.go#L51: 	vp := (*efaceWords)(unsafe.Pointer(v))
		value.go#L52: 	vlp := (*efaceWords)(unsafe.Pointer(&val))
		value.go#L60: 			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
		value.go#L70: 		if typ == unsafe.Pointer(&firstStoreInProgress) {
		value.go#L94: 	vp := (*efaceWords)(unsafe.Pointer(v))
		value.go#L95: 	np := (*efaceWords)(unsafe.Pointer(&new))
		value.go#L104: 			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
		value.go#L114: 		if typ == unsafe.Pointer(&firstStoreInProgress) {
		value.go#L124: 		op := (*efaceWords)(unsafe.Pointer(&old))
		value.go#L139: 	vp := (*efaceWords)(unsafe.Pointer(v))
		value.go#L140: 	np := (*efaceWords)(unsafe.Pointer(&new))
		value.go#L141: 	op := (*efaceWords)(unsafe.Pointer(&old))
		value.go#L156: 			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
		value.go#L166: 		if typ == unsafe.Pointer(&firstStoreInProgress) {
		value.go#L183: 		(*efaceWords)(unsafe.Pointer(&i)).typ = typ
		value.go#L184: 		(*efaceWords)(unsafe.Pointer(&i)).data = data

	syscall
		exec_linux.go#L165: 		RawSyscall(SYS_WRITE, uintptr(mapPipe[1]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
		exec_linux.go#L323: 			clone3.pidFD = uint64(uintptr(unsafe.Pointer(&pidfd)))
		exec_linux.go#L332: 		pid, err1 = rawVforkSyscall(_SYS_clone3, uintptr(unsafe.Pointer(clone3)), unsafe.Sizeof(*clone3), 0)
		exec_linux.go#L338: 			pid, err1 = rawVforkSyscall(SYS_CLONE, 0, flags, uintptr(unsafe.Pointer(&pidfd)))
		exec_linux.go#L340: 			pid, err1 = rawVforkSyscall(SYS_CLONE, flags, 0, uintptr(unsafe.Pointer(&pidfd)))
		exec_linux.go#L368: 		pid, _, err1 = RawSyscall(SYS_READ, uintptr(mapPipe[0]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
		exec_linux.go#L408: 		_, _, err1 = RawSyscall(SYS_IOCTL, uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
		exec_linux.go#L427: 			if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&psetgroups[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
		exec_linux.go#L430: 			pid, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&setgroups[0])), uintptr(len(setgroups)))
		exec_linux.go#L438: 			if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&pgid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
		exec_linux.go#L441: 			pid, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&gidmap[0])), uintptr(len(gidmap)))
		exec_linux.go#L452: 			if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&puid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
		exec_linux.go#L455: 			pid, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&uidmap[0])), uintptr(len(uidmap)))
		exec_linux.go#L472: 			_, _, err1 = RawSyscall6(SYS_MOUNT, uintptr(unsafe.Pointer(&none[0])), uintptr(unsafe.Pointer(&slash[0])), 0, MS_REC|MS_PRIVATE, 0, 0)
		exec_linux.go#L481: 		_, _, err1 = RawSyscall(SYS_CHROOT, uintptr(unsafe.Pointer(chroot)), 0, 0)
		exec_linux.go#L492: 			groups = uintptr(unsafe.Pointer(&cred.Groups[0]))
		exec_linux.go#L515: 		if _, _, err1 = RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
		exec_linux.go#L526: 		if _, _, err1 = RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
		exec_linux.go#L540: 		_, _, err1 = RawSyscall(SYS_CHDIR, uintptr(unsafe.Pointer(dir)), 0, 0)
		exec_linux.go#L649: 		_, _, err1 = RawSyscall6(SYS_PRLIMIT64, 0, RLIMIT_NOFILE, 0, uintptr(unsafe.Pointer(&lim)), 0, 0)
		exec_linux.go#L651: 			RawSyscall6(SYS_PRLIMIT64, 0, RLIMIT_NOFILE, uintptr(unsafe.Pointer(rlim)), 0, 0, 0)
		exec_linux.go#L667: 		uintptr(unsafe.Pointer(argv0)),
		exec_linux.go#L668: 		uintptr(unsafe.Pointer(&argv[0])),
		exec_linux.go#L669: 		uintptr(unsafe.Pointer(&envv[0])))
		exec_linux.go#L673: 	RawSyscall(SYS_WRITE, uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
		exec_linux.go#L829: 		pid, errno = rawVforkSyscall(SYS_CLONE, 0, flags, uintptr(unsafe.Pointer(pidfd)))
		exec_linux.go#L831: 		pid, errno = rawVforkSyscall(SYS_CLONE, flags, 0, uintptr(unsafe.Pointer(pidfd)))
		exec_unix.go#L220: 		n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
		exec_unix.go#L297: 			uintptr(unsafe.Pointer(argv0p)),
		exec_unix.go#L298: 			uintptr(unsafe.Pointer(&argvp[0])),
		exec_unix.go#L299: 			uintptr(unsafe.Pointer(&envvp[0])))
		exec_unix.go#L308: 			uintptr(unsafe.Pointer(argv0p)),
		exec_unix.go#L309: 			uintptr(unsafe.Pointer(&argvp[0])),
		exec_unix.go#L310: 			uintptr(unsafe.Pointer(&envvp[0])))
		flock_linux.go#L15: 	_, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
		lsf_linux.go#L32: 	p := (*[2]byte)(unsafe.Pointer(&lsall.Protocol))
		lsf_linux.go#L58: 	_, _, ep := Syscall(SYS_IOCTL, uintptr(s), SIOCGIFFLAGS, uintptr(unsafe.Pointer(&ifl)))
		lsf_linux.go#L67: 	_, _, ep = Syscall(SYS_IOCTL, uintptr(s), SIOCSIFFLAGS, uintptr(unsafe.Pointer(&ifl)))
		lsf_linux.go#L78: 	p.Filter = (*SockFilter)(unsafe.Pointer(&i[0]))
		lsf_linux.go#L79: 	return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, unsafe.Pointer(&p), unsafe.Sizeof(p))
		lsf_linux.go#L85: 	return setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, unsafe.Pointer(&dummy), unsafe.Sizeof(dummy))
		netlink_linux.go#L34: 	*(*uint32)(unsafe.Pointer(&b[0:4][0])) = rr.Header.Len
		netlink_linux.go#L35: 	*(*uint16)(unsafe.Pointer(&b[4:6][0])) = rr.Header.Type
		netlink_linux.go#L36: 	*(*uint16)(unsafe.Pointer(&b[6:8][0])) = rr.Header.Flags
		netlink_linux.go#L37: 	*(*uint32)(unsafe.Pointer(&b[8:12][0])) = rr.Header.Seq
		netlink_linux.go#L38: 	*(*uint32)(unsafe.Pointer(&b[12:16][0])) = rr.Header.Pid
		netlink_linux.go#L140: 	h := (*NlMsghdr)(unsafe.Pointer(&b[0]))
		netlink_linux.go#L183: 	a := (*RtAttr)(unsafe.Pointer(&b[0]))
		sockcmsg_linux.go#L16: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_linux.go#L37: 	ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
		sockcmsg_unix.go#L27: func (h *Cmsghdr) data(offset uintptr) unsafe.Pointer {
		sockcmsg_unix.go#L28: 	return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)) + offset)
		sockcmsg_unix.go#L55: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_unix.go#L67: 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
		sockcmsg_unix.go#L88: 		fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
		syscall_linux.go#L150: 	_, _, err := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(&c.hdr)), uintptr(unsafe.Pointer(&c.data[0])), 0)
		syscall_linux.go#L346: 	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
		syscall_linux.go#L355: 	return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
		syscall_linux.go#L362: 	return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
		syscall_linux.go#L421: var cgo_libc_setgroups unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L443: 		if _, _, e1 := AllThreadsSyscall(_SYS_setgroups, n, uintptr(unsafe.Pointer(&a[0])), 0); e1 != 0 {
		syscall_linux.go#L448: 	if ret := cgocaller(cgo_libc_setgroups, n, uintptr(unsafe.Pointer(&a[0]))); ret != 0 {
		syscall_linux.go#L526: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L531: 	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
		syscall_linux.go#L535: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
		syscall_linux.go#L538: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L543: 	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
		syscall_linux.go#L548: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
		syscall_linux.go#L551: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L576: 	return unsafe.Pointer(&sa.raw), sl, nil
		syscall_linux.go#L589: func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L600: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
		syscall_linux.go#L611: func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
		syscall_linux.go#L616: 	return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
		syscall_linux.go#L622: 		pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
		syscall_linux.go#L631: 		pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
		syscall_linux.go#L642: 		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
		syscall_linux.go#L662: 		sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
		syscall_linux.go#L666: 		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
		syscall_linux.go#L668: 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_linux.go#L674: 		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
		syscall_linux.go#L676: 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_linux.go#L718: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
		syscall_linux.go#L725: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L732: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L739: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L746: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L753: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L760: 	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
		syscall_linux.go#L765: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
		syscall_linux.go#L770: 	msg.Name = (*byte)(unsafe.Pointer(rsa))
		syscall_linux.go#L804: func sendmsgN(fd int, p, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
		syscall_linux.go#L865: 		err = ptracePtr(req, pid, addr-addr%sizeofPtr, unsafe.Pointer(&buf[0]))
		syscall_linux.go#L877: 		err = ptracePtr(req, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
		syscall_linux.go#L905: 		err = ptracePtr(peekReq, pid, addr-addr%sizeofPtr, unsafe.Pointer(&buf[0]))
		syscall_linux.go#L910: 		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
		syscall_linux.go#L920: 		word := *((*uintptr)(unsafe.Pointer(&data[0])))
		syscall_linux.go#L932: 		err = ptracePtr(peekReq, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
		syscall_linux.go#L937: 		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
		syscall_linux.go#L962: 	iov.Base = (*byte)(unsafe.Pointer(regsout))
		syscall_linux.go#L964: 	return ptracePtr(PTRACE_GETREGSET, pid, uintptr(_NT_PRSTATUS), unsafe.Pointer(&iov))
		syscall_linux.go#L969: 	iov.Base = (*byte)(unsafe.Pointer(regs))
		syscall_linux.go#L971: 	return ptracePtr(PTRACE_SETREGSET, pid, uintptr(_NT_PRSTATUS), unsafe.Pointer(&iov))
		syscall_linux.go#L980: 	err = ptracePtr(PTRACE_GETEVENTMSG, pid, 0, unsafe.Pointer(&data))
		syscall_linux.go#L1144: func cgocaller(unsafe.Pointer, ...uintptr) uintptr
		syscall_linux.go#L1146: var cgo_libc_setegid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1161: var cgo_libc_seteuid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1174: var cgo_libc_setgid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1187: var cgo_libc_setregid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1200: var cgo_libc_setresgid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1213: var cgo_libc_setresuid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1226: var cgo_libc_setreuid unsafe.Pointer // non-nil if cgo linked.
		syscall_linux.go#L1239: var cgo_libc_setuid unsafe.Pointer // non-nil if cgo linked.
		syscall_unix.go#L62: 	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), length)
		syscall_unix.go#L87: 	if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
		syscall_unix.go#L186: 			race.WriteRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L189: 			race.Acquire(unsafe.Pointer(&ioSync))
		syscall_unix.go#L193: 		msan.Write(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L196: 		asan.Write(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L203: 		race.ReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_unix.go#L214: 		race.ReadRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L217: 		msan.Read(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L220: 		asan.Read(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L229: 			race.WriteRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L232: 			race.Acquire(unsafe.Pointer(&ioSync))
		syscall_unix.go#L236: 		msan.Write(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L239: 		asan.Write(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L246: 		race.ReleaseMerge(unsafe.Pointer(&ioSync))
		syscall_unix.go#L250: 		race.ReadRange(unsafe.Pointer(&p[0]), n)
		syscall_unix.go#L253: 		msan.Read(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L256: 		asan.Read(unsafe.Pointer(&p[0]), uintptr(n))
		syscall_unix.go#L266: 	sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
		syscall_unix.go#L315: 	err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
		syscall_unix.go#L337: 	pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
		syscall_unix.go#L338: 	port := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_unix.go#L350: 	pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
		syscall_unix.go#L351: 	port := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_unix.go#L364: 	pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
		syscall_unix.go#L365: 	port := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_unix.go#L377: 	pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
		syscall_unix.go#L378: 	port := (*[2]byte)(unsafe.Pointer(&pp.Port))
		syscall_unix.go#L401: 	var ptr unsafe.Pointer
		syscall_unix.go#L446: 		ptr   unsafe.Pointer
		syscall_unix.go#L459: 	return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
		syscall_unix.go#L464: 	return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
		syscall_unix.go#L468: 	return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
		syscall_unix.go#L472: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
		syscall_unix.go#L476: 	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
		syscall_unix.go#L480: 	return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
		syscall_unix.go#L484: 	return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
		syscall_unix.go#L488: 	var p unsafe.Pointer
		syscall_unix.go#L490: 		p = unsafe.Pointer(&[]byte(s)[0])
		syscall_unix.go#L496: 	return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
		syscall_unix.go#L519: 		race.ReleaseMerge(unsafe.Pointer(&ioSync))
		zsyscall_linux_amd64.go#L18: 	_, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux_amd64.go#L33: 	_, _, e1 := Syscall6(_SYS_faccessat2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L48: 	_, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux_amd64.go#L63: 	_, _, e1 := Syscall6(_SYS_fchmodat2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L83: 	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
		zsyscall_linux_amd64.go#L98: 	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
		zsyscall_linux_amd64.go#L109: 	_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
		zsyscall_linux_amd64.go#L124: 	var _p1 unsafe.Pointer
		zsyscall_linux_amd64.go#L126: 		_p1 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L128: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L130: 	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
		zsyscall_linux_amd64.go#L151: 	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
		zsyscall_linux_amd64.go#L166: 	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
		zsyscall_linux_amd64.go#L181: 	_, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
		zsyscall_linux_amd64.go#L191: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L193: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L195: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L208: 	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
		zsyscall_linux_amd64.go#L228: func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
		zsyscall_linux_amd64.go#L244: 	_, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux_amd64.go#L269: 	_, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
		zsyscall_linux_amd64.go#L284: 	_, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux_amd64.go#L294: 	r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
		zsyscall_linux_amd64.go#L310: 	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux_amd64.go#L325: 	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
		zsyscall_linux_amd64.go#L377: 	_, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
		zsyscall_linux_amd64.go#L422: 	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
		zsyscall_linux_amd64.go#L473: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L475: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L477: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L528: 	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
		zsyscall_linux_amd64.go#L556: 	var _p2 unsafe.Pointer
		zsyscall_linux_amd64.go#L558: 		_p2 = unsafe.Pointer(&dest[0])
		zsyscall_linux_amd64.go#L560: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L562: 	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
		zsyscall_linux_amd64.go#L578: 	r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
		zsyscall_linux_amd64.go#L621: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L623: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L625: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L643: 	var _p1 unsafe.Pointer
		zsyscall_linux_amd64.go#L645: 		_p1 = unsafe.Pointer(&dest[0])
		zsyscall_linux_amd64.go#L647: 		_p1 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L649: 	r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
		zsyscall_linux_amd64.go#L665: 	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
		zsyscall_linux_amd64.go#L680: 	_, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
		zsyscall_linux_amd64.go#L690: 	_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
		zsyscall_linux_amd64.go#L710: 	_, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
		zsyscall_linux_amd64.go#L720: 	_, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
		zsyscall_linux_amd64.go#L730: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L732: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L734: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L757: 	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
		zsyscall_linux_amd64.go#L767: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L769: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L771: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L783: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L785: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L787: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L820: 	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
		zsyscall_linux_amd64.go#L850: 	var _p2 unsafe.Pointer
		zsyscall_linux_amd64.go#L852: 		_p2 = unsafe.Pointer(&data[0])
		zsyscall_linux_amd64.go#L854: 		_p2 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L856: 	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
		zsyscall_linux_amd64.go#L873: 	_, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
		zsyscall_linux_amd64.go#L904: 	r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
		zsyscall_linux_amd64.go#L923: 	_, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
		zsyscall_linux_amd64.go#L938: 	_, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
		zsyscall_linux_amd64.go#L958: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L960: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L962: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L985: 	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
		zsyscall_linux_amd64.go#L1006: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1008: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux_amd64.go#L1010: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1022: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1024: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux_amd64.go#L1026: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1038: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1040: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux_amd64.go#L1042: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1054: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1056: 		_p0 = unsafe.Pointer(&b[0])
		zsyscall_linux_amd64.go#L1058: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1110: 	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
		zsyscall_linux_amd64.go#L1120: 	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L1223: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1225: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L1227: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1240: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1242: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L1244: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1267: 	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
		zsyscall_linux_amd64.go#L1288: 	r0, _, e1 := Syscall6(SYS_SELECT, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
		zsyscall_linux_amd64.go#L1299: 	r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
		zsyscall_linux_amd64.go#L1340: 	r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
		zsyscall_linux_amd64.go#L1356: 	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L1381: 	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
		zsyscall_linux_amd64.go#L1391: 	_, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
		zsyscall_linux_amd64.go#L1401: 	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L1411: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L1421: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L1437: 	_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
		zsyscall_linux_amd64.go#L1447: 	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
		zsyscall_linux_amd64.go#L1457: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
		zsyscall_linux_amd64.go#L1458: 	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
		zsyscall_linux_amd64.go#L1467: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
		zsyscall_linux_amd64.go#L1489: 	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
		zsyscall_linux_amd64.go#L1499: 	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
		zsyscall_linux_amd64.go#L1509: 	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
		zsyscall_linux_amd64.go#L1519: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1521: 		_p0 = unsafe.Pointer(&p[0])
		zsyscall_linux_amd64.go#L1523: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1525: 	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
		zsyscall_linux_amd64.go#L1535: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
		zsyscall_linux_amd64.go#L1536: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1538: 		_p0 = unsafe.Pointer(&buf[0])
		zsyscall_linux_amd64.go#L1540: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1552: 	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
		zsyscall_linux_amd64.go#L1563: 	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
		zsyscall_linux_amd64.go#L1585: 	var _p0 unsafe.Pointer
		zsyscall_linux_amd64.go#L1587: 		_p0 = unsafe.Pointer(&events[0])
		zsyscall_linux_amd64.go#L1589: 		_p0 = unsafe.Pointer(&_zero)
		zsyscall_linux_amd64.go#L1607: 	_, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
		zsyscall_linux_amd64.go#L1622: 	_, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
		zsyscall_linux_amd64.go#L1637: 	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)

	time
		sleep.go#L22: func syncTimer(c chan Time) unsafe.Pointer {
		sleep.go#L45: 	return *(*unsafe.Pointer)(unsafe.Pointer(&c))
		sleep.go#L72: func newTimer(when, period int64, f func(any, uintptr, int64), arg any, cp unsafe.Pointer) *Timer
		tick.go#L44: 	t := (*Ticker)(unsafe.Pointer(newTimer(when(d), int64(d), sendTime, c, syncTimer(c))))
		tick.go#L59: 	stopTimer((*Timer)(unsafe.Pointer(t)))
		tick.go#L72: 	resetTimer((*Timer)(unsafe.Pointer(t)), when(d), int64(d))

	unique
		clone.go#L23: 		ps := (*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&value)) + offset))
		handle.go#L40: 		return Handle[T]{(*T)(unsafe.Pointer(&zero))}

	vendor/golang.org/x/crypto/internal/alias
		alias.go#L16: 		uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
		alias.go#L17: 		uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))

	weak
		pointer.go#L62: 	u unsafe.Pointer
		pointer.go#L70: 	var u unsafe.Pointer
		pointer.go#L72: 		u = runtime_registerWeakPointer(unsafe.Pointer(ptr))
		pointer.go#L93: func runtime_registerWeakPointer(unsafe.Pointer) unsafe.Pointer
		pointer.go#L96: func runtime_makeStrongFromWeak(unsafe.Pointer) unsafe.Pointer