{"\x00\f\x00\xf3\xff", ""},
		{"\x00\f\x00\xf3\xffhello", "hello"},
		{"\x00\f\x00\xf3\xffhello, world", "hello, world"},
		{"\x02", ""},
		{"\xf2H\xcd", "He"},
		{"\xf2H͙0a\u0084\t", "Hel\x90\x90\x90\x90\x90"},
		{"\xf2H͙0a\u0084\t\x00", "Hel\x90\x90\x90\x90\x90"},
	}

	for i, v := range vectors {
		r := strings.NewReader(v.input)
		zr := NewReader(r)
		b, err := io.ReadAll(zr)
		if err != io.ErrUnexpectedEOF {

	{0xd7ff, "\xed\x9f\xbf"}, // last code point before surrogate half.
	{0xe000, "\xee\x80\x80"}, // first code point after surrogate half.
	{0xfffe, "\xef\xbf\xbe"},
	{0xffff, "\xef\xbf\xbf"},
	{0x10000, "\xf0\x90\x80\x80"},
	{0x10001, "\xf0\x90\x80\x81"},
	{0x40000, "\xf1\x80\x80\x80"},
	{0x10fffe, "\xf4\x8f\xbf\xbe"},
	{0x10ffff, "\xf4\x8f\xbf\xbf"},
	{0xFFFD, "\xef\xbf\xbd"},
}

var surrogateMap = []Utf8Map{

	var x88 uint64
	x87, x88 = bits.Sub64(x80, 0x14def9dea2f79cd6, uint64(fiatScalarUint1(x86)))
	var x89 uint64
	var x90 uint64
	x89, x90 = bits.Sub64(x82, uint64(0x0), uint64(fiatScalarUint1(x88)))
	var x91 uint64
	var x92 uint64
	x91, x92 = bits.Sub64(x84, 0x1000000000000000, uint64(fiatScalarUint1(x90)))
	var x94 uint64
	_, x94 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(fiatScalarUint1(x92)))
	var x95 uint64

	var x81 [10<<20]byte
	var x82 [10<<20]byte
	var x83 [10<<20]byte
	var x84 [10<<20]byte
	var x85 [10<<20]byte
	var x86 [10<<20]byte
	var x87 [10<<20]byte
	var x88 [10<<20]byte
	var x89 [10<<20]byte
	var x90 [10<<20]byte
	var x91 [10<<20]byte
	var x92 [10<<20]byte
	var x93 [10<<20]byte
	var x94 [10<<20]byte
	var x95 [10<<20]byte
	var x96 [10<<20]byte
	var x97 [10<<20]byte
	var x98 [10<<20]byte

	"\x85", "%85",
	"\x86", "%86",
	"\x87", "%87",
	"\x88", "%88",
	"\x89", "%89",
	"\x8A", "%8A",
	"\x8B", "%8B",
	"\x8C", "%8C",
	"\x8D", "%8D",
	"\x8E", "%8E",
	"\x8F", "%8F",
	"\x90", "%90",
	"\x91", "%91",
	"\x92", "%92",
	"\x93", "%93",
	"\x94", "%94",
	"\x95", "%95",
	"\x96", "%96",
	"\x97", "%97",
	"\x98", "%98",
	"\x99", "%99",
	"\x9A", "%9A",
	"\x9B", "%9B",

	},
	{
		str:  "\xED\xBB\xAE",
		wstr: []uint16{0xDEEE},
	},
	{
		str:  "\xED\xBF\xBF",
		wstr: []uint16{0xDFFF},
	},

	// 4-byte
	{
		str:  "\xF0\x90\x80\x80",
		wstr: []uint16{0xD800, 0xDC00},
	},
	{
		str:  "\xF0\x9D\x8C\x86",
		wstr: []uint16{0xD834, 0xDF06},
	},
	{
		str:  "\xF4\x8F\xBF\xBF",
		wstr: []uint16{0xDBFF, 0xDFFF},
	},
}

	}
}

func FuzzUTF16FromString(f *testing.F) {
	f.Add("hi")           // ASCII
	f.Add("â")            // latin1
	f.Add("ねこ")           // plane 0
	f.Add("😃")            // extra Plane 0
	f.Add("\x90")         // invalid byte
	f.Add("\xe3\x81")     // truncated
	f.Add("\xe3\xc1\x81") // invalid middle byte

	f.Fuzz(func(t *testing.T, tst string) {
		res, err := syscall.UTF16FromString(tst)
		if err != nil {

		"TOBEORNOTTOBEORTOBEORNOT",
		"\x54\x4f\x42\x45\x4f\x52\x4e\x4f\x54\x82\x84\x86\x8b\x85\x87\x89\x81",
		nil,
	},
	{
		"tobe;MSB;8",
		"TOBEORNOTTOBEORTOBEORNOT",
		"\x2a\x13\xc8\x44\x52\x79\x48\x9c\x4f\x2a\x40\xa0\x90\x68\x5c\x16\x0f\x09\x80\x80",
		nil,
	},
	{
		"tobe-truncated;LSB;8",
		"TOBEORNOTTOBEORTOBEORNOT",
		"\x54\x9e\x08\x29\xf2\x44\x8a\x93\x27\x54\x04",
		io.ErrUnexpectedEOF,
	},

    X73,
    X74,
    X75,
    X76,
    X77,
    X78,
    X79,
    X80,
    X81,
    X82,
    X83,
    X84,
    X85,
    X86,
    X87,
    X88,
    X89,
    X90,
    X91,
    X92,
    X93,
    X94,
    X95,
    X96,
    X97,
    X98,
    X99
  }

  private enum LargeEnum {
    X0,
    X1,
    X2,
    X3,
    X4,

    X73,
    X74,
    X75,
    X76,
    X77,
    X78,
    X79,
    X80,
    X81,
    X82,
    X83,
    X84,
    X85,
    X86,
    X87,
    X88,
    X89,
    X90,
    X91,
    X92,
    X93,
    X94,
    X95,
    X96,
    X97,
    X98,
    X99
  }

  private enum LargeEnum {
    X0,
    X1,
    X2,
    X3,
    X4,