println "nonHeap: \${format(nonHeap.used)} (initial \${format(nonHeap.init)}, committed \${format(nonHeap.committed)}, max \${format(nonHeap.max)}"
                                buildDir.mkdirs()
                                new File(buildDir, "totalMemoryUsed.txt").text = heap.used
                                new File(buildDir, "buildEventTimestamps.txt").text = "0\\n"*3

                            </source>

package heap_test

import (
	"container/heap"
	"fmt"
)

// An IntHeap is a min-heap of ints.
type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x any) {
	// Push and Pop use pointer receivers because they modify the slice's length,

    List<Option> options = []
    File processJsonFile

    OptionsVerifier(File processJsonFile) {
        this.processJsonFile = processJsonFile
    }

    void minHeap(String value) {
        options.add(new MinHeap(value))
    }

    void maxHeap(String value) {
        options.add(new MaxHeap(value))
    }

    void jvmArgs(String value) {
        options.add(new JvmArg(value))
    }

        return clientsManager.reserveIdleClient(forkOptions)
    }

    private JavaForkOptions javaForkOptions(String minHeap, String maxHeap, List<String> jvmArgs) {
        def options = TestFiles.execFactory().newJavaForkOptions()
        options.workingDir = systemSpecificAbsolutePath("foo")
        options.minHeapSize = minHeap
        options.maxHeapSize = maxHeap
        options.jvmArgs = jvmArgs
        return options
    }

func SecurityDescriptorFromString(sddl string) (sd *SECURITY_DESCRIPTOR, err error) {
	var winHeapSD *SECURITY_DESCRIPTOR
	err = convertStringSecurityDescriptorToSecurityDescriptor(sddl, 1, &winHeapSD, nil)
	if err != nil {
		return
	}
	defer LocalFree(Handle(unsafe.Pointer(winHeapSD)))
	return winHeapSD.copySelfRelativeSecurityDescriptor(), nil
}

	unsafe.Offsetof(heapStatsDelta{}.largeFree),
	unsafe.Offsetof(heapStatsDelta{}.largeFreeCount),
	unsafe.Offsetof(heapStatsDelta{}.committed),
	unsafe.Offsetof(heapStatsDelta{}.released),
	unsafe.Offsetof(heapStatsDelta{}.inHeap),
	unsafe.Offsetof(heapStatsDelta{}.inStacks),
	unsafe.Offsetof(heapStatsDelta{}.inPtrScalarBits),
	unsafe.Offsetof(heapStatsDelta{}.inWorkBufs),
	unsafe.Offsetof(lfnode{}.next),
	unsafe.Offsetof(mstats{}.last_gc_nanotime),

// and is called not-in-heap.
//
// Other types can embed NotInHeap to make it not-in-heap. Specifically, pointers
// to these types must always fail the `runtime.inheap` check. The type may be used
// for global variables, or for objects in unmanaged memory (e.g., allocated with
// `sysAlloc`, `persistentalloc`, r`fixalloc`, or from a manually-managed span).
//
// Specifically:
//

    }
  }

  private final Heap minHeap;
  private final Heap maxHeap;
  @VisibleForTesting final int maximumSize;
  private @Nullable Object[] queue;
  private int size;
  private int modCount;

  private MinMaxPriorityQueue(Builder<? super E> builder, int queueSize) {
    Ordering<E> ordering = builder.ordering();
    this.minHeap = new Heap(ordering);
    this.maxHeap = new Heap(ordering.reverse());

    }
  }

  private final Heap minHeap;
  private final Heap maxHeap;
  @VisibleForTesting final int maximumSize;
  private @Nullable Object[] queue;
  private int size;
  private int modCount;

  private MinMaxPriorityQueue(Builder<? super E> builder, int queueSize) {
    Ordering<E> ordering = builder.ordering();
    this.minHeap = new Heap(ordering);
    this.maxHeap = new Heap(ordering.reverse());

					goto keep
				} else {
					// Replace it with this window.
					heap.Remove(&acc.wHeap, i)
					break
				}
			}
		}

		heap.Push(&acc.wHeap, UtilWindow{time, mu})
		if len(acc.wHeap) > acc.nWorst {
			heap.Pop(&acc.wHeap)
		}
	keep:
	}

	if len(acc.wHeap) < acc.nWorst {
		// We don't have N windows yet, so keep accumulating.
		acc.bound = 1.0
	} else {