d9fa54d0300a6ac74936 Result = F (1 - Message changed) Msg = fd5d8331e5cdd7f205bd Qx = f4fd02f3d224727e156a Qy = e7aa734828ef326259f9 R = 9f57e28f69d2ebd96f6d S = 8cfe716488479e04500c Result = F (4 - Q changed) Msg = 0f05382e2df448462075 Qx = 0fdb8faf52d8f46229cc Qy = 96c8d1946528bdd2c14c R = c53c0ce7d408278552a5 S = be7453a12693ce7812fe Result = F (4 - Q changed) Msg = 826ca168835f0d8b3005 Qx = 240431da69703b32ba2a Qy = 13beb5198ee00abdcfb2 R = ad03bdf64e3450407a2a S = 7b55db9abf2045e2dc7c Result = F (1 - Message...

	y2 float64 = z2
	y3 float64 = z3
)

func test32(f float32) {
	if f != 0 || math.Signbit(float64(f)) {
		println("BUG: got", f, "want 0.0")
		return
	}
}

func test64(f float64) {
	if f != 0 || math.Signbit(f) {
		println("BUG: got", f, "want 0.0")
		return
	}
}

func main() {
	if f := -x0; f != 0 || !math.Signbit(float64(f)) {
		println("BUG: got", f, "want -0.0")
	}

	test32(-0.0)
	test32(x0)

	}
	return a[0:w]
}

// Filter eliminates documentation for names that don't pass through the filter f.
// TODO(gri): Recognize "Type.Method" as a name.
func (p *Package) Filter(f Filter) {
	p.Consts = filterValues(p.Consts, f)
	p.Vars = filterValues(p.Vars, f)
	p.Types = filterTypes(p.Types, f)
	p.Funcs = filterFuncs(p.Funcs, f)
	p.Doc = "" // don't show top-level package doc

	t.Logf("Unlock(fd %d) = %v", f.Fd(), err)
	if err != nil {
		t.Fail()
	}
}

func mustTempFile(t *testing.T) (f *os.File, remove func()) {
	t.Helper()

	base := filepath.Base(t.Name())
	f, err := os.CreateTemp("", base)
	if err != nil {
		t.Fatalf(`os.CreateTemp("", %q) = %v`, base, err)
	}
	t.Logf("fd %d = %s", f.Fd(), f.Name())

	return f, func() {
		f.Close()
		os.Remove(f.Name())
	}
}

		// The forwarder is now ready.
		return nil
	}
}

func (f *forwarder) Address() string {
	return net.JoinHostPort(f.localAddress, strconv.Itoa(f.localPort))
}

func (f *forwarder) Close() {
	close(f.stopCh)
	// Closing the stop channel should close anything
	// opened by f.forwarder.ForwardPorts()
}

func (f *forwarder) ErrChan() <-chan error {

// The caller should call f.Cache.freeBoolSlice(live) when it is done with it.
func findlive(f *Func) (reachable []bool, live []bool) {
	reachable = ReachableBlocks(f)
	var order []*Value
	live, order = liveValues(f, reachable)
	f.Cache.freeValueSlice(order)
	return
}

// ReachableBlocks returns the reachable blocks in f.
func ReachableBlocks(f *Func) []bool {

// Some more test cases.
func _() {
	_ = (-x).f
	_ = (*x).f
	_ = (&x).f
	_ = (!x).f
	_ = (-x.f)
	_ = (*x.f)
	_ = (&x.f)
	_ = (!x.f)
	(-x).f()
	(*x).f()
	(&x).f()
	(!x).f()
	_ = (-x.f())
	_ = (*x.f())
	_ = (&x.f())
	_ = (!x.f())

	_ = ((-x)).f
	_ = ((*x)).f
	_ = ((&x)).f
	_ = ((!x)).f
	_ = ((-x.f))
	_ = ((*x.f))
	_ = ((&x.f))
	_ = ((!x.f))
	((-x)).f()
	((*x)).f()
	((&x)).f()

// implications on the spec. See issue #51576.

/*
type Sf struct {
	f int
}

func f0[P Sf](p P) {
	_ = p.f
	p.f = 0
}

func f0t[P ~struct{ f int }](p P) {
	_ = p.f
	p.f = 0
}

var _ = f0[Sf]
var _ = f0t[Sf]

func f1[P interface {
	~struct{ f int }
	m()
}](p P) {
	_ = p.f
	p.f = 0
	p.m()
}

var _ = f1[Sfm]

type Sm struct{}

func (Sm) m() {}

		_ = i
	}
	{
		// change of type for f
		i, f, s := f3()
		f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible|cannot use"
		_, _, _, _, _ = i, f, s, g, t
	}
	{
		// change of type for i
		i, f, s := f3()
		j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible|cannot use"
		_, _, _, _, _ = i, f, s, j, t
	}
	{
		// no new variables
		i, f, s := f3()
		i, f := f2() // ERROR "redeclared|no new"

			Exit("mem5"),
		),
	)
	flagalloc(f.f)
	regalloc(f.f)
	checkFunc(f.f)
	// Spill should be moved to exit2.
	if numSpills(f.blocks["loop1"]) != 0 {
		t.Errorf("spill present from loop1")
	}
	if numSpills(f.blocks["loop2"]) != 0 {
		t.Errorf("spill present in loop2")
	}
	if numSpills(f.blocks["exit1"]) != 0 {
		t.Errorf("spill present in exit1")
	}
	if numSpills(f.blocks["exit2"]) != 1 {