// Exit without unwinding stack barriers.
			runtime.Goexit()
		}()

		// Generate some garbage.
		x[i] = make([]byte, 1024*1024)

		// Give GC some time to install stack barriers in the G.
		time.Sleep(50 * time.Microsecond)
		atomic.StoreInt32(&done, 1)
		for atomic.LoadInt32(&done) == 1 {
			runtime.Gosched()
		}
	}

	if atomic.LoadUint32(&l.done) == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		return l.doSlow()
	}
	return l.res, l.err
}

func (l *lazyImpl[T]) doSlow() (T, error) {
	l.m.Lock()
	defer l.m.Unlock()
	if l.done == 0 {
		done := uint32(1)
		// Defer in case of panic
		defer func() {
			atomic.StoreUint32(&l.done, done)
		}()
		res, err := l.getter()

}

func F(args []reflect.Value) (results []reflect.Value) {
	return nil
}

func main() {
	done := make(chan bool)
	go func() {
		// Test reflect.makeFuncStub.
		t := reflect.TypeOf((func())(nil))
		f := reflect.MakeFunc(t, F).Interface().(func())
		defer f()
		growstack(10000)
		done <- true
	}()
	<-done
	go func() {
		// Test reflect.methodValueCall.
		f := reflect.ValueOf(T{}).Method(0).Interface().(func())

	wg.Add(1)
	go func() {
		defer wg.Done()
		informer.Run(testContext.Done())
	}()

	// Start controller
	wg.Add(1)
	go func() {
		defer wg.Done()
		stopReason := myController.Run(testContext)
		require.ErrorIs(t, stopReason, context.Canceled)
	}()

	// Wait for controller and informer to start up
	require.True(t, cache.WaitForCacheSync(testContext.Done(), myController.HasSynced))

			c.L.Lock()
		}
		c.L.Unlock()
		done <- true
	}()
	go func() {
		c.L.Lock()
		for {
			if x == 2 {
				c.Wait()
				if x != 3 {
					t.Error("want 3")
				}
				break
			}
			if x == 3 {
				break
			}
			c.L.Unlock()
			runtime.Gosched()
			c.L.Lock()
		}
		c.L.Unlock()
		done <- true
	}()
	<-done
	<-done
	<-done
}

			Key:    "failure-domain.beta.kubernetes.io/zone",
			Values: []string{"zone1", "zone2"},
		}},
	}, {
		MatchLabelExpressions: []api.TopologySelectorLabelRequirement{{
			Key:    "failure-domain.beta.kubernetes.io/zone",
			Values: []string{"zone2", "zone1"},
		}},
	}}

	cases := map[string]bindingTest{
		"no topology": {
			class:         makeClass(&waitingMode, nil),

func Ranger[T any]() (*Sender[T], *Receiver[T]) {
	c := make(chan T)
	d := make(chan bool)
	s := &Sender[T]{values: c, done: d}
	r := &Receiver[T]{values: c, done: d}
	runtime.SetFinalizer(r, r.finalize)
	return s, r
}

// A sender is used to send values to a Receiver.
type Sender[T any] struct {
	values chan<- T
	done <-chan bool
}

// Send sends a value to the receiver. It returns whether any more

        hubs=()
        images=()
        tags=()

        for hub in ${HUB}; do
          hubs+=( "$hub" );
        done

        for img in ${IMAGE}; do
          images+=( "$img" );
        done

        for tag in ${TAG}; do
          tags+=( "$tag" );
        done

        for i in "${!hubs[@]}"; do
          if [ -z "${images[$i]}" ]
          then

9223372036854775807 false
done
9223372036854775806 false
9223372036854775807 false
done
9223372036854775805 false
9223372036854775807 false
done

	d := make(chan struct{})
	s := &Sender[Elem]{
		values: c,
		done:   d,
	}
	r := &Receiver[Elem]{
		values: c,
		done:   d,
	}
	runtime.SetFinalizer(r, (*Receiver[Elem]).finalize)
	return s, r
}

// A Sender is used to send values to a Receiver.
type Sender[Elem any] struct {
	values chan<- Elem
	done   <-chan struct{}
}