{"\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{

	x85, x86 = bits.Add64(x62, x76, uint64(p224Uint1(x84)))
	var x87 uint64
	var x88 uint64
	x87, x88 = bits.Add64(x64, x78, uint64(p224Uint1(x86)))
	var x89 uint64
	var x90 uint64
	x89, x90 = bits.Add64(x66, x80, uint64(p224Uint1(x88)))
	x91 := (uint64(p224Uint1(x90)) + uint64(p224Uint1(x67)))
	var x92 uint64
	var x93 uint64
	x93, x92 = bits.Mul64(x2, arg2[3])
	var x94 uint64
	var x95 uint64
	x95, x94 = bits.Mul64(x2, arg2[2])

	var x88 uint64
	p256CmovznzU64(&x88, p256Uint1(x86), x79, x72)
	var x89 uint64
	p256CmovznzU64(&x89, p256Uint1(x86), x81, x74)
	var x90 uint64
	p256CmovznzU64(&x90, p256Uint1(x86), x83, x76)
	out1[0] = x87
	out1[1] = x88
	out1[2] = x89
	out1[3] = x90
}

// p256ToMontgomery translates a field element into the Montgomery domain.
//
// Preconditions:
//
//	0 ≤ eval arg1 < m
//

	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},
	},
}

	x85, x86 = bits.Add64(x76, x73, uint64(p384Uint1(x84)))
	var x87 uint64
	var x88 uint64
	x87, x88 = bits.Add64(x74, x71, uint64(p384Uint1(x86)))
	var x89 uint64
	var x90 uint64
	x89, x90 = bits.Add64(x72, x69, uint64(p384Uint1(x88)))
	x91 := (uint64(p384Uint1(x90)) + x70)
	var x92 uint64
	var x93 uint64
	x92, x93 = bits.Add64(x57, x79, uint64(0x0))
	var x94 uint64
	var x95 uint64

	}
}

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 {