CMPL	SI, DI
	JEQ	eq
	MOVL	size+8(FP), BX
	LEAL	ret+12(FP), AX
	JMP	memeqbody<>(SB)
eq:
	MOVB    $1, ret+12(FP)
	RET

// memequal_varlen(a, b unsafe.Pointer) bool
TEXT runtime·memequal_varlen(SB),NOSPLIT,$0-9
	MOVL    a+0(FP), SI
	MOVL    b+4(FP), DI
	CMPL    SI, DI
	JEQ     eq
	MOVL    4(DX), BX    // compiler stores size at offset 4 in the closure
	LEAL	ret+8(FP), AX
	JMP	memeqbody<>(SB)
eq:

	finalWork fcrequest.SeatSeconds // only final work
}

// queue is a sequence of requests that have arrived but not yet finished
// execution in both the real and virtual worlds.
type queue struct {
	// The requestsWaiting not yet executing in the real world are stored in a FIFO list.
	requestsWaiting fifo

	// nextDispatchR is the R progress meter reading at
	// which the next request will be dispatched in the virtual world.

		Interface: &fakeIDX,
		Address: net.IPNet{
			IP: fakeIP,
		},
		Gateway: fakeGW,
	}
)

func TestPushCNIAddEventSucceed(t *testing.T) {
	// Fake out a test HTTP server and use that instead of a real HTTP server over gRPC to validate  req/resp flows
	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("server happy"))
	}))

	n5 = len(<-c) // ERROR "is not a constant|is not constant"

	n6 = cap(f())  // ERROR "is not a constant|is not constant"
	n7 = cap(<-c) // ERROR "is not a constant|is not constant"
	n8 = real(z) // ERROR "is not a constant|is not constant"
	n9 = len([4]float64{real(z)}) // ERROR "is not a constant|is not constant"

// complex ops
(ComplexReal (ComplexMake real _  )) => real
(ComplexImag (ComplexMake _ imag )) => imag

(Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 =>
  (ComplexMake
    (Load <typ.Float32> ptr mem)
    (Load <typ.Float32>
      (OffPtr <typ.Float32Ptr> [4] ptr)
      mem)
    )
(Store {t} dst (ComplexMake real imag) mem) && t.Size() == 8 =>
  (Store {typ.Float32}

			StabilityLevel: compbasemetrics.ALPHA,
			Help:           "Number of errors when kubelet cannot compute SELinux context for a container that are ignored. They will become real errors when SELinuxMountReadWriteOncePod feature is expanded to all volume access modes.",
		},
		[]string{"access_mode"},
	)
	seLinuxPodContextMismatchErrors = compbasemetrics.NewGaugeVec(
		&compbasemetrics.GaugeOpts{

	cap(a)				// ERROR "not used"
	complex(1, 2)			// ERROR "not used"
	imag(1i)			// ERROR "not used"
	len(a)				// ERROR "not used"
	make([]int, 10)			// ERROR "not used"
	new(int)			// ERROR "not used"
	real(1i)			// ERROR "not used"
	unsafe.Alignof(a)		// ERROR "not used"
	unsafe.Offsetof(s.f)		// ERROR "not used"
	unsafe.Sizeof(a)		// ERROR "not used"

	close(c)
	copy(a, a)
	delete(m, 0)
	panic(0)
	print("foo")

			}

			item.heal.enabled = thisHash.modAlt(f.oldCache.Info.NextCycle/folder.objectHealProbDiv, f.healObjectSelect/folder.objectHealProbDiv) && globalIsErasure
			item.heal.bitrot = f.scanMode == madmin.HealDeepScan

			// if the drive belongs to an erasure set
			// that is already being healed, skip the
			// healing attempt on this drive.
			item.heal.enabled = item.heal.enabled && f.healObjectSelect > 0

	},
	{
		"complex64",
		"Complex64",
		`real := float32FromBits(state.decodeUint(), ovfl)
		imag := float32FromBits(state.decodeUint(), ovfl)
		slice[i] = complex(float32(real), float32(imag))`,
	},
	{
		"complex128",
		"Complex128",
		`real := float64FromBits(state.decodeUint())
		imag := float64FromBits(state.decodeUint())
		slice[i] = complex(real, imag)`,
	},
	{
		"float32",
		"Float32",

// Kernel interface gets call sub-number and pointer to a0.
TEXT ·socketcall(SB),NOSPLIT,$0-36
	CALL	runtime·entersyscall(SB)
	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
	MOVL	call+0(FP), BX	// socket call number
	LEAL	a0+4(FP), CX	// pointer to call arguments
	MOVL	$0, DX
	MOVL	$0, SI
	MOVL	$0, DI
	INVOKE_SYSCALL
	CMPL	AX, $0xfffff001
	JLS	oksock
	MOVL	$-1, n+28(FP)
	NEGL	AX
	MOVL	AX, err+32(FP)