var b bool

func f1(q *Q, xx []byte) interface{} { // ERROR "live at call to newobject: xx$" "live at entry to f1: xx$"
	// xx was copied from the stack to the heap on the previous line:
	// xx was live for the first two prints but then it switched to &xx
	// being live. We should not see plain xx again.
	if b {
		global = &xx
	}
	xx, _, err := f2(xx, 5) // ERROR "live at call to f2: &xx$"
	if err != nil {
		return err
	}
	return nil
}

        given:
        def logFile = log("""\
            line1
            line2
            line3""")

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "input-ending eoln is ignored"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3
        """)

        expect:

func liveValues(f *Func, reachable []bool) (live []bool, liveOrderStmts []*Value) {
	live = f.Cache.allocBoolSlice(f.NumValues())
	liveOrderStmts = f.Cache.allocValueSlice(f.NumValues())[:0]

	// After regalloc, consider all values to be live.
	// See the comment at the top of regalloc.go and in deadcode for details.
	if f.RegAlloc != nil {
		for i := range live {
			live[i] = true
		}
		return
	}

		s.interfere = s.interfere[:n]
	} else {
		s.interfere = make([][]ID, n)
	}
	live := f.newSparseSet(f.NumValues())
	defer f.retSparseSet(live)
	for _, b := range f.Blocks {
		// Propagate liveness backwards to the start of the block.
		// Two values interfere if one is defined while the other is live.
		live.clear()
		live.addAll(s.live[b.ID])
		for i := len(b.Values) - 1; i >= 0; i-- {
			v := b.Values[i]

	fs.DurationVar(&s.LivezGracePeriod, "livez-grace-period", s.LivezGracePeriod, ""+
		"This option represents the maximum amount of time it should take for apiserver to complete its startup sequence "+
		"and become live. From apiserver's start time to when this amount of time has elapsed, /livez will assume "+
		"that unfinished post-start hooks will complete successfully and therefore return true.")

	var e interface{} // ERROR "stack object e interface \{\}$"
	func() {          // ERROR "live at entry to f.func1: &e a$"
		e = a.s // ERROR "live at call to convT: &e$" "stack object a T$"
	}()
	// Before the fix, both a and e were live at the previous line.
	_ = e

func autotmpImplicit() { // ERROR "can inline autotmpImplicit"
	var t int
	implicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

func autotmpExplicit() { // ERROR "can inline autotmpExplicit"
	var t int
	explicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

			encryptionConfigPath: "testdata/encryption-configs/no-kms-provider.yaml",
			wantHealthzChecks:    []string{"etcd"},
			wantReadyzChecks:     []string{"etcd", "etcd-readiness"},
			wantLivezChecks:      []string{"etcd"},
		},
		{
			name:                 "no kms-provider+reload, expect single kms healthz check, no kms livez check",

		}
		linenumber = fmt.Sprintf("(%s%d) ", pfx, p.Line())
	}
	return linenumber
}

func (p stringFuncPrinter) value(v *Value, live bool) {
	if !p.printDead && !live {
		return
	}
	fmt.Fprintf(p.w, "    %s", StmtString(v.Pos))
	fmt.Fprint(p.w, v.LongString())
	if !live {
		fmt.Fprint(p.w, " DEAD")
	}
	fmt.Fprintln(p.w)
}

func (p stringFuncPrinter) startDepCycle() {

}

// isEnvoyReady checks to ensure that Envoy is in the LIVE state and workers have started.
func (p *Probe) isEnvoyReady() error {
	if p.NoEnvoy {
		return nil
	}
	if p.Context == nil {
		return p.checkEnvoyReadiness()
	}
	select {
	case <-p.Context.Done():
		return fmt.Errorf("server is not live, current state is: %s", StateString(Draining))
	default:
		return p.checkEnvoyReadiness()
	}