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)

// LTYPEN spec4	{ outcode(int($1), &$2); }
	NOP
	NOP	AX
	NOP	foo+4(SB)

// LTYPES spec5	{ outcode(int($1), &$2); }
	SHLL	$4, BX
	SHLL	$4, foo+4(SB)
	SHLL	$4, foo+4(SB):AX // SHLL $4, AX, foo+4(SB)

// LTYPEM spec6	{ outcode(int($1), &$2); }
	MOVL	AX, BX
	MOVL	$4, BX

	RET
TEXT ·a23(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0
	LEAQ (AX)(CX*1), R15
	RET
TEXT ·a24(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0
	LEAQ (R15)(AX*1), AX // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET
TEXT ·a25(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0

	MOVQ 2147483647+1(AX), AX       // ERROR "offset too large"
	MOVQ 3395469782(R10), R8        // ERROR "offset too large"
	LEAQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDL 3395469782(AX), AX         // ERROR "offset too large"
	ADDW 3395469782(AX), AX         // ERROR "offset too large"
	LEAQ 433954697820(AX), AX       // ERROR "offset too large"

//	JMP	*(R12*4) // TODO: This line is silently dropped on the floor!
	JCS	2(PC)
	JMP	*(R12)(R13*4) // JMP (R12)(R13*4)
	JCS	2(PC)
	JMP	*(AX) // JMP (AX)
	JCS	2(PC)
	JMP	*(SP) // JMP (SP)
	JCS	2(PC)
//	JMP	*(AX*4) // TODO: This line is silently dropped on the floor!
	JCS	2(PC)
	JMP	*(AX)(AX*4) // JMP (AX)(AX*4)
	JCS	2(PC)
	JMP	4(SP)
	JCS	2(PC)
	JMP	(R12)
	JCS	2(PC)
//	JMP	(R12*4) // TODO: This line is silently dropped on the floor!

	MOVQ (AX), M0  // 0f6f00
	MOVQ M0, 8(SP) // 0f7f442408
	MOVQ 8(SP), M0 // 0f6f442408
	MOVQ M0, (AX)  // 0f7f00
	MOVQ M0, (BX)  // 0f7f03
	// On non-64bit arch, Go asm allowed uint32 offsets instead of int32.
	// These tests check that property for backwards-compatibility.
	MOVL 2147483648(AX), AX  // 8b8000000080
	MOVL -2147483648(AX), AX // 8b8000000080
	ADDL 2147483648(AX), AX  // 038000000080

	V4FMADDSS 7(AX), [X0-X3], K5, X3                   // 62f27f0d9b9807000000 or 62f27f2d9b9807000000 or 62f27f4d9b9807000000
	V4FMADDSS (DI), [X0-X3], K5, X3                    // 62f27f0d9b1f or 62f27f2d9b1f or 62f27f4d9b1f
	V4FMADDSS 7(AX), [X10-X13], K5, X3                 // 62f22f0d9b9807000000 or 62f22f2d9b9807000000 or 62f22f4d9b9807000000
	V4FMADDSS (DI), [X10-X13], K5, X3                  // 62f22f0d9b1f or 62f22f2d9b1f or 62f22f4d9b1f

	VGATHERPF1DPD K2, (R14)(Y29*8)                     // 6292fd42c614ee
	VGATHERPF1DPD K2, (AX)(Y4*1)                       // 62f2fd4ac61420
	VGATHERPF1DPD K2, (BP)(Y10*2)                      // 62b2fd4ac6545500
	VGATHERPF1DPS K3, (DX)(Z10*4)                      // 62b27d4bc61492
	VGATHERPF1DPS K3, (AX)(Z4*1)                       // 62f27d4bc61420
	VGATHERPF1DPS K3, (SP)(Z4*2)                       // 62f27d4bc61464

	VPOPCNTQ 7(AX)(CX*4), K2, Y1                       // 62f2fd2a558c8807000000
	VPOPCNTQ 7(AX)(CX*1), K2, Y1                       // 62f2fd2a558c0807000000
	VPOPCNTQ Y5, K2, Y27                               // 6262fd2a55dd
	VPOPCNTQ Y17, K2, Y27                              // 6222fd2a55d9
	VPOPCNTQ Y13, K2, Y27                              // 6242fd2a55dd

	},
	{
		"LOAD macro",
		lines(
			"#define LOAD(off, reg) \\",
			"\tMOVBLZX	(off*4)(R12),	reg \\",
			"\tADDB	reg,		DX",
			"",
			"LOAD(8, AX)",
		),
		"\n.\n.MOVBLZX.(.8.*.4.).(.R12.).,.AX.\n.ADDB.AX.,.DX.\n",
	},
	{
		"nested multiline macro",
		lines(
			"#define KEYROUND(xmm, load, off, r1, r2, index) \\",
			"\tMOVBLZX	(BP)(DX*4),	R8 \\",
			"\tload((off+1), r2) \\",