var ready, ready2 uint32
	go func() {
		for {
			atomic.StoreUint32(&ready, 1)
			dummy()
			dummy()
		}
	}()
	// Also start one with a frameless function.
	// This is an especially interesting case for
	// LR machines.
	go func() {
		atomic.AddUint32(&ready2, 1)
		frameless()
	}()
	// Also test empty infinite loop.
	go func() {
		atomic.AddUint32(&ready2, 1)
		for {
		}
	}()

// Copyright 2011 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.

// Test that buffered channels are garbage collected properly.
// An interesting case because they have finalizers and used to
// have self loops that kept them from being collected.
// (Cyclic data with finalizers is never finalized, nor collected.)

package main

import (
	"fmt"
	"os"

import org.gradle.tooling.BuildController;
import org.gradle.tooling.GradleConnectionException;

import java.util.List;

public class CustomAction implements BuildAction<Object> {
    // Some interesting type references
    byte[][][] buffers;
    BuildController[][] controllers;
    List<String> values;

    public Object execute(BuildController controller) throws GradleConnectionException {

package org.gradle.tooling.internal.protocol;

import org.gradle.tooling.internal.gradle.GradleProjectIdentity;

/**
 * A marker interface for launchables.
 *
 * The real implementation exists elsewhere and is only interesting for provider.
 * Consumer will see public part of the contract from *.model.* packages and will send it back
 * to provider as it is when a build is launched.
 *
 * @since 1.12
 */

     */
    @Nullable
    String getDescription();

    /**
     * Returns whether launchable is public or not. A public launchable is one that is considered a public 'entry point' to the build, that is interesting for
     * an end user of the build to run.
     *
     * @return Public property.
     * @since 2.1
     */
    boolean isPublic();

namespace tfrt {
namespace fallback_async {

bool IsArgConsumedByFallback(mlir::func::FuncOp func, int arg_index) {
  auto arg = func.getArgument(arg_index);

  // Return true if any user is a fallback op. It is more interesting to know
  // whether it is consumed by any fallback op than whether it is only consumed
  // by fallback ops. For example, the conversion from a DenseHostTensor to a

            buildscript { dependencies { classpath(files('${someLib.toURI()}')) } }
        """

        // Load the StaticData class in the different sub-sub-projects
        // for a more interesting ClassLoader hierarchy.
        for (projectDir in ['foo/foo', 'bar/bar']) {
            file("$projectDir/build.gradle") << """
                buildscript { dependencies { classpath(files('${staticDataLib.toURI()}')) } }

// See the [net/http/pprof] package for more details about all of the
// debug endpoints installed by this import.
//
// # User annotation
//
// Package trace provides user annotation APIs that can be used to
// log interesting events during execution.
//
// There are three types of user annotations: log messages, regions,
// and tasks.
//
// [Log] emits a timestamped message to the execution trace along with

 *
 *     //if you want to append some extra natures in a declarative fashion:
 *     natures 'some.extra.eclipse.nature', 'some.another.interesting.nature'
 *     //if you want to assign natures in a groovy fashion:
 *     natures = ['some.extra.eclipse.nature', 'some.another.interesting.nature']
 *
 *     //if you want to append some extra build command:
 *     buildCommand 'buildThisLovelyProject'

        }
    }

    @Override
    public void artifactDescriptorInvalid(RepositoryEvent event) {
        // The exception stack trace is not really interesting here
        logger.warn(
                "The POM for {} is invalid, transitive dependencies (if any) will not be available: {}",
                event.getArtifact(),
                event.getException().getMessage());