Cumulative count of heap allocations whose storage was freed
		by the garbage collector. Note that this does not include tiny
		objects as defined by /gc/heap/tiny/allocs:objects, only tiny
		blocks.

	/gc/heap/goal:bytes
		Heap size target for the end of the GC cycle.

	/gc/heap/live:bytes
		Heap memory occupied by live objects that were marked by the
		previous GC.

	/gc/heap/objects:objects

      Heap heap;
      if (crossOver == index) {
        heap = this;
      } else {
        index = crossOver;
        heap = otherHeap;
      }
      heap.bubbleUpAlternatingLevels(index, x);
    }

    /**
     * Bubbles a value from {@code index} up the levels of this heap, and returns the index the
     * element ended up at.
     */
    @CanIgnoreReturnValue

	// structure is meant to represent the Go heap. At worst, copying this
	// would take ~160µs assuming a conservative copying rate of 25 GiB/s (the
	// copy will almost never trigger a page fault) for a 1 TiB heap with 4 MiB
	// arenas which is completely discontiguous. ~160µs is still a lot, but in
	// practice most platforms have 64 MiB arenas (which cuts this by a factor
	// of 16) and Go heaps are usually mostly contiguous, so the chance that

}

var ptr unsafe.Pointer

func Storep() {
	var x int // ERROR "moved to heap: x"
	atomic.StorepNoWB(unsafe.Pointer(&ptr), unsafe.Pointer(&x))
}

func Casp1() {
	// BAD: should always be "does not escape"
	x := new(int) // ERROR "escapes to heap|does not escape"
	var y int     // ERROR "moved to heap: y"
	atomic.Casp1(&ptr, unsafe.Pointer(x), unsafe.Pointer(&y))

	// over the lifetime of the program.
	totalAllocated uint64

	// totalFreed is the total bytes of heap objects freed
	// over the lifetime of the program.
	totalFreed uint64

	// totalAllocs is the number of heap objects allocated over
	// the lifetime of the program.
	totalAllocs uint64

	// totalFrees is the number of heap objects freed over
	// the lifetime of the program.

    /**
     * The minimum heap size for the worker process.  When unspecified, no minimum heap size is set.
     *
     * Supports units like the command-line option {@code -Xms} such as {@code "1g"}.
     *
     * @return The minimum heap size.
     */
    @Optional
    @Input
    public abstract Property<String> getMinHeapSize();

    /**

	}
	b.build()
	return nil
}

// scaleHeapSample adjusts the data from a heap Sample to
// account for its probability of appearing in the collected
// data. heap profiles are a sampling of the memory allocations
// requests in a program. We estimate the unsampled value by dividing
// each collected sample by its probability of appearing in the
// profile. heap profiles rely on a poisson process to determine

                    println "Initial Heap: " + memBean.heapMemoryUsage.init
                    assert memBean.heapMemoryUsage.init == 256 * 1024 * 1024
                    println "    Max Heap: " + memBean.heapMemoryUsage.max

                    // Java 8 does not report max heap size exactly matching the command line setting
                    if ($java9orAbove) {

	traceAllocFreeInfoBatch         // Contains info for interpreting events. [min heap addr, page size, min heap align, min stack align]
)

// traceSnapshotMemory takes a snapshot of all runtime memory that there are events for
// (heap spans, heap objects, goroutine stacks, etc.) and writes out events for them.
//

	// (3) Group each event batch by M, sorted by timestamp. (batchCursor contains the groups.)
	// (4) Organize batchCursors in a min-heap, ordered by the timestamp of the next event for each M.
	// (5) Try to advance the next event for the M at the top of the min-heap.
	//   (a) On success, select that M.
	//   (b) On failure, sort the min-heap and try to advance other Ms. Select the first M that advances.
	//   (c) If there's nothing left to advance, goto (1).