for i := range oldTargets {
		currentTgt, ok := oldTargets[i].(*http.Target)
		if !ok {
			continue
		}
		var newTgt *http.Target

		for ii := range tgts {
			if currentTgt.Name() == tgts[ii].Name() {
				newTgt = tgts[ii]
				currentTgt.AssignMigrateTarget(newTgt)
				http.CreateOrAdjustGlobalBuffer(currentTgt, newTgt)
				break
			}
		}
	}

	for _, t := range tgts {

	v := 0 // ERROR "moved to heap: v$"
	b.ii = &v
	return b.ii
}

func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
	v := 0 // ERROR "moved to heap: v$"
	b.ii = &v
	return b.ii
}

func (b Bar) StillNoLeak() int { // ERROR "b does not escape$"
	v := 0
	b.ii = &v
	return b.i
}

func goLeak(b *Bar) { // ERROR "leaking param: b$"
	go b.NoLeak()

        dst[ di++ ] = sid.sub_authority_count;
        System.arraycopy(sid.identifier_authority, 0, dst, di, 6);
        di += 6;
        for ( int ii = 0; ii < sid.sub_authority_count; ii++ ) {
            jcifs.util.Encdec.enc_uint32le(sid.sub_authority[ ii ], dst, di);
            di += 4;
        }
        return dst;
    }

    int type;
    String domainName = null;
    String acctName = null;

}

func (i Instances) Len() int {
	return len(i)
}

func (i Instances) NamespacedNames() NamespacedNames {
	out := make(NamespacedNames, 0, i.Len())
	for _, ii := range i {
		out = append(out, ii.NamespacedName())
	}

	sort.Stable(out)
	return out

		_ = interface{}(nil) == nil
	)
	ii := func(i1 interface{}, i2 interface{}) bool { return i1 == i2 }
	ni := func(n interface{}, i int) bool { return n == i }
	in := func(i int, n interface{}) bool { return i == n }
	pi := func(p *int, i interface{}) bool { return p == i }
	ip := func(i interface{}, p *int) bool { return i == p }

	assert((interface{}(nil) == interface{}(nil)) == ii(nilN, nilN),

	// basics
	var i, j interface{ m() int }
	_ = i == j
	_ = i != j
	_ = i == nil
	_ = i /* ERROR "< not defined" */ < j

	// various interfaces
	var ii interface { m() int; n() }
	var k interface { m() float32 }
	_ = i == ii
	_ = i == k /* ERROR "mismatched types" */

	// interfaces vs values
	var s1 S1
	var s11 S11
	var s2 S2

	_ = i == 0 /* ERROR "cannot convert" */

5aETbbIgmuvewdjvSBSjYzBhMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggr
BgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCkGA1UdEQQiMCCCDmxvY2FsaG9zdDo1
NDUzgg4xMjcuMC4wLjE6NTQ1MzAKBggqhkjOPQQDAgNIADBFAiEA2zpJEPQyz6/l
Wf86aX6PepsntZv2GYlA5UpabfT2EZICICpJ5h/iI+i341gBmLiAFQOyTDT+/wQc
6MF9+Yw1Yy0t
-----END CERTIFICATE-----`)
	keyPem := []byte(`-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIIrYSSNQFaA2Hwf1duRSxKtLYX5CB04fSeQ6tF1aY/PuoAoGCCqGSM49

departe
deşi
din
dinaintea
dintr
dintre
drept
după
ea
ei
el
ele
eram
este
eşti
eu
face
fără
fi
fie
fiecare
fii
fim
fiţi
iar
ieri
îi
îl
îmi
împotriva
în 
înainte
înaintea
încât
încît
încotro
între
întrucât
întrucît
îţi
la
lângă
le
li
lîngă
lor
lui
mă
mâine
mea

	// 21                22
	*e3(&iv, 21), p2 = e2(s2, 22).(I)
	if !p1 || p2 {
		println("bad interface check", i, p1, p2)
		panic("fail")
	}

	s := string(a[0:i])
	if s != "def   ii A 0   C 0     " {
		println("bad array results:", s)
		panic("fail")
	}

		line += "0123456789ABCDEF" // 16 characters
	}

	// make sure that all log outputs is much larger than 2M
	wg := sync.WaitGroup{}
	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func() {
			for ii := 0; ii < 1024; ii++ {
				for j := 0; j < 8; j++ {
					log.Println(line)
				}
			}
			wg.Done()
		}()
	}
	wg.Wait()
	Sync()

	ticker := time.NewTicker(100 * time.Millisecond)