{
		var i interface{} = new(T1)
		_, ok1 := i.(*T1)
		_, ok2 := i.(*T2)
		_, ok3 := i.(*T3)
		if !ok1 || ok2 || ok3 {
			println("*T1", ok1, ok2, ok3)
			panic("fail")
		}
	}
	{
		var i interface{} = MyInt(0)
		_, ok1 := i.(interface {
			m(*T1)
		})
		_, ok2 := i.(interface {
			m(*T2)
		})
		_, ok3 := i.(interface {
			m(*T3)
		})
		if !ok1 || ok2 || ok3 {
			println("T", ok1, ok2, ok3)

func CompareKubeAwareVersionStrings(v1, v2 string) int {
	if v1 == v2 {
		return 0
	}
	v1major, v1type, v1minor, ok1 := parseKubeVersion(v1)
	v2major, v2type, v2minor, ok2 := parseKubeVersion(v2)
	switch {
	case !ok1 && !ok2:
		return strings.Compare(v2, v1)
	case !ok1 && ok2:
		return -1
	case ok1 && !ok2:
		return 1
	}
	if v1type != v2type {
		return int(v1type) - int(v2type)
	}
	if v1major != v2major {

// license that can be found in the LICENSE file.

package main

import "./a"

func F() any {
	return struct{ int }{0}
}

func main() {
	_, ok1 := F().(struct{ int })
	_, ok2 := a.F().(struct{ int })
	if !ok1 || ok2 {
		panic(0)
	}

			continue
		}
		portnet := f[1] // "80/tcp"
		port, j, ok := dtoi(portnet)
		if !ok || port <= 0 || j >= len(portnet) || portnet[j] != '/' {
			continue
		}
		netw := portnet[j+1:] // "tcp"
		m, ok1 := services[netw]
		if !ok1 {
			m = make(map[string]int)
			services[netw] = m
		}
		for i := 0; i < len(f); i++ {
			if i != 1 { // f[1] was port/net
				m[f[i]] = port
			}
		}
	}
}

var a5 = []byte{x: 2}                           // ERROR "index"
var a6 = []byte{1: 1, 2: 2, 1: 3}               // ERROR "duplicate"

var ok1 = S{}       // should be ok
var ok2 = T{S: ok1} // should be ok

// These keys can be computed at compile time but they are
// not constants as defined by the spec, so they do not trigger
// compile-time errors about duplicate key values.

//go:noinline
func (v *Vertex) IsClosedStruct() bool {
	return true
}

func equalVertex(x *Vertex, v Value, flags Flag) bool {
	y, ok := v.(*Vertex)
	if !ok {
		return false
	}
	v, ok1 := x.BaseValue.(Value)
	w, ok2 := y.BaseValue.(Value)
	if !ok1 && !ok2 {
		return true // both are struct or list.
	}
	return equalTerminal(v, w, flags)
}

//go:noinline
func equalTerminal(x Value, y Value, flags Flag) bool {

        return !(version in ['4.10', '4.11', '4.12'])
    }

    def 'reports unloadable #type'() {
        given:
        testSources.with {
            testClass('SomeTestClass').with {
                testMethod('ok1')
                testMethod('ok2')
            }
        }
        testSourceGenerator.writeAllSources(testSources)
        buildFile << """
            apply plugin: "java"

            ${mavenCentralRepository()}

	RET

TEXT	·RawSyscall(SB),NOSPLIT,$0-56
	MOVQ	a1+8(FP), DI
	MOVQ	a2+16(FP), SI
	MOVQ	a3+24(FP), DX
	MOVQ	trap+0(FP), AX	// syscall entry
	SYSCALL
	JCC	ok1
	MOVQ	$-1, r1+32(FP)	// r1
	MOVQ	$0, r2+40(FP)	// r2
	MOVQ	AX, err+48(FP)	// errno
	RET
ok1:
	MOVQ	AX, r1+32(FP)	// r1
	MOVQ	DX, r2+40(FP)	// r2
	MOVQ	$0, err+48(FP)	// errno
	RET

TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
	MOVQ	a1+8(FP), DI

		sort.Slice(oldKeys, func(i, j int) bool {
			key1, ok1 := oldKeys[i].(map[string]any)
			key2, ok2 := oldKeys[j].(map[string]any)
			if ok1 && ok2 {
				key1Id, kid1Exists := key1["kid"]
				key2Id, kid2Exists := key2["kid"]
				if kid1Exists && kid2Exists {
					key1IdStr, ok1 := key1Id.(string)
					key2IdStr, ok2 := key2Id.(string)
					if ok1 && ok2 {
						return key1IdStr < key2IdStr
					}
				}

		// 0 are detected
		tmp.SetInt64(1234567890)
		n1, ok1 := new(Int).SetString(test.in, test.base)
		n2, ok2 := tmp.SetString(test.in, test.base)
		expected := NewInt(test.val)
		if ok1 != test.ok || ok2 != test.ok {
			t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok)
			continue
		}
		if !ok1 {
			if n1 != nil {
				t.Errorf("#%d (input '%s') n1 != nil", i, test.in)
			}