{"_seek<>(SB)", "_seek<>(SB)"},
	{"a2+16(FP)", "a2+16(FP)"},
	{"addr2+24(FP)", "addr2+24(FP)"},
	{"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
	{"b+24(FP)", "b+24(FP)"},
	{"b_len+32(FP)", "b_len+32(FP)"},
	{"racecall<>(SB)", "racecall<>(SB)"},
	{"rcv_name+20(FP)", "rcv_name+20(FP)"},
	{"retoffset+28(FP)", "retoffset+28(FP)"},
	{"runtime·_GetStdHandle(SB)", "runtime._GetStdHandle(SB)"},

	MOVW	y+65540(FP), R4			// 1e020014de8f1000c4338028
	MOVWU	y+65540(FP), R4			// 1e020014de8f1000c433802a
	MOVV	y+65540(FP), R4			// 1e020014de8f1000c433c028
	MOVB	y+65540(FP), R4			// 1e020014de8f1000c4330028
	MOVBU	y+65540(FP), R4			// 1e020014de8f1000c433002a
	MOVW	y+4097(FP), R4			// 3e000014de8f1000c4278028
	MOVWU	y+4097(FP), R4			// 3e000014de8f1000c427802a
	MOVV	y+4097(FP), R4			// 3e000014de8f1000c427c028

	ABSF	F4, F5			// 85041401
	MOVVF	F4, F5			// 85181d01
	MOVF	F4, F5			// 85941401
	MOVD	F4, F5			// 85981401
	MOVW	R4, result+16(FP)	// 64608029
	MOVWU	R4, result+16(FP)	// 64608029
	MOVV	R4, result+16(FP)	// 6460c029
	MOVB	R4, result+16(FP)	// 64600029
	MOVBU	R4, result+16(FP)	// 64600029
	MOVW	R4, 1(R5)		// a4048029
	MOVWU	R4, 1(R5)		// a4048029
	MOVV	R4, 1(R5)		// a404c029
	MOVB	R4, 1(R5)		// a4040029

	// Create maps for easy lookup of instruction names etc.
	for i, s := range x86.Register {
		register[s] = int16(i + x86.REG_AL)
	}
	// Pseudo-registers.
	register["SB"] = RSB
	register["FP"] = RFP
	register["PC"] = RPC
	if linkArch == &x86.Linkamd64 {
		// Alias g to R14
		register["g"] = x86.REGG
	}
	// Register prefix not used on this architecture.

	instructions := make(map[string]obj.As)

	DiskID   string   `msg:"id"`
	Volume   string   `msg:"v"`
	FilePath string   `msg:"fp"`
	FI       FileInfo `msg:"fi"`
}

// DeleteFileHandlerParams are parameters for DeleteFileHandler
type DeleteFileHandlerParams struct {
	DiskID   string        `msg:"id"`
	Volume   string        `msg:"v"`
	FilePath string        `msg:"fp"`
	Opts     DeleteOptions `msg:"do"`
}

at the beginning, as in <code>first_arg+0(FP)</code> and <code>second_arg+8(FP)</code>.
(The meaning of the offset—offset from the frame pointer—distinct
from its use with <code>SB</code>, where it is an offset from the symbol.)
The assembler enforces this convention, rejecting plain <code>0(FP)</code> and <code>8(FP)</code>.
The actual name is semantically irrelevant but should be used to document

	storageRESTMethodReadParts      = "/rps"
)

const (
	storageRESTVolume           = "vol"
	storageRESTVolumes          = "vols"
	storageRESTDirPath          = "dpath"
	storageRESTFilePath         = "fp"
	storageRESTVersionID        = "vid"
	storageRESTHealing          = "heal"
	storageRESTTotalVersions    = "tvers"
	storageRESTSrcVolume        = "svol"
	storageRESTSrcPath          = "spath"

*[256]byte, dst []byte, src []byte, ctr *[16]byte, T *[16]byte, ks []uint32) // Requires: AES, PCLMULQDQ, SSE2, SSE4.1, SSSE3 TEXT ·gcmAesEnc(SB), $256-96 MOVQ productTable+0(FP), DI MOVQ dst_base+8(FP), DX MOVQ src_base+32(FP), SI MOVQ src_len+40(FP), R9 MOVQ ctr+56(FP), CX MOVQ T+64(FP), R8 MOVQ ks_base+72(FP), AX MOVQ ks_len+80(FP), R13 SHRQ $0x02, R13 DECQ R13 MOVOU bswapMask<>+0(SB), X15 MOVOU gcmPoly<>+0(SB), X14 MOVOU (R8), X8 PXOR X9, X9 PXOR X10, X10 MOVOU (CX), X0 MOVL 12(CX), R10 MOVOU (AX),...

				err = msgp.WrapError(err, "DiskID")
				return
			}
		case "v":
			z.Volume, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Volume")
				return
			}
		case "fp":
			z.FilePath, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "FilePath")
				return
			}
		case "fi":
			err = z.FI.DecodeMsg(dc)
			if err != nil {

*[256]byte, dst []byte, src []byte, ctr *[16]byte, T *[16]byte, ks []uint32) // Requires: AES, PCLMULQDQ, SSE2, SSE4.1, SSSE3 TEXT ·gcmAesEnc(SB), $256-96 MOVQ productTable+0(FP), DI MOVQ dst_base+8(FP), DX MOVQ src_base+32(FP), SI MOVQ src_len+40(FP), R9 MOVQ ctr+56(FP), CX MOVQ T+64(FP), R8 MOVQ ks_base+72(FP), AX MOVQ ks_len+80(FP), R13 SHRQ $0x02, R13 DECQ R13 MOVOU bswapMask<>+0(SB), X15 MOVOU gcmPoly<>+0(SB), X14 MOVOU (R8), X8 PXOR X9, X9 PXOR X10, X10 MOVOU (CX), X0 MOVL 12(CX), R10 MOVOU (AX),...