{complex(1, zero), complex(2, zero), complex(0.5, zero)},
	{complex(1, zero), complex(2, -zero), complex(0.5, zero)},
	{complex(1, zero), complex(2, 1), complex(0.4, -0.2)},
	{complex(1, zero), complex(2, -1), complex(0.4, 0.2)},
	{complex(1, zero), complex(2, 2), complex(0.25, -0.25)},
	{complex(1, zero), complex(nan, nan), complex(nan, nan)},
	{complex(1, zero), complex(nan, inf), complex(zero, -zero)},

      "dependencies": {
        "type-fest": "^0.20.2"
      },
      "engines": {
        "node": ">=8"
      },
      "funding": {
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/globals/node_modules/type-fest": {
      "version": "0.20.2",
      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",

    %cst = "tf.Const"() {value = dense<[1, 1, 8]> : tensor<3xi32>} : () -> tensor<3xi32>
    %0 = "tf.XlaGather"(%arg0, %arg1, %cst) {dimension_numbers = "\0A\03\00\01\02\1A\01\02", indices_are_sorted = true} : (tensor<1x1x9xi32>, tensor<1xi32>, tensor<3xi32>) -> tensor<*xi32>
    func.return %0 : tensor<*xi32>
  }

  // CHECK-LABEL: func @xla_gather_with_fold

//   }
//   tuple_shardings: {
//     type: OTHER
//     tile_assignment_dimensions: [ 2, 1 ]
//     tile_assignment_devices   : [ 0, 1 ]
//   }
// Serialized string:
//   "\08\02*\0A\08\03\1A\02\02\01\22\02\00\01*\0A\08\03\1A\02\02\01\22\02\00\01"

// Test that an attempt to map an invalid cluster output index to core program
// index is caught. The output has sharding type TUPLE, which causes the

			success:  false,
			testName: "multicast IPv6 address",
		},
		{
			nodeIP:   "169.254.0.1",
			success:  false,
			testName: "IPv4 link-local unicast address",
		},
		{
			nodeIP:   "fe80::0202:b3ff:fe1e:8329",
			success:  false,
			testName: "IPv6 link-local unicast address",
		},
		{
			nodeIP:   "0.0.0.0",
			success:  false,
			testName: "Unspecified IPv4 address",
		},
		{

					} else if bo&0x10 == 0x10 {
						// A branch based on the value of CTR. Invert the CTR comparison against zero bit.
						bo ^= 0x2
						invertible = true
					} else if bo&0x04 == 0x04 {
						// A branch based on CR bit. Invert the BI comparison bit.
						bo ^= 0x8
						invertible = true
					}

					if invertible {
						// Rewrite

  // CHECK-DAG: %[[COMP2:.*]] = "tf.Const"() <{value = dense<[(0.000000e+00,0.000000e+00), (2.000000e+00,0.000000e+00)]> : tensor<2xcomplex<f32>>}> : () -> tensor<2xcomplex<f32>>
  // CHECK-DAG: %[[COMP1:.*]] = "tf.Const"() <{value = dense<[(1.000000e+00,3.000000e+00), (2.000000e+00,4.000000e+00)]> : tensor<2xcomplex<f32>>}> : () -> tensor<2xcomplex<f32>>

        )
        q_filter = array_ops.fake_quant_with_min_max_vars_per_channel(
            filter_tensor, filter_min, filter_max, num_bits=8, narrow_range=True
        )
        bias = array_ops.constant([0.1, 0.2], dtype=dtypes.float32)
        scale, offset = [1.0] * 2, [0.5] * 2
        mean, variance = scale, offset
        out = nn_ops.conv2d(
            q_input,
            q_filter,
            strides=[1, 1, 2, 1],

		for i := 0; i < 10; i++ {
			v := ValueOf(new([]byte)).Elem()
			v.Grow(61)
			b := v.Bytes()
			b = b[:cap(b)]
			for i, c := range b {
				if c != 0 {
					t.Fatalf("Value.Bytes[%d] = 0x%02x, want 0x00", i, c)
				}
				b[i] = 0xff
			}
			runtime.GC()
		}
	})
}

var appendTests = []struct {
	orig, extra []int
}{
	{nil, nil},
	{[]int{}, nil},
	{nil, []int{}},