defer func() {
		defer recover()	// like a normal call from this func; runs because mustRecover stops the panic
		defer mustRecover(3)
		panic(3)
	}()
	panic(2)
}

func test7() {
	// Like test6, but swapped defer order.
	// The recover in "defer recover()" is now a no-op,
	// because it runs called from panic, not from the func,
	// and therefore cannot see the panic of 2.
	// (Alternately, it cannot see the panic of 2 because

	"istio.io/istio/pkg/kube/controllers"
	"istio.io/istio/pkg/kube/kubetypes"
	"istio.io/istio/pkg/ptr"
)

// delayedClient is a client wrapper that initially starts with an "empty client",
// but can later be swapped with a real client.
// The "empty client" returns empty responses for all reads, and fails all writes.
type delayedClient[T controllers.ComparableObject] struct {
	inf *atomic.Pointer[Informer[T]]

)

REM min and max heap sizes should be set to the same value to avoid
REM stop-the-world GC pauses during resize, and so that we can lock the
REM heap in memory on startup to prevent any of it from being swapped
REM out.
set FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -Xms%FESS_MIN_MEM% -Xmx%FESS_MAX_MEM%
set FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:MaxMetaspaceSize=256m -XX:CompressedClassSpaceSize=32m

REM new generation

	return s.Min.X <= r.Min.X && r.Max.X <= s.Max.X &&
		s.Min.Y <= r.Min.Y && r.Max.Y <= s.Max.Y
}

// Canon returns the canonical version of r. The returned rectangle has minimum
// and maximum coordinates swapped if necessary so that it is well-formed.
func (r Rectangle) Canon() Rectangle {
	if r.Max.X < r.Min.X {
		r.Min.X, r.Max.X = r.Max.X, r.Min.X
	}
	if r.Max.Y < r.Min.Y {
		r.Min.Y, r.Max.Y = r.Max.Y, r.Min.Y
	}

# min and max heap sizes should be set to the same value to avoid
# stop-the-world GC pauses during resize, and so that we can lock the
# heap in memory on startup to prevent any of it from being swapped
# out.
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Xms${FESS_MIN_MEM}"
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Xmx${FESS_MAX_MEM}"
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -XX:MaxMetaspaceSize=256m -XX:CompressedClassSpaceSize=32m"

	var fn func(ctxt *Link, sect *sym.Section, syms []loader.Sym)
	var wg sync.WaitGroup
	var sem chan int
	if ctxt.Out.isMmapped() {
		// Write sections in parallel.
		sem = make(chan int, 2*runtime.GOMAXPROCS(0))
		fn = func(ctxt *Link, sect *sym.Section, syms []loader.Sym) {
			wg.Add(1)
			sem <- 1

//
// All calls to CompareAndSwap for a given Value must use values of the same
// concrete type. CompareAndSwap of an inconsistent type panics, as does
// CompareAndSwap(old, nil).
func (v *Value) CompareAndSwap(old, new any) (swapped bool) {
	if new == nil {
		panic("sync/atomic: compare and swap of nil value into Value")
	}
	vp := (*efaceWords)(unsafe.Pointer(v))
	np := (*efaceWords)(unsafe.Pointer(&new))

			actualSize: -1,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",
			err:        ioutil.ErrOverread,
		},
		7: {
			desc:       "Correct sha256, nested, truncated, swapped",
			src:        mustReader(t, bytes.NewReader([]byte("abcd-more-stuff-to-be ignored")), 4, "", "", -1),
			size:       4,
			actualSize: -1,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",

	// dynamicTransformers updates the transformers when encryption config file changes.
	dynamicTransformers *encryptionconfig.DynamicTransformers

	// identity of the api server
	apiServerID string

	// can be swapped during testing
	getEncryptionConfigHash func(ctx context.Context, filepath string) (string, error)

	}

	x.before = _magic
	x.after = _magic
	for j := 0; j < 32; j += 1 {
		x.i = (1 << j) + 0
		x.o = (1 << j) + 0
		x.n = (1 << j) + 1
		if !atomic.CasRel(&x.i, x.o, x.n) {
			t.Fatalf("should have swapped %#x %#x", x.o, x.n)
		}

		if x.i != x.n {
			t.Fatalf("wrong x.i after swap: x.i=%#x x.n=%#x", x.i, x.n)
		}

		if x.before != _magic || x.after != _magic {