var i int
	p := (*S)(unsafe.Pointer(uintptr(unsafe.Pointer(&i))))
	v := uintptr(unsafe.Pointer(p))
	// p is a pointer to a not-in-heap type. Like some C libraries,
	// we stored an integer in that pointer. That integer just happens
	// to be the address of i.
	// v is also the address of i.
	// p has a base type which is marked not-in-heap, so it
	// should not be adjusted when the stack is copied.
	recurse(100, p, v)
}

      jsonPath: .status.status
      name: Status
      type: string
    - description: 'CreationTimestamp is a timestamp representing the server time
        when this object was created. It is not guaranteed to be set in happens-before
        order across separate operations. Clients may not set this value. It is represented
        in RFC3339 form and is in UTC. Populated by the system. Read-only. Null for

	// it means we want the kernel to pick an appropriate originating local
	// address. Some Linux kernels cycle blindly through a fixed range of
	// local ports, regardless of destination port. If a kernel happens to
	// pick local port 50001 as the source for a Dial("tcp", "", "localhost:50001"),
	// then the Dial will succeed, having simultaneously connected to itself.

 *
 * <p>Resolution happens in multiple steps. The first step is to calculate the dependency graph, which involves selecting component instances and one or more variants of each instance.
 * This type exposes only the information and operations required to do this. In particular, it does not expose any information about artifacts unless this is actually required for graph resolution,

		// selectrecv before allocating the memory for t,
		// which caused non-deterministic crashes.
		// This test looks for the bug by checking that the
		// value received actually ends up in t.
		// If the allocation happens after storing through
		// whatever garbage &t holds, the later reference
		// to t in the case body will use the new pointer and
		// not see the received value.
		v += 0x1020304
		c <- v
		select {
		case t := <-c:

package bytealg

import "internal/cpu"

const MaxBruteForce = 64

func init() {
	// Note: we're kind of lucky that this flag is available at this point.
	// The runtime sets HasVX when processing auxv records, and that happens
	// to happen *before* running the init functions of packages that
	// the runtime depends on.
	// TODO: it would really be nicer for internal/cpu to figure out this

 */
public interface VisitedArtifactSet {
    /**
     * Creates a set that selects the artifacts from this set that match the given criteria.
     * Implementations are lazy, so that the selection happens only when the contents are queried.
     *
     * @param spec Parameters controlling the artifact selection process
     */
    SelectedArtifactSet select(ArtifactSelectionSpec spec);

//  2. The plugin adds that same itab again.  That makes a cycle in the itab
//     chain rooted at hash bucket 0x111.
//  3. The main binary then asks for the itab for *dynamodbstreamsevt.Event /
//     json.Unmarshaler.  This itab happens to also live in bucket 0x111.
//     The lookup code goes into an infinite loop searching for this itab.
//
// The code is carefully crafted so that the two itabs are both from the

@EventScope(Scope.Build.class)
@ServiceScope(Scope.Gradle.class)
public interface OutputChangeListener {
    /**
     * Invoked when some locations on disk have been changed or are about to be changed.
     * This happens for example just before and after the task actions are executed or the outputs are loaded from the cache.
     *
     * @param affectedOutputPaths The files which are affected by the change.
     */

 */
public interface ArtifactSet {
    /**
     * Selects the artifacts of this set that meet the given criteria. Implementation should be eager where possible, so that selection happens immediately, but may be lazy.
     */
    ResolvedArtifactSet select(ArtifactVariantSelector variantSelector, ArtifactSelectionSpec spec);