buf.Write([]byte{0, 5})
	buf.WriteString("event")

	buf.WriteByte(13)
	buf.WriteString(":content-type")
	buf.WriteByte(7)
	buf.Write([]byte{0, 8})
	buf.WriteString("text/xml")

	buf.WriteByte(11)
	buf.WriteString(":event-type")
	buf.WriteByte(7)
	buf.Write([]byte{0, 8})
	buf.WriteString("Progress")

	fmt.Println(buf.Bytes())
}

func genStatsHeader() {
	buf := new(bytes.Buffer)

TEXT runtime·panicIndex(SB),NOSPLIT,$0-8
	MOVW	R1, x+0(FP)
	MOVW	R2, y+4(FP)
	JMP	runtime·goPanicIndex(SB)
TEXT runtime·panicIndexU(SB),NOSPLIT,$0-8
	MOVW	R1, x+0(FP)
	MOVW	R2, y+4(FP)
	JMP	runtime·goPanicIndexU(SB)
TEXT runtime·panicSliceAlen(SB),NOSPLIT,$0-8
	MOVW	R2, x+0(FP)
	MOVW	R3, y+4(FP)
	JMP	runtime·goPanicSliceAlen(SB)
TEXT runtime·panicSliceAlenU(SB),NOSPLIT,$0-8
	MOVW	R2, x+0(FP)
	MOVW	R3, y+4(FP)

// startup (runtime.checkgoarm) if it is a multi-processor but goarm < 7.

TEXT	·Load(SB),NOSPLIT|NOFRAME,$0-8
	MOVW	addr+0(FP), R0
	MOVW	(R0), R1

	MOVB	runtime·goarm(SB), R11
	CMP	$7, R11
	BLT	2(PC)
	DMB	MB_ISH

	MOVW	R1, ret+4(FP)
	RET

TEXT	·Store(SB),NOSPLIT,$0-8
	MOVW	addr+0(FP), R1
	MOVW	v+4(FP), R2

	MOVB	runtime·goarm(SB), R8
	CMP	$7, R8
	BLT	2(PC)
	DMB	MB_ISH

		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		sa.Port = int(p[0])<<8 + int(p[1])
		sa.Addr = pp.Addr
		return sa, nil

	case m.Header.Level == SOL_IPV6 && m.Header.Type == IPV6_ORIGDSTADDR:
		pp := (*RawSockaddrInet6)(unsafe.Pointer(&m.Data[0]))
		sa := new(SockaddrInet6)
		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
		sa.Port = int(p[0])<<8 + int(p[1])
		sa.ZoneId = pp.Scope_id
		sa.Addr = pp.Addr
		return sa, nil

00000310  ee 27 ab 56 77 d1 0b 65  83 96 e5 72 ea 9a 78 85  |.'.Vw..e...r..x.|
00000320  07 e6 86 bf 58 84 a8 4d  08 4a 56 14 a6 7f 0c 5a  |....X..M.JV....Z|
00000330  68 3c 6a 9e 0e 2a 70 6a  4f 58 96 45 f2 14 11 45  |h<j..*pjOX.E...E|
00000340  49 fc b1 0b 13 ff e8 f9  40 71 fb b6 05 ef 88 32  |I.......@q.....2|
00000350  06 19 e0 e9 9d 97 20 e2  78 0b 4b 4c 71 4a 08 ee  |...... .x.KLqJ..|
00000360  31 27 ef dd d0 5b d9 32  88 76 51 38 03 00 ba 67  |1'...[.2.vQ8...g|

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "textflag.h"

TEXT	·getFP(SB), NOSPLIT|NOFRAME, $0-8
	MOVD	R29, ret+0(FP)

    }

    def "get all final does that"() {
        when:
        props.versions = "1.3-rc-1 1.2 0.8"

        then:
        versions().all*.version == [version("1.3-rc-1"), version("1.2"), version("0.8")]
    }

    def "get supported does that"() {
        when:
        props.versions = "1.3-rc-1 1.2 0.8"

        then:
        versions().supported*.version == [version("1.3-rc-1"), version("1.2")]
    }

00000060  70 72 6f 74 6f 31 00 16  00 00 00 17 00 00 00 0d  |proto1..........|
00000070  00 30 00 2e 04 03 05 03  06 03 08 07 08 08 08 09  |.0..............|
00000080  08 0a 08 0b 08 04 08 05  08 06 04 01 05 01 06 01  |................|
00000090  03 03 02 03 03 01 02 01  03 02 02 02 04 02 05 02  |................|
000000a0  06 02                                             |..|
>>> Flow 2 (server to client)

	buf[7] = byte(tu >> (4 * 8))
	buf[8] = byte(tu >> (3 * 8))
	buf[9] = byte(tu >> (2 * 8))
	buf[10] = byte(tu >> (1 * 8))
	buf[11] = byte(tu >> (0 * 8))
	nu := uint32(n)
	buf[12] = byte(nu >> (3 * 8))
	buf[13] = byte(nu >> (2 * 8))
	buf[14] = byte(nu >> (1 * 8))
	buf[15] = byte(nu >> (0 * 8))
	write1(fd, unsafe.Pointer(&buf[0]), int32(len(buf)))

	// Write actual data.
	res := write1(fd, p, n)

	unlock(&faketimeState.lock)

#define PUSH_REGS_HOST_TO_ABI0()	\
	ADJSP	$(REGS_HOST_TO_ABI0_STACK)	\
	MOVQ	BP, (5*8)(SP)	\
	LEAQ	(5*8)(SP), BP	\
	MOVQ	BX, (0*8)(SP)	\
	MOVQ	R12, (1*8)(SP)	\
	MOVQ	R13, (2*8)(SP)	\
	MOVQ	R14, (3*8)(SP)	\
	MOVQ	R15, (4*8)(SP)

#define POP_REGS_HOST_TO_ABI0()	\
	MOVQ	(0*8)(SP), BX	\
	MOVQ	(1*8)(SP), R12	\
	MOVQ	(2*8)(SP), R13	\
	MOVQ	(3*8)(SP), R14	\
	MOVQ	(4*8)(SP), R15	\
	MOVQ	(5*8)(SP), BP	\