TEXT ·vectorizedIEEE(SB),NOSPLIT,$0
	MOVWZ   crc+0(FP), R2     // R2 stores the CRC value
	MOVD    p+8(FP), R3       // data pointer
	MOVD    p_len+16(FP), R4  // len(p)

	MOVD    $·crclecons(SB), R5
	BR      vectorizedBody<>(SB)

// func vectorizedCastagnoli(crc uint32, p []byte) uint32
TEXT ·vectorizedCastagnoli(SB),NOSPLIT,$0
	MOVWZ   crc+0(FP), R2     // R2 stores the CRC value
	MOVD    p+8(FP), R3       // data pointer

				valn("store", i-1, 4)),
			Valu(valn("store", i, 1), OpStore, types.TypeMem, 0, elemType, valn("addr", i, 1),
				valn("v", i, 0), valn("zero", i, 1)),
			Valu(valn("store", i, 2), OpStore, types.TypeMem, 0, elemType, valn("addr", i, 2),
				valn("v", i, 0), valn("store", i, 1)),
			Valu(valn("store", i, 3), OpStore, types.TypeMem, 0, elemType, valn("addr", i, 1),

	r := f.u.Load()
	return *(*float64)(unsafe.Pointer(&r))
}

// Store updates the value atomically.
//
//go:nosplit
func (f *Float64) Store(value float64) {
	f.u.Store(*(*uint64)(unsafe.Pointer(&value)))
}

// UnsafePointer is an atomically accessed unsafe.Pointer value.
//
// Note that because of the atomicity guarantees, stores to values
// of this type never trigger a write barrier, and the relevant

  //     example, a 2-D matrix with 2-D blocks, both stored in row-major order
  //     would have traversal_order = (d0, d1, d2, d3).
  traversal_order:[int];
  // For an n-dimensional tensor with a k-dimensional block (0 <= k <= n),
  // stores how a block dimension in (dn, ..., dn+k-1) maps to the original
  // tensor dimension in (d0, ..., dn).
  // It's stored in the order of (dn, ..., dn+k-1).

        1 * writeStore.add(key, action)
        0 * readStore.add(key, action)
    }

    def "searches in both read and write stores"() {
        setup:
        def r1 = Stub(LocallyAvailableExternalResource)
        def r2 = Stub(LocallyAvailableExternalResource)
        def r3 = Stub(LocallyAvailableExternalResource)
        1 * writeStore.search(key) >> {
            [r1] as Set
        }
        1 * readStore.search(key) >> {

		cs := cache.List(mockGvk, namespace)
		os := store.List(mockGvk, namespace)
		log.Infof("cache.List => Got %d, expected %d", len(cs), n)
		log.Infof("store.List => Got %d, expected %d", len(os), n)
		return len(os) == n && len(cs) == n
	}, retry.Message("cache and backing store match"))

	// remove elements directly through the client
	for i := 0; i < n; i++ {

	sa.AddDefaultResources()
	g.Expect(sa.stores).To(BeEmpty())

	// With ingress on, though, we should.
	ingressStrictMeshCfg := tempFileFromString(t, "ingressControllerMode: 'STRICT'")
	defer func() { _ = os.Remove(ingressStrictMeshCfg.Name()) }()

	err = sa.AddFileKubeMeshConfig(ingressStrictMeshCfg.Name())
	g.Expect(err).To(BeNil())
	sa.AddDefaultResources()
	g.Expect(sa.stores).To(HaveLen(0))
}

    /**
     * Uses previously stored resumption data to enrich an existing execution request.
     * @param request The execution request that will be enriched.
     * @param rootProject The root project that is being built.
     */
    void applyResumptionData(MavenExecutionRequest request, MavenProject rootProject);

    /**
     * Removes previously stored resumption data.

	B	end
native_barrier:
	DMB	MB_ISH
end:
	MOVB	R1, ret+4(FP)
	RET

TEXT	·Store8(SB),NOSPLIT,$0-5
	MOVW	addr+0(FP), R1
	MOVB	v+4(FP), R2

	MOVB	runtime·goarm(SB), R8
	CMP	$7, R8
	BGE	native_barrier
	BL	memory_barrier<>(SB)
	B	store
native_barrier:
	DMB	MB_ISH

store:
	MOVB	R2, (R1)

	CMP	$7, R8
	BGE	native_barrier2
	BL	memory_barrier<>(SB)
	RET

     */
    ToolchainPrivate[] getToolchainsForType(String type, MavenSession context) throws MisconfiguredToolchainException;

    /**
     * Stores the toolchain into build context for later use by toolchain-aware plugins.
     *
     * @param toolchain the toolchain to store, must not be {@code null}
     * @param context the Maven session, must not be {@code null}
     * @since 2.0.9