>>> Flow 1 (client to server)
00000000  16 03 01 00 6d 01 00 00  69 03 03 dd 92 e1 75 15  |....m...i.....u.|
00000010  1d 9f 00 c5 2b 8a 14 86  aa 93 7c c0 32 2a 29 14  |....+.....|.2*).|
00000020  38 75 ce 62 a7 df c1 4a  eb 1e 0c 00 00 04 00 05  |8u.b...J........|
00000030  00 ff 01 00 00 3c 00 16  00 00 00 17 00 00 00 0d  |.....<..........|
00000040  00 30 00 2e 04 03 05 03  06 03 08 07 08 08 08 09  |.0..............|

func mapAppendAssignmentInt8() {
	m := make(map[int8][]int8, 0)
	var k int8 = 0

	// 386:-".*mapaccess"
	// amd64:-".*mapaccess"
	// arm:-".*mapaccess"
	// arm64:-".*mapaccess"
	m[k] = append(m[k], 1)

	// 386:-".*mapaccess"
	// amd64:-".*mapaccess"
	// arm:-".*mapaccess"
	// arm64:-".*mapaccess"
	m[k] = append(m[k], 1, 2, 3)

	a := []int8{7, 8, 9, 0}

	// 386:-".*mapaccess"
	// amd64:-".*mapaccess"

	CMP     $0, R11
	BNE     skipfpsave
	MOVD	F8, (13*4+8*1)(R13)
	MOVD	F9, (13*4+8*2)(R13)
	MOVD	F10, (13*4+8*3)(R13)
	MOVD	F11, (13*4+8*4)(R13)
	MOVD	F12, (13*4+8*5)(R13)
	MOVD	F13, (13*4+8*6)(R13)
	MOVD	F14, (13*4+8*7)(R13)
	MOVD	F15, (13*4+8*8)(R13)

skipfpsave:
	BL	runtime·load_g(SB)
	// We set up the arguments to cgocallback when saving registers above.
	BL	runtime·cgocallback(SB)

//go:registerparams
//go:noinline
func F(a, b, c *int) int {
	return *a + *b + *c
}

//go:registerparams
//go:noinline
func H(s, t string) string {
	return s + " " + t
}

func main() {
	a, b, c := 1, 4, 16
	x := F(&a, &b, &c)
	fmt.Printf("x = %d\n", x)
	y := H("Hello", "World!")
	fmt.Println("len(y) =", len(y))
	fmt.Println("y =", y)

//go:noinline
func K(s, t string) (result string) { // result spills
	result = "Aloha! " + s + " " + t
	r := ""
	if len(s) <= len(t) {
		r = "OKAY! "
		X()
	}
	return r + result
}

func main() {
	a, b, c := 1, 4, 16
	x := F(&a, &b, &c)
	fmt.Printf("x = %d\n", x)

	y := H("Hello", "World!")
	fmt.Println("len(y) =", len(y))
	fmt.Println("y =", y)
	z := H("Hello", "Pal!")
	fmt.Println("len(z) =", len(z))

//go:noinline
func K(s, t string) (result string) { // result spills
	result = "Aloha! " + s + " " + t
	r := ""
	if len(s) <= len(t) {
		r = "OKAY! "
		X()
	}
	return r + result
}

func main() {
	a, b, c := 1, 4, 16
	x := F(&a, &b, &c)
	fmt.Printf("x = %d\n", x)

	y := H("Hello", "World!")
	fmt.Println("len(y) =", len(y))
	fmt.Println("y =", y)
	z := H("Hello", "Pal!")
	fmt.Println("len(z) =", len(z))

	_           [is64bit]int32 // Extra padding for 64-bit hosts only.

	// End of common part. Beginning of signal-specific part.

	Pid    int32
	Uid    uint32
	Status int32

	// Pad to 128 bytes.
	_ [128 - (6+is64bit)*4]byte
}

const (
	// Possible values for SiginfoChild.Code field.
	_CLD_EXITED    int32 = 1
	_CLD_KILLED          = 2
	_CLD_DUMPED          = 3
	_CLD_TRAPPED         = 4
	_CLD_STOPPED         = 5

        props.put("javax.version", "3.1.0");
        props.put("mockito.version", "1.10.19");
        props.put("hamcret.version", "2.1");
        props.put("lombok.version", "1.18.6");
        props.put("junit.version", "4.12");
        Model model = Model.newBuilder(true).properties(props).build();
        String xml = toXml(model);

        for (int i = 0; i < 10; i++) {

        then:
        executedAndNotSkipped ":run"
        assertOutputFileIs('''\
        2
        3
        4
        '''.stripIndent())
    }

    @Issue(["GRADLE-1483", "GRADLE-3528"])
    def "when the user declares outputs it becomes incremental"() {
        given:
        buildFile << """
            run.outputs.file "out.txt"
        """

        when:

00000020  07 44 e3 2e 85 3f 1a 5f  f1 2a 24 20 cb e8 e8 c4  |.D...?._.*$ ....|
00000030  e9 28 01 21 9f 82 d2 da  6b 3e a0 7f 0d 20 95 12  |.(.!....k>... ..|
00000040  39 5b 3f f8 04 86 df 9b  72 3b 74 e2 00 04 13 03  |9[?.....r;t.....|
00000050  00 ff 01 00 00 94 00 0b  00 04 03 00 01 02 00 0a  |................|
00000060  00 06 00 04 00 17 00 1d  00 16 00 00 00 17 00 00  |................|