_ = x /* ERROR "incomparable types in type set" */ == y
	_ = y /* ERROR "incomparable types in type set" */ == x
	_ = y /* ERROR "incomparable types in type set" */ == y

	_ = x /* ERROR "type parameter P is not comparable with <" */ < y
}

func _[P any](x P, y any) {
	_ = x /* ERROR "incomparable types in type set" */ == x
	_ = x /* ERROR "incomparable types in type set" */ == y
	_ = y == x // ERROR "incomparable types in type set"

	_ = b < b
	_ = a /* ERROR "type parameter A is not comparable with <" */ < a
	_ = l /* ERROR "type parameter L is not comparable with <" */ < l
	_ = s /* ERROR "type parameter S is not comparable with <" */ < s
	_ = p /* ERROR "type parameter P is not comparable with <" */ < p
	_ = f /* ERROR "type parameter F is not comparable with <" */ < f
	_ = i /* ERROR "type parameter I is not comparable with <" */ < i

            if (c2MoreSpecific) {
                // Incomparable due to cross-assignable arguments (i.e.
                // foo(String, Object) vs. foo(Object, String))
                return INCOMPARABLE;
            }

            return MORE_SPECIFIC;
        }

        if (c2MoreSpecific) {
            return LESS_SPECIFIC;
        }

        // Incomparable due to non-related arguments (i.e.

		return ErrInvalidHuffman
	}

	return nil
}

// incomparable is a zero-width, non-comparable type. Adding it to a struct
// makes that struct also non-comparable, and generally doesn't add
// any size (as long as it's first).
type incomparable [0]func()

type node struct {
	_ incomparable

	// children is non-nil for internal nodes
	children *[256]*node

	_ = x /* ERROR "empty type set" */ + x
	<-x /* ERROR "empty type set" */
	x <- /* ERROR "empty type set" */ 0
	close(x /* ERROR "empty type set" */)
}

func _[T interface{ int | []byte }](x T) {
	_ = x /* ERROR "incomparable types in type set" */ == x

// Issue 11737 - invalid == not being caught until generated switch code was compiled

package p

func f()

func s(x interface{}) {
	switch x {
	case f: // ERROR "invalid case f \(type func\(\)\) in switch \(incomparable type\)|can only be compared to nil"
	}

import (
	"io"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"golang.org/x/net/http/httpguts"
)

// incomparable is a zero-width, non-comparable type. Adding it to a struct
// makes that struct also non-comparable, and generally doesn't add
// any size (as long as it's first).
type incomparable [0]func()

// maxInt64 is the effective "infinite" value for the Server and
// Transport's byte-limiting readers.

	return AlgType(t) == ANOALG
}

// IsComparable reports whether t is a comparable type.
func IsComparable(t *Type) bool {
	a := AlgType(t)
	return a != ANOEQ && a != ANOALG
}

// IncomparableField returns an incomparable Field of struct Type t, if any.
func IncomparableField(t *Type) *Field {
	for _, f := range t.Fields() {
		if !IsComparable(f.Type) {
			return f
		}
	}
	return nil
}

type Point struct {
	// Make the type not comparable (i.e. used with == or as a map key), as
	// equivalent points can be represented by different Go values.
	_ incomparable

	// The point is internally represented in extended coordinates (X, Y, Z, T)
	// where x = X/Z, y = Y/Z, and xy = T/Z per https://eprint.iacr.org/2008/522.
	x, y, z, t field.Element
}

type incomparable [0]func()

func checkInitialized(points ...*Point) {

}

// Comparable reports whether values of type T are comparable.
func Comparable(T Type) bool {
	return comparable(T, true, nil, nil)
}

// If dynamic is set, non-type parameter interfaces are always comparable.
// If reportf != nil, it may be used to report why T is not comparable.