}
	if s == nil {
		panic(arg + " == nil")
	}
}

func main() {
	checkBytes([]byte(""), `[]byte("")`)
	checkBytes([]byte(mystring("")), `[]byte(mystring(""))`)
	checkBytes(mybytes(""), `mybytes("")`)
	checkBytes(mybytes(mystring("")), `mybytes(mystring(""))`)

	checkRunes([]rune(""), `[]rune("")`)
	checkRunes([]rune(mystring("")), `[]rune(mystring(""))`)
	checkRunes(myrunes(""), `myrunes("")`)

	{V((**byte)(nil)), V((**byte)(nil))},
	{V((**MyByte)(nil)), V((**MyByte)(nil))},
	{V((chan byte)(nil)), V((chan byte)(nil))},
	{V((chan MyByte)(nil)), V((chan MyByte)(nil))},
	{V(([]byte)(nil)), V(([]byte)(nil))},
	{V(([]MyByte)(nil)), V(([]MyByte)(nil))},
	{V((map[int]byte)(nil)), V((map[int]byte)(nil))},
	{V((map[int]MyByte)(nil)), V((map[int]MyByte)(nil))},
	{V((map[byte]int)(nil)), V((map[byte]int)(nil))},

	},
	{
		Value:         &Data{Bytes: []byte{}, Custom: MyBytes{}, Attr: []byte{}},
		ExpectXML:     `<Data Attr=""><Bytes></Bytes><Custom></Custom></Data>`,
		UnmarshalOnly: true,
	},

	// Check that []byte works, including named []byte types.
	{
		Value:     &Data{Bytes: []byte("ab"), Custom: MyBytes("cd"), Attr: []byte{'v'}},
		ExpectXML: `<Data Attr="v"><Bytes>ab</Bytes><Custom>cd</Custom></Data>`,
	},

	VLD1	(R2), [V28.S4, V29.S4, V30.S4, V31.S4]     //load 64*4bytes K constant(K0-K63)

blockloop:

	VLD1.P	16(R1), [V4.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V5.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V6.B16]                            // load 16bytes message
	VLD1.P	16(R1), [V7.B16]                            // load 16bytes message

type myByte1 []byte
type myByte2 []byte
func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] }
func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR "no core type" */ [i:j:k] }

func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }

</pre>
</li>

<li>
Converting a slice of bytes to a string type yields
a string whose successive bytes are the elements of the slice.

<pre>
string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'})   // "hellø"
string([]byte{})                                     // ""
string([]byte(nil))                                  // ""

type MyBytes []byte
string(MyBytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'})  // "hellø"
</pre>

// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func f[T []MyByte](x T) string {
	return string(x)
}

func g[T []MyRune](x T) string {
	return string(x)
}

func main() {
	var y []MyByte
	_ = f(y)
	_ = string(y)

	var z []MyRune
	_ = g(z)
	_ = string(z)

	// 4
	_ = []byte("hellø") // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
	_ = []byte("")      // []byte{}

	_ = bytes("hellø") // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}

	_ = []myByte("world!")      // []myByte{'w', 'o', 'r', 'l', 'd', '!'}
	_ = []myByte(myString("🌏")) // []myByte{'\xf0', '\x9f', '\x8c', '\x8f'}

	// 5
	_ = []rune(myString("白鵬翔")) // []rune{0x767d, 0x9d6c, 0x7fd4}

// Test case where a slice of a user-defined byte type (not uint8 or byte) is
// converted to a string.  Same for slice of runes.

package main

type MyByte byte

type MyRune rune

func main() {
	var y []MyByte
	_ = string(y)

	var z []MyRune
	_ = string(z)

/**
 * Static utility methods pertaining to {@code byte} primitives, that are not already found in
 * either {@link Byte} or {@link Arrays}, <i>and interpret bytes as neither signed nor unsigned</i>.
 * The methods which specifically treat bytes as signed or unsigned are found in {@link SignedBytes}
 * and {@link UnsignedBytes}.
 *
 * <p>See the Guava User Guide article on <a