MOVD	R1, n-8(SP)           // e310f0100024
	MOVW	R2, n-8(SP)           // 5020f010
	MOVH	R3, n-8(SP)           // 4030f010
	MOVB	R4, n-8(SP)           // 4240f010
	MOVWZ	R5, n-8(SP)           // 5050f010
	MOVHZ	R6, n-8(SP)           // 4060f010
	MOVBZ	R7, n-8(SP)           // 4270f010
	MOVDBR	R8, n-8(SP)           // e380f010002f
	MOVWBR	R9, n-8(SP)           // e390f010003e

	CALL	foo(SB)
//	CALL	(AX*4) // TODO: This line is silently dropped on the floor!
	CALL	foo+4(SB)(AX*4)
	CALL	*4(SP) // CALL 4(SP)
	CALL	*(AX) // CALL (AX)
	CALL	*(SP) // CALL (SP)
//	CALL	*(AX*4) // TODO: This line is silently dropped on the floor!
	CALL	*(AX)(AX*4) // CALL (AX)(AX*4)
	CALL	4(SP)
	CALL	(AX)
	CALL	(SP)
//	CALL	(AX*4) // TODO: This line is silently dropped on the floor!
	JCS	2(PC)
	JMP	(AX)(AX*4)

	{"(DX)", "(DX)"},
	{"(R9)", "(R9)"},
	{"(R9)(BX*8)", "(R9)(BX*8)"},
	{"(SI)", "(SI)"},
	{"(SI)(BX*1)", "(SI)(BX*1)"},
	{"(SI)(DX*1)", "(SI)(DX*1)"},
	{"(SP)", "(SP)"},
	{"(SP)(AX*4)", "(SP)(AX*4)"},
	{"32(SP)(BX*2)", "32(SP)(BX*2)"},
	{"32323(SP)(R8*4)", "32323(SP)(R8*4)"},
	{"+3(PC)", "3(PC)"},
	{"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
	{"-3(PC)", "-3(PC)"},
	{"-64(SI)(BX*1)", "-64(SI)(BX*1)"},

	KMOVW K5, 17(SP)                                   // c5f8916c2411
	KMOVW K4, 17(SP)                                   // c5f891642411
	KMOVW K5, -17(BP)(SI*4)                            // c5f8916cb5ef
	KMOVW K4, -17(BP)(SI*4)                            // c5f89164b5ef
	KMOVW K7, SP                                       // c5f893e7
	KMOVW K6, SP                                       // c5f893e6

			// Format the sparse map.
			formatSPD := func(sp sparseDatas, sa sparseArray) sparseDatas {
				for i := 0; len(sp) > 0 && i < sa.MaxEntries(); i++ {
					f.formatNumeric(sa.Entry(i).Offset(), sp[0].Offset)
					f.formatNumeric(sa.Entry(i).Length(), sp[0].Length)
					sp = sp[1:]
				}
				if len(sp) > 0 {
					sa.IsExtended()[0] = 1
				}
				return sp
			}
			sp2 := formatSPD(spd, blk.GNU().Sparse())

        ComparableVersion sp1 = new ComparableVersion("1.0-sp1-redhat");
        ComparableVersion sp2 = new ComparableVersion("1.0-sp-1-redhat");
        ComparableVersion sp3 = new ComparableVersion("1.0-sp.1-redhat");
        assertTrue(f.compareTo(sp1) < 0, "expected " + f + " < " + sp1);
        assertTrue(f.compareTo(sp2) < 0, "expected " + f + " < " + sp2);

            throws IOException {
        MavenProperties sp = new MavenProperties(false);
        if (Files.exists(path)) {
            sp.load(path);
        }
        properties.forEach(
                (k, v) -> sp.put(k.toString(), escape ? DefaultInterpolator.escape(v.toString()) : v.toString()));
        loadIncludes(path, sp, callback);
        substitute(sp, callback);
        sp.forEach(properties::setProperty);
    }

TEXT asmtest_avx512_4fmaps(SB), NOSPLIT, $0
	V4FMADDPS 17(SP), [Z0-Z3], K2, Z0                  // 62f27f4a9a842411000000
	V4FMADDPS -17(BP)(SI*4), [Z0-Z3], K2, Z0           // 62f27f4a9a84b5efffffff
	V4FMADDPS 17(SP), [Z10-Z13], K2, Z0                // 62f22f4a9a842411000000
	V4FMADDPS -17(BP)(SI*4), [Z10-Z13], K2, Z0         // 62f22f4a9a84b5efffffff
	V4FMADDPS 17(SP), [Z20-Z23], K2, Z0                // 62f25f429a842411000000

	VRSQRT28PS 17(SP)(BP*8), K1, Z12                   // 62727d49cca4ec11000000
	VRSQRT28PS 17(SP)(BP*4), K1, Z12                   // 62727d49cca4ac11000000
	VRSQRT28PS Z11, K1, Z22                            // 62c27d49ccf3
	VRSQRT28PS Z5, K1, Z22                             // 62e27d49ccf5
	VRSQRT28PS 17(SP)(BP*8), K1, Z22                   // 62e27d49ccb4ec11000000

	VPGATHERQQ Y8, 0(Y9*4), Y10             // c422bd91148d00000000
	// AVX2GATHER: test SP/BP base with different displacements.
	VPGATHERQQ X0, (SP)(X1*1), X2           // c4e2f991140c
	VPGATHERQQ X0, 16(SP)(X1*1), X2         // c4e2f991540c10
	VPGATHERQQ X0, 512(SP)(X1*1), X2        // c4e2f991940c00020000
	VPGATHERQQ X0, (R12)(X1*1), X2          // c4c2f991140c