return mv.MapKeys()
}

func mapiter1(m map[string]string) *reflect.MapIter { // ERROR "leaking param: m$"
	mv := reflect.ValueOf(m)
	return mv.MapRange()
}

func mapiter2(m map[string]string) string { // ERROR "leaking param: m$"
	mv := reflect.ValueOf(m)
	it := mv.MapRange()
	if it.Next() {
		return it.Key().String()
	}
	return ""
}

        def mapper1 = Mock(BuildOperationMapper)
        def mapper2 = Mock(BuildOperationMapper)
        def mappedProgressEvent = Mock(InternalProgressEvent)

        given:
        mapper1.isEnabled(subscriptions) >> true
        mapper1.trackers >> []
        mapper1.detailsType >> Long.class
        mapper2.isEnabled(subscriptions) >> true
        mapper2.trackers >> []
        mapper2.detailsType >> String.class

	elem = elem.assignTo("reflect.MapIter.SetValue", v.typ(), target)
	typedmemmove(v.typ(), v.ptr, elem.ptr)
}

// Next advances the map iterator and reports whether there is another
// entry. It returns false when iter is exhausted; subsequent
// calls to [MapIter.Key], [MapIter.Value], or [MapIter.Next] will panic.
func (iter *MapIter) Next() bool {
	if !iter.m.IsValid() {

pkg os, method (*ProcessState) ExitCode() int
pkg os/exec, method (ExitError) ExitCode() int
pkg reflect, method (*MapIter) Key() Value
pkg reflect, method (*MapIter) Next() bool
pkg reflect, method (*MapIter) Value() Value
pkg reflect, method (Value) MapRange() *MapIter
pkg reflect, type MapIter struct
pkg runtime/debug, func ReadBuildInfo() (*BuildInfo, bool)
pkg runtime/debug, type BuildInfo struct

pkg reflect, method (*MapIter) Reset(Value)
pkg reflect, method (Value) CanComplex() bool
pkg reflect, method (Value) CanFloat() bool
pkg reflect, method (Value) CanInt() bool
pkg reflect, method (Value) CanUint() bool
pkg reflect, method (Value) FieldByIndexErr([]int) (Value, error)
pkg reflect, method (Value) SetIterKey(*MapIter)
pkg reflect, method (Value) SetIterValue(*MapIter)

    waiter1.start();
    waiter1.awaitWaiting();

    WaiterThread waiter2 = new WaiterThread(future);
    waiter2.start();
    waiter2.awaitWaiting();
    // The waiter queue should be waiter2->waiter1

    // This should wake up waiter1 and cause the waiter1 node to be removed.
    waiter1.interrupt();

    waiter1.join();
    waiter2.awaitWaiting(); // should still be blocked

    waiter1.start();
    waiter1.awaitWaiting();

    WaiterThread waiter2 = new WaiterThread(future);
    waiter2.start();
    waiter2.awaitWaiting();
    // The waiter queue should be waiter2->waiter1

    // This should wake up waiter1 and cause the waiter1 node to be removed.
    waiter1.interrupt();

    waiter1.join();
    waiter2.awaitWaiting(); // should still be blocked

         ++member_iter) {
      ResourceAndDevice resource_and_device = *member_iter;
      auto map_iter = chain_resource_to_ops_map.find(resource_and_device);
      if (map_iter == chain_resource_to_ops_map.end()) continue;
      OperationSetTy& resource_ops = map_iter->getSecond();

      // Add dependencies between all ops that access current resource and chain
      // source and sink.

		}
		if setkey, key := valueToString(k), valueToString(iter.Key()); setkey != key {
			t.Errorf("MapIter.Key() = %q, MapIter.SetKey() = %q", key, setkey)
		}
		if setval, val := valueToString(e), valueToString(iter.Value()); setval != val {
			t.Errorf("MapIter.Value() = %q, MapIter.SetValue() = %q", val, setval)
		}
	}

	if testenv.OptimizationOff() {
		return // no inlining with the noopt builder

	// structure, not the stack. Check if this is the case and if so,
	// remove.

	// Remove up to two frames.
	maxiter := 2
	// Allow one different sample for this many samples with the same
	// second-to-last frame.
	similarSamples := 32
	margin := len(p.Sample) / similarSamples

	for iter := 0; iter < maxiter; iter++ {
		addr1 := make(map[uint64]int)
		for _, s := range p.Sample {
			if len(s.Location) > 1 {