inGOOS = true
		} else if inGOOS && strings.HasPrefix(line, "}") {
			break
		} else if inGOOS {
			goos := strings.Fields(line)[0]
			goos = strings.TrimPrefix(goos, `"`)
			goos = strings.TrimSuffix(goos, `":`)
			gooses = append(gooses, goos)
		}
	}

	for _, target := range gooses {
		if target == "nacl" {
			continue
		}
		var tags []string
		if target == "linux" {

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

// package goos contains GOOS-specific constants.
package goos

// The next line makes 'go generate' write the zgoos*.go files with
// per-OS information, including constants named Is$GOOS for every
// known GOOS. The constant is 1 on the current system, 0 otherwise;
// multiplying by them is useful for defining GOOS-specific constants.
//

@SuppressSignatureCheck
sealed class CallEvent {
  abstract val timestampNs: Long
  abstract val call: Call

  val name: String
    get() = javaClass.simpleName

  /** Returns if the event closes this event, or null if this is no open event. */
  open fun closes(event: CallEvent): Boolean? = null

  data class ProxySelectStart(
    override val timestampNs: Long,
    override val call: Call,
    val url: HttpUrl,
  ) : CallEvent()

type Name string

type EFunc func(int) int

func Register(f EFunc, names ...Name) int {
	return f(len(names))
}

const (
	B Name = "B"
)

func RegisterIt() {
	n := B + "Duck"
	d := B + "Goose"
	f := func(x int) int { return x + 9 }
	Register(f, n, d)
}

func main() {
	RegisterIt()

@SuppressSignatureCheck
sealed class ConnectionEvent {
  abstract val timestampNs: Long
  open val connection: Connection?
    get() = null

  /** Returns if the event closes this event, or null if this is no open event. */
  open fun closes(event: ConnectionEvent): Boolean? = null

  val name: String
    get() = javaClass.simpleName

  data class ConnectStart(
    override val timestampNs: Long,
    val route: Route,

        @Override
        void close() throws IOException {
            closed = true
        }
    }

    def "closes input"() {
        given:
        def input = new TestInputStream()

        when:
        target.readFrom(input)

        then:
        input.closed
    }

    def "closes input on subsequent use"() {
        given:
        def input = new TestInputStream()

        when:

        return new TextFileWriterIoAction(output, encoding);
    }

    /**
     * Performs the given action against the given resource, then closes the resource. Ignores failure to close the resource when
     * the action throws an exception.
     */
    public static <T extends Closeable> void withResource(T resource, Action<? super T> action) {
        try {

@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class Closeables {
  @VisibleForTesting static final Logger logger = Logger.getLogger(Closeables.class.getName());

  private Closeables() {}

  /**
   * Closes a {@link Closeable}, with control over whether an {@code IOException} may be thrown.
   * This is primarily useful in a finally block, where a thrown exception needs to be logged but

func (file *file) readLock() error {
	if !file.fdmu.ReadLock() {
		return ErrClosed
	}
	return nil
}

// readUnlock removes a reference from the file and unlocks it for reading.
// It also closes the file if it marked as closed and there is no remaining
// reference.
func (file *file) readUnlock() {
	if file.fdmu.ReadUnlock() {
		file.destroy()
	}
}

func (r *PipeReader) Read(data []byte) (n int, err error) {
	return r.pipe.read(data)
}

// Close closes the reader; subsequent writes to the
// write half of the pipe will return the error [ErrClosedPipe].
func (r *PipeReader) Close() error {
	return r.CloseWithError(nil)
}

// CloseWithError closes the reader; subsequent writes
// to the write half of the pipe will return the error err.
//