// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func F[T any](c, d chan T) T {
	select {
	case x := <- c:
		return x
	case x := <- d:
		return x
	}

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func F() interface{} { return new(T[int]) }

type T[P any] int

func (x *T[P]) One() int { return x.Two() }

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func Unique[T comparable](set []T) []T {
	nset := make([]T, 0, 8)

loop:
	for _, s := range set {
		for _, e := range nset {
			if s == e {
				continue loop
			}
		}

		nset = append(nset, s)
	}

	return nset

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type T struct {
	X int `go:"track"`
	Y int `go:"track"`
	Z int // untracked
}

func (t *T) GetX() int {
	return t.X
}
func (t *T) GetY() int {
	return t.Y
}
func (t *T) GetZ() int {
	return t.Z

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type X struct {
	T [32]byte
}

func (x *X) Get() []byte {
	t := x.T
	return t[:]
}

func (x *X) RetPtr(i int) *int {
	i++
	return &i
}

func (x *X) RetRPtr(i int) (r1 int, r2 *int) {
	r1 = i + 1
	r2 = &r1
	return

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

import "sync"

type Loader[K comparable, R any] struct {
	batch *LoaderBatch[K, R]
}

func (l *Loader[K, R]) Load() error {
	l.batch.f()
	return nil
}

type LoaderBatch[K comparable, R any] struct {
	once    *sync.Once
}

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Mode uint

func (m Mode) String() string { return "mode string" }
func (m *Mode) Addr() *Mode   { return m }

type Stringer interface {
	String() string
}

var global Stringer
var m Mode

func init() {

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func F(i interface{}) int { // ERROR "can inline F" "i does not escape"
	switch i.(type) {
	case nil:
		return 0
	case int:
		return 1
	case float64:
		return 2
	default:
		return 3
	}
}

console.log('a');...

package org.gradle.test;

class A {