}

  private static void assertCannotSet(AbstractFuture<Integer> future) {
    assertThat(future.set(99)).isFalse();
    assertThat(future.setException(new IndexOutOfBoundsException())).isFalse();
    assertThat(future.setFuture(new AbstractFuture<Integer>() {})).isFalse();
    assertThat(future.setFuture(immediateFuture(99))).isFalse();
  }

  private static void assertCannotCancel(AbstractFuture<Integer> future) {

00000300  56 d6 40 86 91 31 3d ba  6b 41 bc 51 6f ac b2 df  |V.@..1=.kA.Qo...|
00000310  90 4b 78 17 03 03 00 99  21 0f 5b 18 54 84 98 0c  |.Kx.....!.[.T...|
00000320  3a 7b 0b db 99 0e 09 f6  b7 4f a9 cc da bf 4c ac  |:{.......O....L.|
00000330  5f 44 fc ba 9d 5d 52 d5  ec 2e 08 0c cc 3c e1 72  |_D...]R......<.r|
00000340  10 77 5b 7b 55 f7 c1 44  a3 25 e0 48 20 9a 3a de  |.w[{U..D.%.H .:.|

func Example_rand() {
	// Create and seed the generator.
	// Typically a non-fixed seed should be used, such as time.Now().UnixNano().
	// Using a fixed seed will produce the same output on every run.
	r := rand.New(rand.NewSource(99))

	// The tabwriter here helps us generate aligned output.
	w := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0)
	defer w.Flush()
	show := func(name string, v1, v2, v3 any) {

func.func @main(tensor<4xf32>) -> tensor<4xf32> {
^bb0(%arg0: tensor<4xf32>):
  // CHECK:      {
  // CHECK-NEXT:   version: 3,
  // CHECK-NEXT:   operator_codes: [ {
  // CHECK-NEXT:     deprecated_builtin_code: 99,
  // CHECK-NEXT:     version: 1,
  // CHECK-NEXT:     builtin_code: SQUARED_DIFFERENCE
  // CHECK-NEXT:   }, {
  // CHECK-NEXT:     deprecated_builtin_code: 18,
  // CHECK-NEXT:     version: 1,

	_ = x[InvalidReal-93]
	_ = x[InvalidAssert-94]
	_ = x[ImpossibleAssert-95]
	_ = x[InvalidConversion-96]
	_ = x[InvalidUntypedConversion-97]
	_ = x[BadOffsetofSyntax-98]
	_ = x[InvalidOffsetof-99]
	_ = x[UnusedExpr-100]
	_ = x[UnusedVar-101]
	_ = x[MissingReturn-102]
	_ = x[WrongResultCount-103]
	_ = x[OutOfScopeResult-104]
	_ = x[InvalidCond-105]
	_ = x[InvalidPostDecl-106]

	}
}

var deepEqualPerfTests = []struct {
	x, y any
}{
	{x: int8(99), y: int8(99)},
	{x: []int8{99}, y: []int8{99}},
	{x: int16(99), y: int16(99)},
	{x: []int16{99}, y: []int16{99}},
	{x: int32(99), y: int32(99)},
	{x: []int32{99}, y: []int32{99}},
	{x: int64(99), y: int64(99)},
	{x: []int64{99}, y: []int64{99}},
	{x: int(999999), y: int(999999)},
	{x: []int{999999}, y: []int{999999}},

  }

  private static void assertCannotSet(AbstractFuture<Integer> future) {
    assertThat(future.set(99)).isFalse();
    assertThat(future.setException(new IndexOutOfBoundsException())).isFalse();
    assertThat(future.setFuture(new AbstractFuture<Integer>() {})).isFalse();
    assertThat(future.setFuture(immediateFuture(99))).isFalse();
  }

  private static void assertCannotCancel(AbstractFuture<Integer> future) {

00000160  41 ab 8a fb 29 b7 22 93  c1 ea 92 29 45 a1 e5 46  |A...)."....)E..F|
00000170  92 98 30 5f 2e f1 90 f4  a0 cb b3 0a 64 16 be 4c  |..0_........d..L|
00000180  18 2c 83 ef 7b 7b e8 74  6f cf 99 c3 47 37 fd c4  |.,..{{.to...G7..|
00000190  a7 57 ba 2b d2 69 01 71  47 37 ac bd 7d a3 d7 cf  |.W.+.i.qG7..}...|
000001a0  ce e5 bc d3 75 f8 d3 d8  e7 b4 57 81 8d 92 05 04  |....u.....W.....|

   * StringBuilders (in a CharSequence[] to make it a little harder for the JVM).
   */
  @BeforeExperiment
  void setUp() {
    final long seed = 99;
    final Random rnd = new Random(seed);
    strings = new String[SAMPLES];
    for (int i = 0; i < SAMPLES; i++) {
      StringBuilder sb = new StringBuilder();
      for (int j = 0; j < charCount; j++) {

	VPERMT2B (CX), Z1, K3, Z6                          // 62f2754b7d31
	VPERMT2B 99(R15), Z1, K3, Z6                       // 62d2754b7db763000000
	VPERMT2B Z20, Z9, K3, Z6                           // 62b2354b7df4
	VPERMT2B Z9, Z9, K3, Z6                            // 62d2354b7df1
	VPERMT2B (CX), Z9, K3, Z6                          // 62f2354b7d31
	VPERMT2B 99(R15), Z9, K3, Z6                       // 62d2354b7db763000000