}

func max(x, y float64) float64 {
	// special cases
	switch {
	case IsInf(x, 1) || IsInf(y, 1):
		return Inf(1)
	case IsNaN(x) || IsNaN(y):
		return NaN()
	case x == 0 && x == y:
		if Signbit(x) {
			return y
		}
		return x
	}
	if x > y {
		return x
	}
	return y
}

// Min returns the smaller of x or y.
//
// Special cases are:
//
//	Min(x, -Inf) = Min(-Inf, x) = -Inf

		return !pattern.IsValid() && !val.IsValid()
	}
	if pattern.Type() != val.Type() {
		return false
	}

	// Special cases.
	switch pattern.Type() {
	case identType:
		// For identifiers, only the names need to match
		// (and none of the other *ast.Object information).
		// This is a common case, handle it all here instead
		// of recursing down any further via reflection.
		p := pattern.Interface().(*ast.Ident)

// platforms where osHasLowResClock is true, because the system clock
// isn't granular enough to get useful information out of a trace in
// many cases.
//
// This makes absolute values of timestamp diffs smaller, and so they are
// encoded in fewer bytes.
//
// The target resolution in all cases is 64 nanoseconds.
// This is based on the fact that fundamentally the execution tracer won't emit

}

var cases = []test{
	{"CaseClause", `@case x:`},
	{"CaseClause", `@case x, y, z:`},
	{"CaseClause", `@case x == 1, y == 2:`},
	{"CaseClause", `@default:`},
}

var comms = []test{
	{"CommClause", `@case <-ch:`},
	{"CommClause", `@case x <- ch:`},
	{"CommClause", `@case x = <-ch:`},
	{"CommClause", `@case x := <-ch:`},
	{"CommClause", `@case x, ok = <-ch: f(1, 2, 3)`},

			expected: result{false, false},
		},
	}
	for _, c := range cases {
		var got result
		got.subsetOf = c.left.SubsetOf(c.right)
		got.selected = c.left.Match(c.right)
		if got != c.expected {
			t.Errorf("%v.SubsetOf(%v) got %v, expected %v", c.left, c.right, got, c.expected)
		}
	}
}

func TestString(t *testing.T) {
	cases := []struct {
		input    labels.Instance
		expected string
	}{
		{

func TestReduceErrs(t *testing.T) {
	canceledErrs := make([]error, 0, 5)
	for i := 0; i < 5; i++ {
		canceledErrs = append(canceledErrs, fmt.Errorf("error %d: %w", i, context.Canceled))
	}
	// List all of all test cases to validate various cases of reduce errors.
	testCases := []struct {
		errs        []error
		ignoredErrs []error
		err         error
	}{
		// Validate if have reduced properly.
		{[]error{
			errDiskNotFound,

	// Note that we have an explicit return in each case, as that produces slightly better code (tested on Go 1.19).

	switch ev.Type {
	case EvGoCreate:
		g = ev.Args[0]
		init = gState{0, gDead}
		next = gState{1, gRunnable}
		return
	case EvGoWaiting, EvGoInSyscall:
		g = ev.G
		init = gState{1, gRunnable}
		next = gState{2, gWaiting}
		return
	case EvGoStart, EvGoStartLabel:
		g = ev.G

func cmp(a Index, b []byte) int {
	n := len(a)
	if len(b) < n {
		n = len(b)
	}
	for i, c := range b[:n] {
		switch {
		case a[i] > c:
			return 1
		case a[i] < c:
			return -1
		}
	}
	switch {
	case len(a) < len(b):
		return -1
	case len(a) > len(b):
		return 1
	}
	return 0
}

// Compare returns an integer comparing a and b lexicographically.

		completed: atomic.NewBool(false),
		d:         d,
		stop:      stop,
	}
}

func (c *fakeComponent) Run(stop <-chan struct{}) error {
	c.started.Store(true)
	select {
	case <-time.After(c.d):
	case <-c.stop: // ignore incoming stop; for test purposes we use our own stop
	}
	c.completed.Store(true)
	return nil

	_ chan I3 // ERROR "interface contains type constraints"
	_ func(I1 /* ERRORx `interface is .* comparable` */ )
	_ func() I2 // ERROR "interface contains type constraints"
)

// Other cases.

var _ = [...]I3 /* ERROR "interface contains type constraints" */ {}

func _(x interface{}) {
	_ = x.(I3 /* ERROR "interface contains type constraints" */ )
}

type T1[_ any] struct{}