p.f = 0
}

var _ = f4[*Sfm]

type A int
type B int
type C float64

type Int interface {
	*Sf | A
	*Sf | B
}

func f5[P Int](p P) {
	_ = p.f
	p.f = 0
}

var _ = f5[*Sf]

type Int2 interface {
	*Sf | A
	any
	*Sf | C
}

func f6[P Int2](p P) {
	_ = p.f
	p.f = 0
}

var _ = f6[*Sf]

type Int3 interface {
	Sf
	~struct{ f int }
}

	intCertFile         = "../testdata/multilevelpki/int-cert.pem"
	intKeyFile          = "../testdata/multilevelpki/int-key.pem"
	intCertChainFile    = "../testdata/multilevelpki/int-cert-chain.pem"
	int2CertFile        = "../testdata/multilevelpki/int2-cert.pem"
	int2KeyFile         = "../testdata/multilevelpki/int2-key.pem"
	int2CertChainFile   = "../testdata/multilevelpki/int2-cert-chain.pem"

func TestCreatePluggedCertCA(t *testing.T) {
	rootCertFile := "../testdata/multilevelpki/root-cert.pem"
	certChainFile := []string{"../testdata/multilevelpki/int2-cert-chain.pem"}
	signingCertFile := "../testdata/multilevelpki/int2-cert.pem"
	signingKeyFile := "../testdata/multilevelpki/int2-key.pem"
	rsaKeySize := 2048

	defaultWorkloadCertTTL := 99999 * time.Hour
	maxWorkloadCertTTL := time.Hour

    /*
     * This trick allows us to avoid having separate states for "first four ints" and "all other
     * four int chunks."  The state we want after the first four bytes is
     *
     * crc0 = ~int0
     * crc1 = int1
     * crc2 = int2
     * crc3 = int3
     *
     * ...so we set crc0 so that computeForWord(crc0) = -1 and xoring it with the first int

    /*
     * This trick allows us to avoid having separate states for "first four ints" and "all other
     * four int chunks."  The state we want after the first four bytes is
     *
     * crc0 = ~int0
     * crc1 = int1
     * crc2 = int2
     * crc3 = int3
     *
     * ...so we set crc0 so that computeForWord(crc0) = -1 and xoring it with the first int

func (T4) m() int { _ = x4; return 0 }
var x4 /* ERROR "initialization cycle" */ = T4.m(0)

type T3p int
func (*T3p) m() int { _ = x3p; return 0 }
var x3p /* ERROR "initialization cycle" */ = (*T3p).m

type T4p int
func (*T4p) m() int { _ = x4p; return 0 }
var x4p /* ERROR "initialization cycle" */ = (*T4p).m(nil)

// cycles through method expressions of embedded methods

type T5 struct { E5 }
type E5 int

   * Returns the values from each provided array combined into a single array. For example, {@code
   * concat(new int[] {a, b}, new int[] {}, new int[] {c}} returns the array {@code {a, b, c}}.
   *
   * @param arrays zero or more {@code int} arrays
   * @return a single array containing all the values from the source arrays, in order
   */
  public static int[] concat(int[]... arrays) {
    int length = 0;
    for (int[] array : arrays) {

   * Returns the values from each provided array combined into a single array. For example, {@code
   * concat(new int[] {a, b}, new int[] {}, new int[] {c}} returns the array {@code {a, b, c}}.
   *
   * @param arrays zero or more {@code int} arrays
   * @return a single array containing all the values from the source arrays, in order
   */
  public static int[] concat(int[]... arrays) {
    int length = 0;
    for (int[] array : arrays) {

// If the value passed in is not actually a map, this will panic.
func Int32KeySet[T any](theMap map[int32]T) Int32 {
	return Int32(KeySet(theMap))
}

// Insert adds items to the set.
func (s Int32) Insert(items ...int32) Int32 {
	return Int32(cast(s).Insert(items...))
}

// Delete removes all items from the set.
func (s Int32) Delete(items ...int32) Int32 {
	return Int32(cast(s).Delete(items...))

		} else {
			time.Sleep(3 * time.Millisecond)
		}
		ift2, err := Interfaces()
		if err != nil {
			ti.teardown()
			t.Fatal(err)
		}
		if len(ift2) <= len(ift1) {
			for _, ifi := range ift1 {
				t.Logf("before: %v", ifi)
			}
			for _, ifi := range ift2 {
				t.Logf("after: %v", ifi)
			}
			ti.teardown()
			t.Fatalf("got %v; want gt %v", len(ift2), len(ift1))
		}
		for _, ifi := range ift2 {