TEXT	·f(SB), 4, $8-0
	CALL	·f1(SB)
	RET	·f2(SB)
	CALL	·unreachable(SB)

TEXT	·leaf(SB), 4, $0-0
	RET	·f3(SB)
	JMP	·unreachable(SB)

TEXT	·leaf2(SB), 4, $32-0 // nonzero frame size
	RET	·f4(SB)

	check1(0)
	check1(1)
	check1(2)
}

type T1 struct {
	X, Y, Z int
}

func f() int {
	return 1
}

func check1(pass int) T1 {
	v := []T1{{X: f(), Z: f()}}
	if v[0].Y != 0 {
		panic("nonzero init")
	}
	v[0].Y = pass
	return v[0]

				}
			case IPv6len:
				switch ifim.Type {
				case sysARPHardwareIPv6IPv6, sysARPHardwareGREIPv6:
					continue
				}
			}
			var nonzero bool
			for _, b := range a.Value {
				if b != 0 {
					nonzero = true
					break
				}
			}
			if nonzero {
				ifi.HardwareAddr = a.Value[:]
			}
		case syscall.IFLA_IFNAME:
			ifi.Name = string(a.Value[:len(a.Value)-1])
		case syscall.IFLA_MTU:

	) ([]IPAddr, error) {
		return fn(ctx, network, host)
	}
	testPreHookSetKeepAlive = func(*netFD) {}
	testHookSetKeepAlive    = func(KeepAliveConfig) {}

	// testHookStepTime sleeps until time has moved forward by a nonzero amount.
	// This helps to avoid flakes in timeout tests by ensuring that an implausibly
	// short deadline (such as 1ns in the future) is always expired by the time
	// a relevant system call occurs.
	testHookStepTime = func() {}

                    android:offset="1.0" />
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:fillColor="#FFFFFF"
        android:fillType="nonZero"

 *       .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
 *       .result();
 * }
 * }</pre>
 *
 * <p>The value of this expression will have the same sign as the <i>first nonzero</i> comparison
 * result in the chain, or will be zero if every comparison result was zero.
 *
 * <p><b>Note:</b> {@code ComparisonChain} instances are <b>immutable</b>. For this utility to work

	// it should finish up and exit with a nonzero status,
	// not have to be killed with SIGKILL.
	cancel()

	io.Copy(stdout, r)
	if stdout.Len() > 0 {
		t.Logf("stdout:\n%s", stdout)
	}
	err = cmd.Wait()

	ee, _ := err.(*exec.ExitError)
	if ee == nil {
		t.Fatalf("unexpectedly finished with nonzero status")
	}
	if len(ee.Stderr) > 0 {
		t.Logf("stderr:\n%s", ee.Stderr)

			re:      regexp.MustCompile(`^0: L23:C23 -- L24:C12 NS=1 = (\d+)$`),
			nonzero: true,
		},
		{
			tag:     "third function unit 1",
			re:      regexp.MustCompile(`^1: L27:C2 -- L28:C10 NS=2 = (\d+)$`),
			nonzero: true,
		},
		{
			tag:     "third function unit 2",
			re:      regexp.MustCompile(`^2: L24:C12 -- L26:C3 NS=1 = (\d+)$`),
			nonzero: true,
		},
	}
	flags := []string{"-live", "-pkg=" + mainPkgPath}

                    android:offset="1.0" />
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:fillColor="#FFFFFF"
        android:fillType="nonZero"

                    android:offset="1.0" />
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:fillColor="#FFFFFF"
        android:fillType="nonZero"