defer func() {
		mustNotRecover()
	}()
	panic(1)
}

func test2() {
	// Recover only sees the panic argument
	// if it is called from a deferred call.
	// It does not see the panic when called from a call within a deferred call (too late)
	// nor does it see the panic when it *is* the deferred call (too early).
	defer mustRecover(2)
	defer recover() // should be no-op
	panic(2)
}

func test3() {

// y == 0 (division by zero) but, unlike Div, it doesn't panic on a
// quotient overflow.
func Rem(hi, lo, y uint) uint {
	if UintSize == 32 {
		return uint(Rem32(uint32(hi), uint32(lo), uint32(y)))
	}
	return uint(Rem64(uint64(hi), uint64(lo), uint64(y)))
}

// Rem32 returns the remainder of (hi, lo) divided by y. Rem32 panics

	t.Fatalf("Unable to find sub command %s", name)

	return nil
}

// getKubeadmPath returns the contents of the environment variable KUBEADM_PATH
// or panics if it's empty
func getKubeadmPath() string {
	kubeadmPath := os.Getenv("KUBEADM_PATH")
	if len(kubeadmPath) == 0 {
		panic("the environment variable KUBEADM_PATH must point to the kubeadm binary path")
	}
	return kubeadmPath

	panicMessage string
}

func (a *panickingAuthenticationInfoResolver) ClientConfigFor(hostPort string) (*rest.Config, error) {
	panic(a.panicMessage)
}

func (a *panickingAuthenticationInfoResolver) ClientConfigForService(serviceName, serviceNamespace string, servicePort int) (*rest.Config, error) {
	panic(a.panicMessage)

func (m *validationMetrics) ObserveRatchetingTime(d time.Duration) {
	m.RatchetingTime.Observe(d.Seconds())
}

// Reset resets the metrics. This is meant to be used for testing. Panics
// if the metrics cannot be re-registered. Returns all the reset metrics
func (m *validationMetrics) Reset() []metrics.Registerable {
	m.RatchetingTime = metrics.NewHistogram(m.RatchetingTime.HistogramOpts)

	stdout := os.Stdout
	f := createTempFile(eg.Name)
	os.Stdout = f
	finished := false
	start := time.Now()

	// Clean up in a deferred call so we can recover if the example panics.
	defer func() {
		timeSpent := time.Since(start)

		// Restore stdout, get output and remove temporary file.
		os.Stdout = stdout
		var buf strings.Builder
		_, seekErr := f.Seek(0, io.SeekStart)

	d.state = spongeSqueezing
	d.n = d.rate
	copyOut(d, d.storage[:d.rate])
}

// Write absorbs more data into the hash's state. It panics if any
// output has already been read.
func (d *state) Write(p []byte) (written int, err error) {
	if d.state != spongeAbsorbing {
		panic("sha3: Write after Read")
	}
	written = len(p)

	for len(p) > 0 {
		if d.n == 0 && len(p) >= d.rate {

// slice.
//
// Swapper panics if the provided interface is not a slice.
func Swapper(slice any) func(i, j int) {
	v := ValueOf(slice)
	if v.Kind() != Slice {
		panic(&ValueError{Method: "Swapper", Kind: v.Kind()})
	}
	// Fast path for slices of size 0 and 1. Nothing to swap.
	switch v.Len() {
	case 0:
		return func(i, j int) { panic("reflect: slice index out of range") }
	case 1:

	}

	return &schemaImpl{
		variableName: b.VariableName,
		resource:     b.Resource,
	}, nil
}

// MustBuild calls Build and panics if it fails.
func (b Builder) MustBuild() Schema {
	s, err := b.Build()
	if err != nil {
		panic(fmt.Sprintf("MustBuild: %v", err))
	}

	return s
}

type schemaImpl struct {
	resource     resource.Schema
	name         config.GroupVersionKind

func Add(h Hook) {
	for !locked.CompareAndSwap(0, 1) {
		Gosched()
	}
	hooks = append(hooks, h)
	locked.Store(0)
}

// Run runs the exit hooks.
//
// If an exit hook panics, Run will throw with the panic on the stack.
// If an exit hook invokes exit in the same goroutine, the goroutine will throw.
// If an exit hook invokes exit in another goroutine, that exit will block.
func Run(code int) {