VRANGESD $3, X22, X2, K4, X2                       // 62b3ed0c51d603
	VRANGESD $3, X5, X2, K4, X2                        // 62f3ed0c51d503
	VRANGESD $3, X14, X2, K4, X2                       // 62d3ed0c51d603
	VRANGESD $3, X22, X31, K4, X2                      // 62b3850451d603
	VRANGESD $3, X5, X31, K4, X2                       // 62f3850451d503
	VRANGESD $3, X14, X31, K4, X2                      // 62d3850451d603

	VPERMB -7(DI)(R8*2), X20, K1, X23                  // 62a25d018dbc47f9ffffff
	VPERMB X26, X2, K1, X23                            // 62826d098dfa
	VPERMB X19, X2, K1, X23                            // 62a26d098dfb
	VPERMB X0, X2, K1, X23                             // 62e26d098df8
	VPERMB 7(SI)(DI*4), X2, K1, X23                    // 62e26d098dbcbe07000000
	VPERMB -7(DI)(R8*2), X2, K1, X23                   // 62a26d098dbc47f9ffffff

	IMULB	DX
	IMULW	DX, BX
	IMULL	R11, R12
	IMULQ	foo+4(SB), R11

// LTYPEXC spec8	{ outcode($1, &$2); }
	CMPPD	X1, X2, 4
	CMPPD	foo+4(SB), X2, 4

// LTYPEX spec9	{ outcode($1, &$2); }
	PINSRW	$4, AX, X2
	PINSRW	$4, foo+4(SB), X2

// LTYPERT spec10	{ outcode($1, &$2); }
	JCS	2(PC)
	RETFL	$4

// Was bug: LOOP is a branch instruction.
	JCS	2(PC)
loop:

	VPSHRDVW X2, X2, K7, X0                            // 62f2ed0f72c2
	VPSHRDVW X31, X2, K7, X0                           // 6292ed0f72c7
	VPSHRDVW X11, X2, K7, X0                           // 62d2ed0f72c3
	VPSHRDVW (AX), X2, K7, X0                          // 62f2ed0f7200
	VPSHRDVW 7(SI), X2, K7, X0                         // 62f2ed0f728607000000
	VPSHRDVW X2, X8, K7, X0                            // 62f2bd0f72c2

	f1 T1
	f2 T2
}

func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] {
	return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}

func (p Pair[_, X2]) Second() X2 {
	return p.f2
}

// Deprecated: Use something else.
func Clone[S ~[]T, T any](s S) S {
	return append(S(nil), s...)

      buf[bufLen++] = getChar(h);

      int x0 = buf[bufLen - 1] & 0xff;
      int x1 = buf[bufLen - 2] & 0xff;
      int x2 = buf[bufLen - 3] & 0xff;
      int x3 = buf[bufLen / 2] & 0xff;
      buf[((x0 << 16) + (x1 << 8) + x2) % bufLen] ^= x3;
      buf[((x1 << 16) + (x2 << 8) + x3) % bufLen] ^= i % 256;
    }
    assertEquals(0xeaa3b1c985261632L, h);
  }

  private static long remix(long h) {

	VGETMANTSD $7, X24, X2, K4, X9                     // 6213ed0c27c807
	VGETMANTSD $8, X27, X2, K2, X2                     // 6293ed0a27d308 or 6293ed2a27d308 or 6293ed4a27d308
	VGETMANTSD $8, (R8), X2, K2, X2                    // 62d3ed0a271008 or 62d3ed2a271008 or 62d3ed4a271008

   * @throws X1 when the given throwable is of the declared type X1
   * @throws X2 when the given throwable is of the declared type X2
   */
  public <X1 extends Exception, X2 extends Exception> RuntimeException rethrow(
      Throwable e, Class<X1> declaredType1, Class<X2> declaredType2) throws IOException, X1, X2 {
    checkNotNull(e);
    thrown = e;
    throwIfInstanceOf(e, IOException.class);

	{"g", "R14"},
	{"SI", "SI"},
	{"SP", "SP"},
	{"X0", "X0"},
	{"X1", "X1"},
	{"X10", "X10"},
	{"X11", "X11"},
	{"X12", "X12"},
	{"X13", "X13"},
	{"X14", "X14"},
	{"X15", "X15"},
	{"X2", "X2"},
	{"X3", "X3"},
	{"X4", "X4"},
	{"X5", "X5"},
	{"X6", "X6"},
	{"X7", "X7"},
	{"X8", "X8"},
	{"X9", "X9"},
	{"_expand_key_128<>(SB)", "_expand_key_128<>(SB)"},
	{"_seek<>(SB)", "_seek<>(SB)"},

      buf[bufLen++] = getChar(h);

      int x0 = buf[bufLen - 1] & 0xff;
      int x1 = buf[bufLen - 2] & 0xff;
      int x2 = buf[bufLen - 3] & 0xff;
      int x3 = buf[bufLen / 2] & 0xff;
      buf[((x0 << 16) + (x1 << 8) + x2) % bufLen] ^= x3;
      buf[((x1 << 16) + (x2 << 8) + x3) % bufLen] ^= i % 256;
    }
    assertEquals(0x7a1d67c50ec7e167L, h);
  }

  private static long remix(long h) {