00000240  ea 53 41 b4 2e 1e f6 0b  33 f5 e1 40 69 c0 91 6f  |.SA.....3..@i..o|
00000250  88 c1 68 c8 18 99 6e fe  b3 5f 9b ee f1 4a 76 41  |..h...n.._...JvA|
00000260  1f d1 05 f5 39 76 61 e6  a6 ea 75 0e 50 32 a1 19  |....9va...u.P2..|
00000270  20 6a 4c 5d 62 6e 2a 6e  af f9 9c 38 b6 3a bc 86  | jL]bn*n...8.:..|
00000280  eb ac 6d d3 b5 48 30 11  4d 98 2e 61 34 16 03 03  |..m..H0.M..a4...|

64-bit variant, the <shift> is 0, 16, 32 or 48.

The current Go assembler does not accept zero shifts, such as "op $0, Rd" and "op $(0<<(16|32|48)), Rd" instructions.

Examples:

	MOVK $(10<<32), R20     <=>      movk x20, #10, lsl #32
	MOVZW $(20<<16), R8     <=>      movz w8, #20, lsl #16
	MOVK $(0<<16), R10 will be reported as an error by the assembler.

Special Cases.

(1) umov is written as VMOV.

00000350  ac a8 82 3d f5 ef 17 03  03 00 99 7e 30 4f f1 00  |...=.......~0O..|
00000360  1e dd eb c6 54 d2 f5 f7  21 aa 6b b0 83 0c fa 8b  |....T...!.k.....|
00000370  12 af ac 15 3e 54 b6 1c  85 9b 0c 80 02 d8 e3 5f  |....>T........._|
00000380  36 57 64 fe 7a b8 31 d0  aa 59 f1 e6 af e0 27 c5  |6Wd.z.1..Y....'.|
00000390  b8 d8 2f ab e0 cc c3 02  18 73 30 36 b5 2a 0d 12  |../......s06.*..|

		return util.NewErrs(fmt.Errorf("validatePortNumberString(%s) bad type %T, want string", path, val))
	}
	if val.(string) == "*" || val.(string) == "" {
		return nil
	}
	intV, err := strconv.ParseInt(val.(string), 10, 32)
	if err != nil {
		return util.NewErrs(fmt.Errorf("%s : %s", path, err))
	}
	return validatePortNumber(path, intV)
}

// validatePortNumber checks whether val is an integer representing a valid port number.

>>> Flow 1 (client to server)
00000000  16 03 01 00 eb 01 00 00  e7 03 03 ca 9d 80 22 cc  |..............".|
00000010  77 d9 f2 87 3f a8 93 a1  13 6f a0 f5 4e d0 1b fe  |w...?....o..N...|
00000020  cc 04 c0 7c 8d 7d 2e 5c  c2 6d 69 20 1e 1f 96 97  |...|.}.\.mi ....|
00000030  82 97 85 5b fd c1 59 cb  a5 2a 91 c1 b5 88 06 6c  |...[..Y..*.....l|
00000040  b0 ed 5c 41 78 cc f6 3c  28 d9 29 2b 00 04 13 03  |..\Ax..<(.)+....|

	VPERM2I128 $0x02, AA2, BB2, AA0; VPERM2I128 $0x02, CC2, DD2, BB0; VPERM2I128 $0x13, AA2, BB2, CC0; VPERM2I128 $0x13, CC2, DD2, DD0
	VPXOR      (8*32)(inp), AA0, AA0; VPXOR (9*32)(inp), BB0, BB0; VPXOR (10*32)(inp), CC0, CC0; VPXOR (11*32)(inp), DD0, DD0
	VMOVDQU    AA0, (8*32)(oup); VMOVDQU BB0, (9*32)(oup); VMOVDQU CC0, (10*32)(oup); VMOVDQU DD0, (11*32)(oup)

		}
	}
}

func TestRGBA64Image(t *testing.T) {
	// memset sets every element of s to v.
	memset := func(s []byte, v byte) {
		for i := range s {
			s[i] = v
		}
	}

	r := Rect(0, 0, 3, 2)
	testCases := []Image{
		NewAlpha(r),
		NewAlpha16(r),
		NewCMYK(r),
		NewGray(r),
		NewGray16(r),
		NewNRGBA(r),
		NewNRGBA64(r),
		NewNYCbCrA(r, YCbCrSubsampleRatio444),

	var b strings.Builder
	err = added.ExecuteTemplate(&b, "a", 0)
	if err != nil {
		t.Fatal(err)
	}
	if b.String() != "broot" {
		t.Errorf("expected %q got %q", "broot", b.String())
	}
}

// Issue 7032
func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
	master := "{{define \"master\"}}{{end}}"
	tmpl := New("master")
	tree, err := parse.Parse("master", master, "", "", nil)
	if err != nil {

		// values that start with plus sign (e.g, "+10") or leading zeros (e.g., "008") are not valid.
		if !validFirstDigit(value) {
			return 0, fmt.Errorf("invalid value %q", value)
		}

		i, err := strconv.ParseInt(value, 10, 32)
		if err != nil {
			// make sure we default to 0 on error.
			return 0, err
		}
		return int32(i), nil
	}
	return 0, nil
}

func validFirstDigit(str string) bool {
	if len(str) == 0 {

00000290  fd 1e bc 64 8b 01 3f a0  f8 8b 41 be 4d 97 07 6c  |...d..?...A.M..l|
000002a0  3b 09 74 d6 00 76 b3 a0  c0 d0 92 d0 78 24 d7 b2  |;.t..v......x$..|
000002b0  1f c0 86 90 59 3a fb a8  e1 f6 80 23 db f7 90 93  |....Y:.....#....|
000002c0  95 fd 37 14 8c 34 f3 07  10 f8 dd e3 66 28 1c b2  |..7..4......f(..|
000002d0  a0 14 03 03 00 01 01 16  03 03 00 40 00 00 00 00  |...........@....|