package foo

func debugf(format string, args ...interface{}) { // ERROR "can inline debugf" "format does not escape" "args does not escape"
	// Dummy implementation for non-debug build.
	// A non-empty implementation would be enabled with a build tag.
}

func bar() { // ERROR "can inline bar"
	value := 10
	debugf("value is %d", value) // ERROR "inlining call to debugf" "value does not escape" "\.\.\. argument does not escape"

}

var (
	D        MultiFlag
	I        MultiFlag
	PrintOut int
	DebugV   bool
)

func init() {
	flag.Var(&D, "D", "predefined symbol with optional simple value -D=identifier=value; can be set multiple times")
	flag.Var(&I, "I", "include directory; can be set multiple times")
	flag.BoolVar(&DebugV, "v", false, "print debug output")

	for {
		log.Debug("accepting conn")
		conn, err := z.accept()
		if err != nil {
			if errors.Is(err, net.ErrClosed) {
				log.Debug("listener closed - returning")
				return
			}

			log.Errorf("failed to accept conn: %v", err)
			continue
		}
		log.Debug("connection accepted")
		go func() {
			log.Debug("handling conn")

// MODEL-DEBUG: %[[f_sqrt2:.*]] = "tfl.sqrt"(%[[f_sqrt1]])
// MODEL-DEBUG-NOT: debug_
// MODEL-DEBUG-SAME: (tensor<?x1x1x3xf32>)
// MODEL-DEBUG: %[[q_sqrt2:.*]] = "tfl.sqrt"(%[[dq1]]
// MODEL-DEBUG-NOT: debug_
// MODEL-DEBUG-SAME: (tensor<?x1x1x3xf32>)
// MODEL-DEBUG: %[[q2:.*]] = "tfl.quantize"(%[[q_sqrt2]])
// MODEL-DEBUG: %[[f_mul:.*]] = tfl.mul %[[f_sqrt2]], %[[f_conv]]

		log.Debugf("Failed to unmarshal CNI plugin log entry: %v", err)
		return cniLog{}, false
	}
	var msg cniLog
	if err := json.Unmarshal(raw["msg"], &msg.Msg); err != nil {
		log.Debugf("Failed to unmarshal CNI plugin log entry: %v", err)
		return cniLog{}, false
	}
	if err := json.Unmarshal(raw["level"], &msg.Level); err != nil {
		log.Debugf("Failed to unmarshal CNI plugin log entry: %v", err)

		hostsideProbeIPSet:   probeSet,
	}
}

func (s *NetServer) Start(ctx context.Context) {
	log.Debug("starting ztunnel server")
	go s.ztunnelServer.Run(ctx)
}

func (s *NetServer) Stop() {
	log.Debug("removing host iptables rules")
	s.iptablesConfigurator.DeleteHostRules()

	log.Debug("destroying host ipset")
	s.hostsideProbeIPSet.Flush()
	if err := s.hostsideProbeIPSet.DestroySet(); err != nil {

		caller     bool
		wantExit   bool
		stackLevel Level
	}{
		{
			f:   func() { Debug("Hello") },
			pat: timePattern + "\tdebug\tHello",
		},
		{
			f:   func() { Debugf("Hello") },
			pat: timePattern + "\tdebug\tHello",
		},
		{
			f:   func() { Debugf("%s", "Hello") },
			pat: timePattern + "\tdebug\tHello",
		},

		{
			f:   func() { Info("Hello") },
			pat: timePattern + "\tinfo\tHello",

	return &bucketMetacache{
		bucket:     bucket,
		caches:     make(map[string]metacache, 10),
		cachesRoot: make(map[string][]string, 10),
	}
}

func (b *bucketMetacache) debugf(format string, data ...interface{}) {
	if serverDebugLog {
		console.Debugf(format+"\n", data...)
	}
}

// findCache will attempt to find a matching cache for the provided options.
// If a cache with the same ID exists already it will be returned.

	switch {
	case !req.Full:
		if log.DebugEnabled() {
			log.Debugf("%s: %s%s for node:%s resources:%d size:%s%s",
				v3.GetShortType(w.TypeUrl), ptype, req.PushReason(), con.proxy.ID, len(res), util.ByteCount(configSize), info)
		}
	default:
		debug := ""
		if log.DebugEnabled() {
			// Add additional information to logs when debug mode enabled.
			debug = " nonce:" + resp.Nonce + " version:" + resp.VersionInfo
		}

		}
		msg += fmt.Sprintf("validate %s: OK (empty value)", pstr)
		scope.Debug(msg)
		return nil
	}

	vf, ok := getValidationFuncForPath(validations, path)
	if !ok {
		msg += fmt.Sprintf("validate %s: OK (no validation)", pstr)
		scope.Debug(msg)
		// No validation defined.
		return nil
	}
	scope.Debug(msg)
	return vf(path, val)
}