for i := 0; i < p; i++ {
		i := i
		go func() {
			for j := 0; j < N; j++ {
				// Write a pointer using memmove.
				copy(collider[i:i+1], ptrs[i:i+1])
				// Write nil using memclr.
				// (This is a magic loop that gets lowered to memclr.)
				r := collider[i : i+1]
				for k := range r {
					r[k] = nil
				}
			}
			done <- struct{}{}
		}()
	}
	// Start readers.  They read pointers from slots

// asmcheck

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that optimized range memclr works with pointers to arrays.
// The clears get inlined, see https://github.com/golang/go/issues/56997

package codegen

type T struct {
	a *[10]int
	b [10]int
}

func (t *T) f() {
	// amd64:-".*runtime.memclrNoHeapPointers"

TEXT runtime·memclrNoHeapPointers(SB), NOSPLIT, $0-8
	MOVL	ptr+0(FP), DI
	MOVL	n+4(FP), BX
	XORL	AX, AX

	// MOVOU seems always faster than REP STOSL.
tail:
	// BSR+branch table make almost all memmove/memclr benchmarks worse. Not worth doing.
	TESTL	BX, BX
	JEQ	_0
	CMPL	BX, $2
	JBE	_1or2
	CMPL	BX, $4
	JB	_3
	JE	_4
	CMPL	BX, $8
	JBE	_5through8
	CMPL	BX, $16
	JBE	_9through16
#ifdef GO386_softfloat

	// AX = ptr
	// BX = n
	MOVQ	AX, DI	// DI = ptr
	XORQ	AX, AX

	// MOVOU seems always faster than REP STOSQ when Enhanced REP STOSQ is not available.
tail:
	// BSR+branch table make almost all memmove/memclr benchmarks worse. Not worth doing.
	TESTQ	BX, BX
	JEQ	_0
	CMPQ	BX, $2
	JBE	_1or2
	CMPQ	BX, $4
	JBE	_3or4
	CMPQ	BX, $8
	JB	_5through7
	JE	_8
	CMPQ	BX, $16
	JBE	_9through16
	CMPQ	BX, $32

	// 128 because that is the maximum SSE register load (loading all data
	// into registers lets us ignore copy direction).
tail:
	// BSR+branch table make almost all memmove/memclr benchmarks worse. Not worth doing.
	TESTL	BX, BX
	JEQ	move_0
	CMPL	BX, $2
	JBE	move_1or2
	CMPL	BX, $4
	JB	move_3
	JE	move_4
	CMPL	BX, $8
	JBE	move_5through8
	CMPL	BX, $16
	JBE	move_9through16

 * bytecode manipulation libraries tools like ASM.
 *
 * <p>The notion of "member" here is similar to, but broader than
 * {@link java.lang.reflect.Member}. The latter is essentially an abstraction over fields,
 * methods and constructors; this Member and its subtypes represent not only fields and
 * methods, but also classes, inner classes, annotations and their values, and more. This

	I64Load b_len+8(FP)
	I32WrapI64
	Call memchr<>(SB)
	I64ExtendI32S
	Set R0

	Get SP
	I64Const $-1
	Get R0
	I64Load b_base+0(FP)
	I64Sub
	Get R0
	I64Eqz $0
	Select
	I64Store ret+32(FP)

	RET

TEXT ·IndexByteString(SB), NOSPLIT, $0-32
	Get SP
	I64Load s_base+0(FP)
	I32WrapI64
	I32Load8U c+16(FP)
	I64Load s_len+8(FP)
	I32WrapI64
	Call memchr<>(SB)
	I64ExtendI32S
	Set R0

            isInject(member) ||
            isOverrideMethod(member) ||
            isKotlinFileFacadeClass(member);
    }

    private boolean isClassFieldConstructorOrMethod(JApiCompatibility member) {
        return member instanceof JApiClass || member instanceof JApiField || member instanceof JApiConstructor || member instanceof JApiMethod;
    }

    private boolean isInject(JApiCompatibility member) {

                                origin != KaSymbolOrigin.INTERSECTION_OVERRIDE
                    }.filter { member ->
                        member !is KaConstructorSymbol || symbol !is KaClassOrObjectSymbol || !symbol.classKind.isObject
                    }.filterNot { member ->
                        member is KaConstructorSymbol && symbol is KaEnumEntrySymbol
                    }
                    .toList()
            }

const memDebug = false

var bloc uintptr
var blocMax uintptr
var memlock mutex

type memHdr struct {
	next memHdrPtr
	size uintptr
}

var memFreelist memHdrPtr // sorted in ascending order

type memHdrPtr uintptr

func (p memHdrPtr) ptr() *memHdr   { return (*memHdr)(unsafe.Pointer(p)) }
func (p *memHdrPtr) set(x *memHdr) { *p = memHdrPtr(unsafe.Pointer(x)) }

func memAlloc(n uintptr) unsafe.Pointer {
	n = memRound(n)