printpointer(&x) // ERROR "live at call to printpointer: x$"
	printpointer(&x)
}

func f3(b1, b2 bool) {
	// Here x and y are ambiguously live. In previous go versions they
	// were marked as live throughout the function to avoid being
	// poisoned in GODEBUG=gcdead=1 mode; this is now no longer the
	// case.

	printint(0)
	if b1 == false {
		printint(0)
		return
	}

	if b2 {

]() {
        var b0 string
        for range b0 {}
        for _ = range b0 {}
        for _, _ = range b0 {}

        var b1 B1
        for range b1 {}
        for _ = range b1 {}
        for _, _ = range b1 {}

        var b2 B2
        for range b2 {}

        var c0 chan int
        for range c0 {}
        for _ = range c0 {}

// IntPerLayer-DAG: %[[output1_quantized:.*]] = "tf.PartitionedCall"(%[[output0_quantized]], %[[w1]], %[[b1]]) <{config = "", config_proto = "", executor_type = "", f = @composite_conv2d_with_bias_and_relu6_fn_1}> {_tfl_quant_trait = "fully_quantizable"}
// IntPerLayer-DAG: %[[output1_unquantized:.*]] = "tf.PartitionedCall"(%[[output0_quantized]], %[[w1]], %[[b1]]) <{config = "", config_proto = "", executor_type = "", f = @composite_conv2d_with_bias_and_relu6_fn_1_0}>

    TypeWithDuplicates b1 = new TypeWithDuplicates(2, 1);
    TypeWithDuplicates b2 = new TypeWithDuplicates(2, 2);
    TypeWithDuplicates c = new TypeWithDuplicates(3, 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,
            c,
            b2);

	printpointer(&x) // ERROR "live at call to printpointer: x$"
	printpointer(&x)
}

func f3(b1, b2 bool) {
	// Here x and y are ambiguously live. In previous go versions they
	// were marked as live throughout the function to avoid being
	// poisoned in GODEBUG=gcdead=1 mode; this is now no longer the
	// case.

	printint(0)
	if b1 == false {
		printint(0)
		return
	}

	if b2 {

			}

			// read should ignore blank fields in b2
			var b2 BlankFields
			if err := Read(bytes.NewReader(buf), LittleEndian, &b2); err != nil {
				t.Error(err)
			}
			if b1.A != b2.A || b1.B != b2.B || b1.C != b2.C {
				t.Errorf("%#v != %#v", b1, b2)
			}
		})
	}
}

func TestSizeStructCache(t *testing.T) {
	// Reset the cache, otherwise multiple test runs fail.
	structSize = sync.Map{}

	case *FuncType:
		b1 := filterParamList(t.Params, f, export)
		b2 := filterParamList(t.Results, f, export)
		return b1 || b2
	case *InterfaceType:
		if filterFieldList(t.Methods, f, export) {
			t.Incomplete = true
		}
		return len(t.Methods.List) > 0
	case *MapType:
		b1 := filterType(t.Key, f, export)
		b2 := filterType(t.Value, f, export)
		return b1 || b2
	case *ChanType:

			d.buf.Reset()
			var b0, b1 byte
			for {
				if b, ok = d.mustgetc(); !ok {
					return nil, d.err
				}
				d.buf.WriteByte(b)
				if b0 == '-' && b1 == '-' {
					if b != '>' {
						d.err = d.syntaxError(
							`invalid sequence "--" not allowed in comments`)
						return nil, d.err
					}
					break
				}
				b0, b1 = b1, b
			}
			data := d.buf.Bytes()

00000280  18 aa 03 ea 06 75 22 dd  78 d2 a5 89 b8 c9 23 64  |.....u".x.....#d|
00000290  e1 28 38 ce 34 6c 6e 06  7b 51 f1 a7 e6 f4 b3 7f  |.(8.4ln.{Q......|
000002a0  fa b1 3f 14 11 89 66 79  d1 8e 88 0e 0b a0 9e 30  |..?...fy.......0|
000002b0  2a c0 67 ef ca 46 02 88  e9 53 81 22 69 22 97 ad  |*.g..F...S."i"..|
000002c0  80 93 d4 f7 dd 70 14 24  d7 70 0a 46 a1 16 03 03  |.....p.$.p.F....|

	if n < sz {
		return RuneError, 1
	}
	b1 := p[1]
	if b1 < accept.lo || accept.hi < b1 {
		return RuneError, 1
	}
	if sz <= 2 { // <= instead of == to help the compiler eliminate some bounds checks
		return rune(p0&mask2)<<6 | rune(b1&maskx), 2
	}
	b2 := p[2]
	if b2 < locb || hicb < b2 {
		return RuneError, 1
	}
	if sz <= 3 {
		return rune(p0&mask3)<<12 | rune(b1&maskx)<<6 | rune(b2&maskx), 3
	}
	b3 := p[3]