b.WriteString("alpha")
	check(t, &b, "alpha")
	s1 := b.String()
	b.WriteString("beta")
	check(t, &b, "alphabeta")
	s2 := b.String()
	b.WriteString("gamma")
	check(t, &b, "alphabetagamma")
	s3 := b.String()

	// Check that subsequent operations didn't change the returned strings.
	if want := "alpha"; s1 != want {
		t.Errorf("first String result is now %q; want %q", s1, want)
	}
	if want := "alphabeta"; s2 != want {

	irm := ldr.IsReflectMethod(es1)
	if 0 != es1val {
		t.Errorf("expected IsReflectMethod(es1) value of 0, got %v", irm)
	}
}

func sameRelocSlice(s1 *Relocs, s2 []Reloc) bool {
	if s1.Count() != len(s2) {
		return false
	}
	for i := 0; i < s1.Count(); i++ {
		r1 := s1.At(i)
		r2 := &s2[i]
		if r1.Sym() != r2.Sym() ||
			r1.Type() != r2.Type() ||
			r1.Off() != r2.Off() ||
			r1.Add() != r2.Add() ||

// genConcat2 generates the cross product of the strings of g1 concatenated
// with those of g2.
func genConcat2(g1, g2 generator) generator {
	return func(collect func(string)) {
		g1(func(s1 string) {
			g2(func(s2 string) {
				collect(s1 + s2)
			})
		})
	}
}

// genConcat generalizes genConcat2 to any number of generators.
func genConcat(gs ...generator) generator {
	if len(gs) == 0 {
		return genConst("")

func.func @testBroadcastGradientArgsSameShape() -> (tensor<0xi32>, tensor<0xi32>) {
  %s0 = "tf.Const"() {value = dense<[1, 2]> : tensor<2xi32>} : () -> tensor<2xi32>
  %s1 = "tf.Const"() {value = dense<[1, 2]> : tensor<2xi32>} : () -> tensor<2xi32>
  %r0, %r1 = "tf.BroadcastGradientArgs"(%s0, %s1) {} : (tensor<2xi32>, tensor<2xi32>) -> (tensor<0xi32>, tensor<0xi32>)

  // CHECK-DAG: %[[R:.*]] = "tf.Const"() <{value = dense<> : tensor<0xi32>}> : () -> tensor<0xi32>

	// Create servers that will act as SPIFFE bundle endpoints.
	s1 := httptest.NewTLSServer(h)
	s2 := httptest.NewTLSServer(h)

	// The system needs to trust these server certs to securely connect to
	// the SPIFFE bundle endpoints.
	serverCerts := []*x509.Certificate{s1.Certificate(), s2.Certificate()}

	input1 := map[string]string{
		"foo": s1.Listener.Addr().String(),
	}

                         kXlaHasHostTransferAttrName, true));
    Node* s1 = Sequencer(
        b2.opts().WithName("F1_sequencer").WithControlInputs({recv1, send1}),
        "F1");

    NodeBuilder node_builder1("F1", "F1", lib_def.get());
    node_builder1.Input(a).Input(b);
    Node* call1 =
        b2.opts().WithControlInputs({s1, b}).FinalizeBuilder(&node_builder1);

    Node* key_constant2 =

        assertThat(traverser instanceof JarFileTraverser, is(true));

        final List<String> list = new ArrayList<String>();
        traverser.forEach((ResourceHandler) (path, is) -> list.add(path));
        list.sort((s1, s2) -> s1.compareTo(s2));
        assertThat(list.size(), is(2));
        assertThat(list.get(0), is("junit/textui/ResultPrinter.class"));
        assertThat(list.get(1), is("junit/textui/TestRunner.class"));
    }

            state.put(
                rowFunction.apply(input),
                columnFunction.apply(input),
                valueFunction.apply(input),
                mergeFunction),
        (s1, s2) -> s1.combine(s2, mergeFunction),
        state -> state.toTable());
  }

  static <
          T extends @Nullable Object,
          R extends @Nullable Object,
          C extends @Nullable Object,
          V,

	}

	if want := [][]int{{1, 2}, {3, 4}}; !chunkEqual(got, want) {
		t.Errorf("Chunk iteration did not stop, got %v, want %v", got, want)
	}
}

func chunkEqual[Slice ~[]E, E comparable](s1, s2 []Slice) bool {
	return EqualFunc(s1, s2, Equal[Slice])

			continue
		}
		if s.Addr == 0 || s.Size == 0 {
			continue
		}
		secs = append(secs, s)
	}

	secOverlaps := func(s1, s2 *elf.Section) bool {
		st1 := s1.Addr
		st2 := s2.Addr
		en1 := s1.Addr + s1.Size
		en2 := s2.Addr + s2.Size
		return max(st1, st2) < min(en1, en2)
	}

	// Sort by address
	sort.SliceStable(secs, func(i, j int) bool {