std::vector<DeviceCompilationClusterSignature> signatures = {s1, s2, s3};
  for (int i = 0; i < signatures.size(); ++i) {
    for (int j = 0; j < signatures.size(); ++j) {
      EXPECT_EQ(i == j, signatures[i] == signatures[j])
          << "s1: " << signatures[i].HumanString() << "\n"
          << "s2: " << signatures[j].HumanString();
      EXPECT_EQ(i == j,

			if s2.s == "/" {
				if s1.s != "" {
					b.WriteString(s1.s)
				} else {
					b.WriteString("x")
				}
			}
			return b.String()
		}
		if !s1.multi && s2.multi {
			writeSegment(&b, s1)
		} else if s1.wild && s2.wild {
			// Both patterns will match whatever we put here; use
			// the first wildcard name.
			writeSegment(&b, s1)
		} else if s1.wild && !s2.wild {

package main

var p0exp = S1{
	F1: complex(float64(2.3640607624715027), float64(-0.2717825524109192)),
	F2: S2{F1: 9},
	F3: 103050709,
}

type S1 struct {
	F1 complex128
	F2 S2
	F3 uint64
}

type S2 struct {
	F1 uint64
	F2 empty
}

type empty struct {
}

//go:noinline
//go:registerparams
func callee(p0 S1) {
	if p0 != p0exp {
		panic("bad p0")
	}
}

package main

import "reflect"

type S1 struct{ i int }
type S2 struct{ S1 }

func main() {
	typ := reflect.TypeOf(S2{})
	f := typ.Field(0)
	if f.Name != "S1" || f.Anonymous != true {
		println("BUG: ", f.Name, f.Anonymous)
		return
	}
	f, ok := typ.FieldByName("S1")
	if !ok {
		println("BUG: missing S1")
		return
	}
	if !f.Anonymous {
		println("BUG: S1 is not anonymous")
		return
	}

// Test multiple identical unnamed structs with methods.  This caused
// a compilation error with gccgo.

package p

type S1 struct{}

func (s S1) M() {}

type S2 struct {
	F1 struct {
		S1
	}
	F2 struct {
		S1
	}
}

type I interface {
	M()
}

func F() {
	var s2 S2
	var i1 I = s2.F1
	var i2 I = s2.F2
	_, _ = i1, i2

// j by 0, causing bounds check elimination to attempt
// something%0, which panics (in the bug).

package q

func f() {
	var s1 string
	var b bool
	if b {
		b = !b
		s1 += "a"
	}

	var s2 string
	var i, j int
	if (s1 <= "") || (s2 >= "") {
		j = len(s1[:6])
	} else {
		i = len("b")
	}

	for j < 0 {
		j += i
	}

    assertThat(dispatchedSubscribers).containsExactly(i1, i2, i3, s1, s1, s1, s1, s2, s2, s2, s2);
  }

  public void testImmediateDispatcher() {
    dispatcher = Dispatcher.immediate();
    dispatcher.dispatch(1, integerSubscribers.iterator());

    assertThat(dispatchedSubscribers)
        .containsExactly(
            i1, s1, s2, // Each integer subscriber immediately dispatches to 2 string subscribers.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type S1 struct {
	s2 S2
}

type S2 struct{}

func (S2) Make() S2 {
	return S2{}
}

func (S1) Make() S1 {
	return S1{s2: S2{}.Make()}
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f() {
	var i int
	var b *bool
	var s0, s1, s2 string

	if *b {
		s2 = s2[:1]
		i = 1
	}
	s1 = s1[i:-i+i] + s1[-i+i:i+2]
	s1 = s0[i:-i]

		t0 = xk[k+0] ^ te0[uint8(s0>>24)] ^ te1[uint8(s1>>16)] ^ te2[uint8(s2>>8)] ^ te3[uint8(s3)]
		t1 = xk[k+1] ^ te0[uint8(s1>>24)] ^ te1[uint8(s2>>16)] ^ te2[uint8(s3>>8)] ^ te3[uint8(s0)]
		t2 = xk[k+2] ^ te0[uint8(s2>>24)] ^ te1[uint8(s3>>16)] ^ te2[uint8(s0>>8)] ^ te3[uint8(s1)]
		t3 = xk[k+3] ^ te0[uint8(s3>>24)] ^ te1[uint8(s0>>16)] ^ te2[uint8(s1>>8)] ^ te3[uint8(s2)]
		k += 4
		s0, s1, s2, s3 = t0, t1, t2, t3
	}