// Print with a format
340241
func (p FmtPrinter) Printf(logger *Logger, format string, a ...interface{}) {
	format = "%s " + format
	b := make([]interface{}, 1)
	b[0] = logger.Color(logger.Name)
	a = append(b, a...)
	fmt.Fprintf(os.Stderr, format, a...)
}
1273900
func print(w io.Writer, v interface{}) {
	if s, ok := v.(fmt.Stringer); ok {
		fmt.Fprint(w, s.String())
	} else {
		switch v.(type) {
		case string:
			fmt.Fprintf(w, "%s", v)
		case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
			fmt.Fprintf(w, "%d", v)
		case float32, float64:
			fmt.Fprintf(w, "%g", v)
		default:
			fmt.Fprintf(w, "%v", v)
		}
	}
}
311512
func (cmd *CLI) Printf(format string, a ...interface{}) {
	fmt.Fprintf(cmd.StdOut(), format, a...)
}
1318089
func (t internalLog) Printf(format string, v ...interface{}) {
	t.Output(2, fmt.Sprintf(format, v...))
}
893481
func (me *Logger) print(priority int, v ...interface{}) {
	if priority <= me.priority {
		me.setFullPrefix(priority)
		me.logger.Print(v...)
	}
}
859046
func print(v interface{}) string {
	switch vt := v.(type) {
	case Map:
		return vt.String()
	case Slice:
		return vt.String()
	case BSON:
		return fmt.Sprintf("BSON(%v)", vt)
	case Float:
		return fmt.Sprintf("Float(%v)", vt)
	case String:
		return fmt.Sprintf("String(%v)", vt)
	case Array:
		wr := bytes.NewBuffer(nil)
		fmt.Fprint(wr, "Array([")
		for i, vtv := range vt {
			fmt.Fprint(wr, print(vtv))
			if i != len(vt)-1 {
				fmt.Fprint(wr, " ")
			}
		}
		fmt.Fprintf(wr, "])")
		return wr.String()
	case Binary:
		return fmt.Sprintf("Binary(%v)", vt)
	case Undefined:
		return "Undefined()"
	case ObjectId:
		return fmt.Sprintf("ObjectId(%v)", vt)
	case Bool:
		return fmt.Sprintf("Bool(%v)", vt)
	case UTCDateTime:
		return fmt.Sprintf("UTCDateTime(%v)", time.Unix(0, int64(vt)*1000*1000))
	case Null:
		return "Null()"
	case Regexp:
		return fmt.Sprintf("Regexp(Pattern(%v) Options(%v))", vt.Pattern, vt.Options)
	case DBPointer:
		return fmt.Sprintf("DBPointer(Name(%v) ObjectId(%v))", vt.Name, vt.ObjectId)
	case Javascript:
		return fmt.Sprintf("Javascript(%v)", vt)
	case Symbol:
		return fmt.Sprintf("Symbol(%v)", vt)
	case JavascriptScope:
		return fmt.Sprintf("JavascriptScope(Javascript(%v) Scope(%v))", vt.Javascript, vt.Scope)
	case Int32:
		return fmt.Sprintf("Int32(%v)", vt)
	case Timestamp:
		return fmt.Sprintf("Timestamp(%v)", vt)
	case Int64:
		return fmt.Sprintf("Int64(%v)", vt)
	case MinKey:
		return "MinKey()"
	case MaxKey:
		return "MaxKey()"
	}
	return fmt.Sprint(v)
}
1249355
func (l *Logger) Printf(format string, args ...interface{}) {
	l.logger().Printf(format, args...)
}
1037947
func (l *Logger) Printf(format string, v ...interface{}) {
	if e := l.Debug(); e.Enabled() {
		e.Msg(fmt.Sprintf(format, v...))
	}
}
262141
func (entry *Entry) Print(args ...interface{}) {
	if entry.lgEntry.Logger.Level >= lg.InfoLevel {
		entry.lgEntry.WithFields(entry.fields).Info(args...)
	}
}
1166572
func Print(v ...interface{}) {
	if Severity >= LevelInfo {
		std.Output(5, fmt.Sprint(v...), LevelInfo)
	}
}
1184270
func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
	c.Set()
	defer c.unset()

	return fmt.Fprintf(Output, format, a...)
}
102822
func (p *Printer) Print(vs ...interface{}) {
	for i, v := range vs {
		if i > 0 {
			fmt.Fprint(p.w, " ")
		}
		p.reprValue(map[reflect.Value]bool{}, reflect.ValueOf(v), "")
	}
}
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})
	}
}
307136
func (p HTMLPrinter) Print(w io.Writer, kind Kind, tokText string) error {
	if p.AsOrderedList {
		if i := strings.Index(tokText, "\n"); i > -1 {
			if err := p.Print(w, kind, tokText[:i]); err != nil {
				return err
			}
			w.Write([]byte("</li>\n<li>"))
			if err := p.Print(w, kind, tokText[i+1:]); err != nil {
				return err
			}
			return nil
		}
	}

	class := ((HTMLConfig)(p)).Class(kind)
	if class != "" {
		_, err := w.Write([]byte(`<span class="`))
		if err != nil {
			return err
		}
		_, err = io.WriteString(w, class)
		if err != nil {
			return err
		}
		_, err = w.Write([]byte(`">`))
		if err != nil {
			return err
		}
	}
	template.HTMLEscape(w, []byte(tokText))
	if class != "" {
		_, err := w.Write([]byte(`</span>`))
		if err != nil {
			return err
		}
	}
	return nil
}
844059
func (l *loggerImpl) print(level int, lstr string, msg string, args ...interface{}) {
	l.Lock()
	defer l.Unlock()
	var t = time.Now().Format("15:04:05.000000")
	var c = colors[level]
	c.Println(fmt.Sprintf("%s%s %s %s", l.prefix, lstr, t, fmt.Sprintf(msg, args...)))
}
445860
func (w *Wrapper) Printf(format string, values ...interface{}) {
	fmt.Fprintf(w, format+"\t", values...)
}
660153
func (c *Code) Print(args ...interface{}) {
	if len(args) > 0 {
		for i := 0; i < c.indent; i++ {
			c.text += indentation
		}
		c.text += fmt.Sprintf(args[0].(string), args[1:]...)
	}
	c.text += "\n"
}