* must not both be identical to the values given in the first mapping. If only the {@code x}
     * values are identical, the transformation is vertical. If only the {@code y} values are
     * identical, the transformation is horizontal (i.e. the slope is zero).
     */
    public LinearTransformation and(double x2, double y2) {

	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...)

	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

	VPOPCNTW 99(R15), K3, X23                          // 62c2fd0b54bf63000000
	VPOPCNTW X20, K3, X2                               // 62b2fd0b54d4
	VPOPCNTW X5, K3, X2                                // 62f2fd0b54d5
	VPOPCNTW X25, K3, X2                               // 6292fd0b54d1
	VPOPCNTW (CX), K3, X2                              // 62f2fd0b5411
	VPOPCNTW 99(R15), K3, X2                           // 62d2fd0b549763000000

	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

	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);

      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) {

      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) {

	CFLDSP	32(X5), F10				// ERROR "rs2 must be SP/X2"
	CFLDSP	32(SP), X10				// ERROR "expected float register in rd position"
	CFLDSP	36(SP), F10				// ERROR "must be a multiple of 8"
	CSWSP	X10, 20(X5)				// ERROR "rd must be SP/X2"
	CSWSP	F10, 20(SP)				// ERROR "expected integer register in rs2 position"
	CSWSP	X10, 22(SP)				// ERROR "must be a multiple of 4"
	CSDSP	X10, 24(X5)				// ERROR "rd must be SP/X2"