// right place so we wind up at tteN when n%5=N.
	switch n % 5 {
	case 0:
		stack <- tte0(n)
	case 1:
		stack <- tte1(n)
	case 2:
		stack <- tte2(n)
	case 3:
		stack <- tte3(n)
	case 4:
		stack <- tte4(n)
	default:
		panic("unreachable")
	}
}
func tte0(n int) string {
	return tte4(n - 1)
}
func tte1(n int) string {
	return tte0(n - 1)
}
func tte2(n int) string {

	VMOVDQA ·chacha20Constants<>(SB), TT0
	VPADDD  TT0, AA0, AA0; VPADDD TT0, AA1, AA1; VPADDD TT0, AA2, AA2
	VPADDD  TT1, BB0, BB0; VPADDD TT1, BB1, BB1; VPADDD TT1, BB2, BB2
	VPADDD  TT2, CC0, CC0; VPADDD TT2, CC1, CC1; VPADDD TT2, CC2, CC2
	VMOVDQA ·avx2IncMask<>(SB), TT0
	VPADDD  TT3, DD0, DD0; VPADDD TT0, TT3, TT3
	VPADDD  TT3, DD1, DD1; VPADDD TT0, TT3, TT3
	VPADDD  TT3, DD2, DD2

	// ---------------------------------------------------

	VSCBIQ  PL, T0, CAR1
	VSQ     PL, T0, TT0
	VSBCBIQ T1, PH, CAR1, CAR2
	VSBIQ   T1, PH, CAR1, TT1
	VSBIQ   T2, ZER, CAR2, T2

	// what output to use, TT1||TT0 or T1||T0?
	VSEL T0, TT0, T2, T0
	VSEL T1, TT1, T2, T1

	VPDI $0x4, T0, T0, TT0
	VST  TT0, (0*16)(res_ptr)
	VPDI $0x4, T1, T1, TT1
	VST  TT1, (1*16)(res_ptr)
	RET

#undef res_ptr

	k := 4
	var t0, t1, t2, t3 uint32
	for r := 0; r < nr; r++ {
		t0 = xk[k+0] ^ te0[uint8(s0>>24)] ^ te1[uint8(s1>>16)] ^ te2[uint8(s2>>8)] ^ te3[uint8(s3)]
		t1 = xk[k+1] ^ te0[uint8(s1>>24)] ^ te1[uint8(s2>>16)] ^ te2[uint8(s3>>8)] ^ te3[uint8(s0)]
		t2 = xk[k+2] ^ te0[uint8(s2>>24)] ^ te1[uint8(s3>>16)] ^ te2[uint8(s0>>8)] ^ te3[uint8(s1)]
		t3 = xk[k+3] ^ te0[uint8(s3>>24)] ^ te1[uint8(s0>>16)] ^ te2[uint8(s1>>8)] ^ te3[uint8(s2)]
		k += 4

	VSUBUQM  T0, PL, TT0        // VSQ     PL, T0, TT0
	VSUBECUQ T1, PH, CAR1, CAR2 // VSBCBIQ T1, PH, CAR1, CAR2
	VSUBEUQM T1, PH, CAR1, TT1  // VSBIQ   T1, PH, CAR1, TT1
	VSUBEUQM T2, ZER, CAR2, T2  // VSBIQ   T2, ZER, CAR2, T2

	VSEL TT0, T0, T2, T0
	VSEL TT1, T1, T2, T1

	// Reorder the bytes so STXVD2X can be used.
	// TT0, TT1 used for VPERM result in case

// (Can adapt this code to generate them too.)
func TestTe(t *testing.T) {
	for i := 0; i < 256; i++ {
		s := uint32(sbox0[i])
		s2 := mul(s, 2)
		s3 := mul(s, 3)
		w := s2<<24 | s<<16 | s<<8 | s3
		te := [][256]uint32{te0, te1, te2, te3}
		for j := 0; j < 4; j++ {
			if x := te[j][i]; x != w {
				t.Fatalf("te[%d][%d] = %#x, want %#x", j, i, x, w)
			}
			w = w<<24 | w>>8
		}
	}
}

	0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
}

// Lookup tables for encryption.
// These can be recomputed by adapting the tests in aes_test.go.

var te0 = [256]uint32{
	0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554,
	0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a,

:›Ö7_]ZéŠzjs®¼N'¼71Ö cxqyKÜo¨ØÞpáЈenKízR}’®úuZLcHƦ 9»/ ¤º ( ¿, £¬øN@\Kª«³_ilgñ¬sÈIQBha2Z V&`ÄØD }ObdmkN~¼ª ˆ¾¾¸< 쾄 ¢€€¸²¦¢ˆ²¾¼ ¨ªŒª¸¾€ª„†8 †ªª °ˆˆ€† >>º²¼<²¾>¨¾¦†>º²¼²¾>¸²¼Š >¨ªŒª¸¾€ª„b> DsqBázM²OªByùmGF¸ ˆ¾ Œ²ªŽ ú²¼òþ Æèö† ¬¾„ †Š€€¾„ˆª¨ ¸¢¼®Š¢®ª†<tt&& îüÊ>ø²¼Š ttʆª ˆ°ª ¬¾¸¸¾jÌX®7±©­­µ«¿7Ÿ©7“Š¼ ¢ †ˆ¢¼¨¢¸¾¼ª ú²¼òþ †ª„Œª„ ¾¼ ø²¼Š °¾†ˆ† „Š¼¼²¼® :¤²ˆ ò¼ˆª¸>âúè ¢„¦°²ˆª¦ˆŠ`ª‘+7Ó½—¯µ±½7··>¨¢ˆ¢ Ž²ˆ° ˆ°ª €¢ˆ° ˆ¾ ˆ°ª ¨„²Œª ¾„ ¨²„ª¦ˆ¾„’ ²¼ Ž°²¦° ’¾Š Ž¢¼ˆ ú²¼òþ ˆ¾ †ˆ¾„N^L¢‹/ · xfqEF¸ rtÜ@}¦‘—ÝåÂpGú¨wmë£iåTqU }_ìac­tjïB»oiWzeÈ©~mOe+W...

FB62..FB65    ; mapped                 ; 067F          # 1.1  ARABIC LETTER TEHEH ISOLATED FORM..ARABIC LETTER TEHEH MEDIAL FORM
FB66..FB69    ; mapped                 ; 0679          # 1.1  ARABIC LETTER TTEH ISOLATED FORM..ARABIC LETTER TTEH MEDIAL FORM
FB6A..FB6D    ; mapped                 ; 06A4          # 1.1  ARABIC LETTER VEH ISOLATED FORM..ARABIC LETTER VEH MEDIAL FORM