EXPECT_THAT(r_.AddTensor(0), 7);
  // /* after */
  // %0 = f1()
  // %1 = f2(%0)
  // %2 = f3(%0,%1)
  // %3 = f4(%0,%1,%2)
  // f5()
  // %4 = f2(%0)
  // %5 = f3(%0,%4)
  // %6 = f4(%0,%4,%5)
}

class RematSimulationTest : public testing::Test {
 protected:
  class RandomRemat : public Rematerializer {
   public:

// Call of inlined method with blank receiver.
func (_ *T) M() int { return 1 }
func (t *T) MM() int { return t.M() }


// One more like issue 2678
type S struct { x, y int }
type U []S

func F4(S int) U { return U{{S,S}} }

func F5() []*S {
	return []*S{ {1,2}, { 3, 4} }
}

func F6(S int) *U {
	return &U{{S,S}}
}

// Bug in the fix.

type PB struct { x int }

		return 1
	}
	return 0
}

func F2() int {
	if (M{1: 2}) == nil {
		return 1
	}
	return 0
}

func F3() int {
	if nil == (A{}) {
		return 1
	}
	return 0
}

func F4() int {
	if a := (A{}); a == nil {
		return 1
	}
	return 0
}

func F5() int {
	for k, v := range (M{1: 2}) {
		return v - k
	}
	return 0
}

func F6() int {

00000160  d9 2b 2b 24 23 77 5b 1c  3b bd 75 5d ce 20 54 cf  |.++$#w[.;.u]. T.|
00000170  a1 63 87 1d 1e 24 c4 f3  1d 1a 50 8b aa b6 14 43  |.c...$....P....C|
00000180  ed 97 a7 75 62 f4 14 c8  52 d7 02 03 01 00 01 a3  |...ub...R.......|
00000190  81 93 30 81 90 30 0e 06  03 55 1d 0f 01 01 ff 04  |..0..0...U......|
000001a0  04 03 02 05 a0 30 1d 06  03 55 1d 25 04 16 30 14  |.....0...U.%..0.|

000002a0  4c 72 2b 9d ae db 46 06  06 4d f4 c1 b3 3e c0 d1  |Lr+...F..M...>..|
000002b0  bd 42 d4 db fe 3d 13 60  84 5c 21 d3 3b e9 fa e7  |.B...=.`.\!.;...|
000002c0  16 03 03 00 ac 0c 00 00  a8 03 00 1d 20 c5 28 44  |............ .(D|
000002d0  4a 31 d9 b6 53 90 8e 41  3c 67 2c 6f 9d b0 a6 d3  |J1..S..A<g,o....|
000002e0  ed 70 64 94 ba 80 56 ca  f8 d7 10 28 49 08 04 00  |.pd...V....(I...|

		fmt.Println("defer2")
	}()
	for {
		defer func() { // ERROR "heap-allocated defer"
			fmt.Println("defer1")
		}()
		if glob > 2 {
			break
		}
	}
}

func f4() {
	defer func() { // ERROR "open-coded defer"
		fmt.Println("defer")
	}()
label:
	fmt.Println("goto loop")
	if glob > 2 {
		goto label
	}
}

func f5() {
label:
	fmt.Println("goto loop")

	a := x + y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y
	}
	return x
}

func f4(x, y float32, z int) float32 {
	a := x - y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y
	}
	return x

35:			f1(a)
38:				f2(b)
39:				if gretbool() {
41:					f3(c)
46:				f5(b)
48:			f6(a)
33:		for x := 0; x <= 1; x++ { // From delve scopetest.go
35:			f1(a)
38:				f2(b)
39:				if gretbool() {
44:					f4(int(c))
46:				f5(b)
48:			f6(a)
33:		for x := 0; x <= 1; x++ { // From delve scopetest.go
53:				j = id(1)
54:				f = id(2)
56:			for i := 0; i <= 5; i++ {
58:				if i == f {
62:				sleepytime()

000000e0  88 13 65 11 bf ea d9 07  e9 46 fd 5b 60 ce 57 46  |..e......F.[`.WF|
000000f0  8b a9 bd c6 58 1a 3b bd  5e fb 0f 46 ec fc 8b 2c  |....X.;.^..F...,|
00000100  ea a7 19 06 6a e5 6f 10  7a 27 04 6b aa a4 2c f4  |....j.o.z'.k..,.|
00000110  ef 3b e8 8a 51 88 fd e0  ae 33 b1 4c b3 04 5e 91  |.;..Q....3.L..^.|
00000120  b0 98 0b 9f 38 a3 3c fb  9f d5 d2 36 e4 09 19 18  |....8.<....6....|

00000010  fd 0e cd 4d 25 21 88 bf  07 16 95 49 6a 78 2d 70  |...M%!.....Ijx-p|
00000020  25 f7 06 36 f2 98 4c 23  16 41 a5 20 87 60 d3 78  |%..6..L#.A. .`.x|
00000030  c7 ab 8b f9 2b 2c 21 1e  f4 5b 25 bc 81 53 18 5c  |....+,!..[%..S.\|
00000040  3b 7e dd 3e 7b c4 ee d1  f8 9d bf 7a 00 04 13 03  |;~.>{......z....|
00000050  00 ff 01 00 00 91 00 0b  00 04 03 00 01 02 00 0a  |................|