if len(s) <= bytealg.MaxBruteForce {
			return bytealg.Index(s, sep)
		}
		c0 := sep[0]
		c1 := sep[1]
		i := 0
		t := len(s) - n + 1
		fails := 0
		for i < t {
			if s[i] != c0 {
				// IndexByte is faster than bytealg.Index, so use it as long as
				// we're not getting lots of false positives.
				o := IndexByte(s[i+1:t], c0)
				if o < 0 {
					return -1
				}
				i += o + 1
			}

0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06
0000130 00 f9 ff 6d 01 00 00 00 00 42 e8 21 5e 0f 00 00
0000140 00 ff ff 0a f0 66 64 12 61 c0 15 dc e8 a0 48 bf
0000150 48 af 2a b3 20 c0 9b 95 0d c4 67 04 42 53 06 06
0000160 06 40 00 06 00 f9 ff 6d 01 00 00 00 00 50 4b 01

     * 00010: 43 45 46 45 45 43 41 43 41 43 41 43 41 43 41 43  |CEFEECACACACACAC|
     * 00020: 41 43 41 43 41 43 41 43 41 43 41 41 44 00 00 20  |ACACACACACAAD.. |
     * 00030: 00 01 c0 0c 00 20 00 01 00 00 00 00 00 06 20 00  |..... ........ .|
     * 00040: ac 22 22 e1                                      |."".            |
     * </pre>
     *
     * @param ps the PrintStream to write the hexdump output to

     */
    private fun schemeDelimiterOffset(
      input: String,
      pos: Int,
      limit: Int,
    ): Int {
      if (limit - pos < 2) return -1

      val c0 = input[pos]
      if ((c0 < 'a' || c0 > 'z') && (c0 < 'A' || c0 > 'Z')) return -1 // Not a scheme start char.

      characters@ for (i in pos + 1 until limit) {
        return when (input[i]) {
          // Scheme character. Keep going.

	B4 func(int, float64) *B0
	B5 func(x int, y float64) *A1

	C0 = B0
	D0[P1, P2 any] struct{ x P1; y P2 }
	E0 = D0[int, string]
)
</pre>

<p>
these types are identical:
</p>

<pre>
A0, A1, and []string
A2 and struct{ a, b int }
A3 and int
A4, func(int, float64) *[]string, and A5

B0 and C0
D0[int, string] and E0
[]int and []int

addMulVVWWasm(z, x *uint, y uint, n uintptr) (carry uint) { const mask32 = 1<<32 - 1 y0 := y & mask32 y1 := y >> 32 for i := range n { xi := *idx(x, i) x0 := xi & mask32 x1 := xi >> 32 zi := *idx(z, i) z0 := zi & mask32 z1 := zi >> 32 c0 := carry & mask32 c1 := carry >> 32 w00 := x0*y0 + z0 + c0 l00 := w00 & mask32 h00 := w00 >> 32 w01 := x0*y1 + z1 + h00 l01 := w01 & mask32 h01 := w01 >> 32 w10 := x1*y0 + c1 + l01 h10 := w10 >> 32 carry = x1*y1 + h10 + h01 *idx(z, i) = w10<<32 + l00 } return carry } func addMulVVW1024(z,...

func pkEncode(buf []byte, ρ []byte, t1 [][n]uint16, p parameters) []byte { pk := append(buf, ρ...) for _, w := range t1[:p.k] { // Encode four at a time into 4 * 10 bits = 5 bytes. for i := 0; i < n; i += 4 { c0 := w[i] c1 := w[i+1] c2 := w[i+2] c3 := w[i+3] b0 := byte(c0 >> 0) b1 := byte((c0 >> 8) | (c1 << 2)) b2 := byte((c1 >> 6) | (c2 << 4)) b3 := byte((c2 >> 4) | (c3 << 6)) b4 := byte(c3 >> 2) pk = append(pk, b0, b1, b2, b3, b4) } } return pk } func pkDecode(pk []byte, t1 [][n]uint16, p parameters)...