// Printf prints a format string filled with the given values.
964959
func Printf(format string, a ...interface{}) (n int, err error) {
	out := Sprintf(format, a...)
	print(out)
	return len([]byte(out)), nil
}
1310062
func (d *Dataset) Printf(format string) *Dataset {
	return d.Fprintf(os.Stdout, format)
}
170624
func Printf(format string, a ...interface{}) (int, error) {
	format += ResetCode
	format = compile(format)
	return fmt.Printf(format, a...)
}
450992
func (p *printer) printf(format string, args ...interface{}) {
	n, err := fmt.Fprintf(p, format, args...)
	p.written += n
	if err != nil {
		panic(localError{err})
	}
}
159550
func (logger *Logger) Printf(format string, v ...interface{}) {
	logger.Output(2, fmt.Sprintf(format, v...))
}
760695
func (cl *CallbackLogger) Printf(format string, v ...interface{}) {
	file, line := fileAndLine(2)
	cl.f(&logutilpb.Event{
		Time:  TimeToProto(time.Now()),
		Level: logutilpb.Level_CONSOLE,
		File:  file,
		Line:  line,
		Value: fmt.Sprintf(format, v...),
	})
}
280855
func (ctx *WriterContext) Writef(format string, args ...interface{}) error {
	_, err := fmt.Fprintf(ctx.writer, format, args...)
	return err
}
1282921
func (l *Logger) Printf(format string, v ...interface{}) {
	l.Emit(0, fmt.Sprintf(format, v...), nil)
}
678722
func (l *Slog) Printf(s string, v ...interface{}) {
	l = l.copy()
	l.Log.di(fnLevelDi)
	l.Log.Message(fmt.Sprintf(s, v...))
	l.commit()
}
1110791
func (p *Pretty) PrintValue(val r.Value, level int) {
	if !val.IsValid() {
		io.WriteString(p.Out, p.NilString)
		return
	}

	cur := strings.Repeat(p.Indent, level)
	next := strings.Repeat(p.Indent, level+1)

	nl := "\n"
	if len(p.Indent) == 0 {
		nl = " "
	}

	if p.MaxLevel > 0 && level >= p.MaxLevel {
		io.WriteString(p.Out, val.String())
		return
	}

	switch val.Kind() {
	case r.Int, r.Int8, r.Int16, r.Int32, r.Int64:
		io.WriteString(p.Out, strconv.FormatInt(val.Int(), 10))

	case r.Uint, r.Uint8, r.Uint16, r.Uint32, r.Uint64:
		io.WriteString(p.Out, strconv.FormatUint(val.Uint(), 10))

	case r.Float32, r.Float64:
		io.WriteString(p.Out, strconv.FormatFloat(val.Float(), 'f', -1, 64))

	case r.String:
		io.WriteString(p.Out, strconv.Quote(val.String()))

	case r.Bool:
		io.WriteString(p.Out, strconv.FormatBool(val.Bool()))

	case r.Map:
		l := val.Len()

		io.WriteString(p.Out, "{"+nl)
		for i, k := range val.MapKeys() {
			io.WriteString(p.Out, next)
			io.WriteString(p.Out, strconv.Quote(k.String()))
			io.WriteString(p.Out, ": ")
			p.PrintValue(val.MapIndex(k), level+1)
			if i < l-1 {
				io.WriteString(p.Out, ","+nl)
			} else {
				io.WriteString(p.Out, nl)
			}
		}
		io.WriteString(p.Out, cur)
		io.WriteString(p.Out, "}")

	case r.Array, r.Slice:
		l := val.Len()

		if p.Compact && l == 0 {
			io.WriteString(p.Out, "[]")
		} else {
			io.WriteString(p.Out, "["+nl)
			for i := 0; i < l; i++ {
				io.WriteString(p.Out, next)
				p.PrintValue(val.Index(i), level+1)
				if i < l-1 {
					io.WriteString(p.Out, ","+nl)
				} else {
					io.WriteString(p.Out, nl)
				}
			}
			io.WriteString(p.Out, cur)
			io.WriteString(p.Out, "]")
		}

	case r.Interface, r.Ptr:
		p.PrintValue(val.Elem(), level)

	case r.Struct:
		if val.CanInterface() {
			i := val.Interface()
			if i, ok := i.(fmt.Stringer); ok {
				io.WriteString(p.Out, i.String())
			} else {
				l := val.NumField()

				sOpen := "struct {"

				if p.Compact {
					sOpen = "{"
				}

				if p.Compact && l == 0 {
					io.WriteString(p.Out, "{}")
				} else {
					io.WriteString(p.Out, sOpen+nl)
					for i := 0; i < l; i++ {
						io.WriteString(p.Out, next)
						io.WriteString(p.Out, val.Type().Field(i).Name)
						io.WriteString(p.Out, ": ")
						p.PrintValue(val.Field(i), level+1)
						if i < l-1 {
							io.WriteString(p.Out, ","+nl)
						} else {
							io.WriteString(p.Out, nl)
						}
					}
					io.WriteString(p.Out, cur)
					io.WriteString(p.Out, "}")
				}
			}
		} else {
			io.WriteString(p.Out, "protected")
		}

	default:
		io.WriteString(p.Out, "unsupported:")
		io.WriteString(p.Out, val.String())
	}
}
847957
func Print(priority Priority, format string, a ...interface{}) error {
	return Send(fmt.Sprintf(format, a...), priority, nil)
}
1037947
func (l *Logger) Printf(format string, v ...interface{}) {
	if e := l.Debug(); e.Enabled() {
		e.Msg(fmt.Sprintf(format, v...))
	}
}
671248
func (s VerboseLogger) Printf(format string, v ...interface{}) {
	s.Logger.Printf(format, v...)
}
1123749
func Printf(str string, vals ...interface{}) {
	log.di(fnLevelDiPlus1).Printf(str, vals...)
}
311512
func (cmd *CLI) Printf(format string, a ...interface{}) {
	fmt.Fprintf(cmd.StdOut(), format, a...)
}
244390
func (s StdLogger) Printf(format string, v ...interface{}) {
	s.Logger.Printf(format, v...)
}
1255474
func (c Colorize) Fprintf(w io.Writer, format string, v ...interface{}) (int, error) {
	return Fprintf(w, c.Foreground, c.Background, format, v...)
}