def heap = ManagementFactory.memoryMXBean.heapMemoryUsage
                                def nonHeap = ManagementFactory.memoryMXBean.nonHeapMemoryUsage
                                println "BEFORE GC"
                                println "heap: \${format(heap.used)} (initial \${format(heap.init)}, committed \${format(heap.committed)}, max \${format(heap.max)}"

func tUPiSPa() {
	s1 := "ant"
	s2 := "bat" // ERROR "moved to heap: s2$"
	s3 := "cat" // ERROR "moved to heap: s3$"
	s4 := "dog" // ERROR "moved to heap: s4$"
	s5 := "emu" // ERROR "moved to heap: s5$"
	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"

func tUPiSPa() {
	s1 := "ant"
	s2 := "bat" // ERROR "moved to heap: s2$"
	s3 := "cat" // ERROR "moved to heap: s3$"
	s4 := "dog" // ERROR "moved to heap: s4$"
	s5 := "emu" // ERROR "moved to heap: s5$"
	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"

}

// Unfortunate: x doesn't need to escape to heap, just to result.
func slice1(x []byte) []byte { // ERROR "leaking param: x$"
	v := reflect.ValueOf(x) // ERROR "x escapes to heap"
	return v.Slice(1, 2).Bytes()
}

// Unfortunate: x doesn't need to escape to heap, just to result.
func slice2(x string) string { // ERROR "leaking param: x$"
	v := reflect.ValueOf(x) // ERROR "x escapes to heap"
	return v.Slice(1, 2).String()
}

	*ppi = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$"
}

func foo75aesc1(z *int) { // ERROR "z does not escape$"
	sink = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$"
}

func foo76(z *int) { // ERROR "z does not escape"

var sink interface{}

func level0() {
	i := 0     // ERROR "moved to heap: i"
	p0 := &i   // ERROR "moved to heap: p0"
	p1 := &p0  // ERROR "moved to heap: p1"
	p2 := &p1  // ERROR "moved to heap: p2"
	sink = &p2
}

func level1() {
	i := 0    // ERROR "moved to heap: i"
	p0 := &i  // ERROR "moved to heap: p0"
	p1 := &p0 // ERROR "moved to heap: p1"
	p2 := &p1
	sink = p2
}

func level2() {

			}
			h.pop()
			if !verify(&h, 0) {
				t.Errorf("heap invariant violated: %v", h)
			}
		}
		for !h.empty() { // pop remaining elements
			h.pop()
			if !verify(&h, 0) {
				t.Errorf("heap invariant violated: %v", h)
			}
		}
	}
}

// recursively verify heap-ness, starting at element i.
func verify(h *heap, i int) bool {
	n := len(*h)
	c1 := 2*i + 1 // left child

	i := 0                   // ERROR "moved to heap: i"
	j := 0                   // ERROR "moved to heap: j"
	m[&i] = &j
	return m
}

func map3() []*int {
	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
	i := 0                   // ERROR "moved to heap: i"
	// BAD: j should not escape
	j := 0 // ERROR "moved to heap: j"
	m[&i] = &j
	var r []*int

	p := &i // ERROR "moved to heap: p$"
	p2 := &p
	param6(&p2)
}

// **in -> heap
func param7(i ***int) { // ERROR "leaking param content: i$"
	sink = **i
}

func caller7() {
	i := 0 // ERROR "moved to heap: i$"
	p := &i
	p2 := &p
	param7(&p2)
}

// **in -> heap
func param8(i **int) { // ERROR "i does not escape$"
	sink = **i // ERROR "\*\(\*i\) escapes to heap"
}

	x X
}

func field0() {
	i := 0 // ERROR "moved to heap: i$"
	var x X
	x.p1 = &i
	sink = x.p1
}

func field1() {
	i := 0 // ERROR "moved to heap: i$"
	var x X
	// BAD: &i should not escape
	x.p1 = &i
	sink = x.p2
}

func field3() {
	i := 0 // ERROR "moved to heap: i$"
	var x X
	x.p1 = &i
	sink = x // ERROR "x escapes to heap"
}

func field4() {
	i := 0 // ERROR "moved to heap: i$"