ok      bool
}{
	{"a", "a", true},
	{"a", "b", false},
	{"a/**", "a", true},
	{"a/**", "b", false},
	{"a/**", "a/b", true},
	{"a/**", "b/b", false},
	{"a/**", "a/b/c/d/e/f", true},
	{"a/**", "z/a/b/c/d/e/f", false},
	{"**/a", "a", true},
	{"**/a", "b", false},
	{"**/a", "x/a", true},
	{"**/a", "x/a/b", false},
	{"**/a", "x/y/z/a", true},
	{"**/a", "x/y/z/a/b", false},

package p

type Eq[T any] interface {
	Eqv(a T, b T) bool
}

type EqFunc[T any] func(a, b T) bool

func (r EqFunc[T]) Eqv(a, b T) bool {
	return r(a, b)
}

func New[T any](f func(a, b T) bool) Eq[T] {
	return EqFunc[T](f)
}

func Equal(a, b []byte) bool {
	return string(a) == string(b)
}

        '( ~ )'            | [token('~')]
        '(a, b, c)'        | ['a', 'b', 'c']
        '(1, 2, 3)'        | ['1', '2', '3']
        '(<a.h>, "b.h")'   | ['<a.h>', '"b.h"']
        '(a, (c, (d), e))' | ['a', expression('(c, (d), e)')]
        '(a##b)'           | [expression('a##b')]
        '( a ## b ## c )'  | [expression('a##b##c')]
        '(a b c)'          | [tokens('a b c')]
    }

lize:function(b){var c=b.split(" ");return a.each(c,function(a,b){c[a]=b.substr(0,1).toUpperCase()+b.substr(1,b.length)}),c.join(" ")},insert:function(a,b,c){var d=(b.attr("data-sanitize-insert-"+c)||"").replace(/\[SPACE\]/g," ");return"left"===c&&0===a.indexOf(d)||"right"===c&&a.substring(a.length-d.length)===d?a:("left"===c?d:"")+a+("right"===c?d:"")},insertRight:function(a,b){return this.insert(a,b,"right")},insertLeft:function(a,b){return this.insert(a,b,"left")},numberFormat:function(a,c){i...

func fEqPtrEqPtr(a, b *int, f float64) bool {
	return a == b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on EqPtr$"
}

func fEqPtrNeqPtr(a, b *int, f float64) bool {
	return a == b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on EqPtr$"
}

func fNeqPtrEqPtr(a, b *int, f float64) bool {

        path.url == 'file://$ROOT_DIR$/a/b'
        path.relPath == '$ROOT_DIR$/a/b'
    }

    def createsRelativePathForAnAncestorOfRootDir() {
        factory.addPathVariable('ROOT_DIR', tmpDir.testDirectory)

        expect:
        def path = factory.relativePath('ROOT_DIR', tmpDir.testDirectory.parentFile.parentFile.file('a/b'))
        path.url == 'file://$ROOT_DIR$/../../a/b'

        expect:
        set.collect { it } == ['a', 'b', 'c']
        set.iterator().collect { it } == ['a', 'b', 'c']
    }

    def canGetElementsAsAList() {
        ImmutableDomainObjectSet<String> set = new ImmutableDomainObjectSet<String>(['a', 'b', 'c'])

        expect:
        set.all == ['a', 'b', 'c']
    }

}

func f(a A) int {
	for i, x := range &a.b {
		if x != 0 {
			return 64*i + int(x)
		}
	}
	return 0
}

func g(a *A) int { // ERROR "a does not escape"
	for i, x := range &a.b {
		if x != 0 {
			return 64*i + int(x)
		}
	}
	return 0
}

func h(a *B) *uint64 { // ERROR "leaking param: a to result ~r0 level=1"
	for i, x := range &a.b {
		if i == 0 {
			return x
		}
	}
	return nil

	return a == b
}

func CompareArray3(a, b [3]int16) bool {
	// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
	// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
	return a == b
}

func CompareArray4(a, b [12]int8) bool {
	// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
	// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
	return a == b
}

fun foo(a: Int): Int {
    val b: Int = 1
    for (n in 1..a) {
        <expr>if (a + b > 0) break
        consume(a - b)
        if (a - b > 0) break
        consume(a + b)</expr>
    }
    return 1
}