_ = b == b
	_ = a /* ERROR "[10]func() cannot be compared" */ == a
	_ = l /* ERROR "slice can only be compared to nil" */ == l
	_ = s /* ERROR "struct containing []byte cannot be compared" */ == s
	_ = p == p
	_ = f /* ERROR "func can only be compared to nil" */ == f
	_ = i == i
	_ = m /* ERROR "map can only be compared to nil" */ == m
	_ = c == c

	_ = b == nil /* ERROR "mismatched types" */

sealed class ResidualProgram {

    /**
     * A static residue, can be compiled ahead of time.
     */
    data class Static(val instructions: List<Instruction>) : ResidualProgram() {

        constructor(vararg instructions: Instruction) :
            this(instructions.toList())
    }

    /**
     * A dynamic script [source] residue, can only be compiled after the execution of the static [prelude] at runtime.
     */

	things []string
}

type thing2 struct {
	things []thing1
}

func _() {
	var a1, b1 thing1
	_ = a1 /* ERROR "struct containing []string cannot be compared" */ == b1

	var a2, b2 thing2
	_ = a2 /* ERROR "struct containing []thing1 cannot be compared" */ == b2

func (this incr) Apply(x int) int {
	return x + this.n
}

type pos struct{}

func (this pos) Apply(x int) bool {
	return x > 0
}

type compose[a, b, c any] struct {
	f Function[a, b]
	g Function[b, c]
}

func (this compose[a, b, c]) Apply(x a) c {
	return this.g.Apply(this.f.Apply(x))
}

type _Eq[a any] interface {
	Equal(a) bool
}

type Int int

# To run locally an OpenLDAP instance using Docker
# $ docker-compose -f ldap.yaml up -d
version: '3.7'

services:
  openldap:
    image: quay.io/minio/openldap
    ports:
      - "389:389"
      - "636:636"
    environment:
      LDAP_ORGANIZATION: "MinIO Inc"
      LDAP_DOMAIN: "min.io"

// Name of attribute used to tag operators for compilation with XLA

// Implies must-compile semantics: either it will be compiled
// with XLA, or an error will be thrown.
extern const char* const kXlaMustCompileAttr;  // "_XlaMustCompile"

// Implies auto-clustering: tagged nodes will be clustered and compiled with XLA
// on a best-effort basis.
extern const char* const kXlaCompileAttr;  // "_XlaCompile"

# This is important for reproducing native builds with cross-compiled builds.
go build -o x.a text/template
! grep 'GOROOT\\' x.a
! grep 'text\\template' x.a
! grep 'c:\\' x.a

# executables should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o hello.exe hello.go
! grep 'GOROOT\\' hello.exe
! grep '\\runtime' hello.exe

// hook.
type WroteRequestInfo struct {
	// Err is any error encountered while writing the Request.
	Err error
}

// compose modifies t such that it respects the previously-registered hooks in old,
// subject to the composition policy requested in t.Compose.
func (t *ClientTrace) compose(old *ClientTrace) {
	if old == nil {
		return
	}
	tv := reflect.ValueOf(t).Elem()
	ov := reflect.ValueOf(old).Elem()

     * The function that compute the value for this compound access. For example, if the access is `+=`, this is the resolved `plus`
     * function. If the access is `++`, this is the resolved `inc` function.
     */
    public val operationPartiallyAppliedSymbol: KaPartiallyAppliedFunctionSymbol<KaFunctionSymbol> get() = withValidityAssertion { backingOperationPartiallyAppliedSymbol }

    /**

            while (true) {
                K previousProperty = previousEntry.getKey();
                K currentProperty = currentEntry.getKey();
                int compared = comparator.compare(previousProperty, currentProperty);
                if (compared < 0) {
                    if (!diffListener.removed(previousProperty)) {
                        return false;
                    }