func fmt.Fprintf

316 uses

	fmt (current package)
		print.go#L202: func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
		print.go#L213: 	return Fprintf(os.Stdout, format, a...)

	cloud.google.com/go/storage
		storage.go#L553: 	fmt.Fprintf(buf, "%s\n", opts.Method)
		storage.go#L561: 	fmt.Fprintf(buf, "/%s\n", u.RawPath)
		storage.go#L587: 	fmt.Fprintf(buf, "%s\n", canonicalQueryString.Encode())
		storage.go#L614: 	fmt.Fprintf(buf, "%s\n\n", canonicalHeaders)
		storage.go#L615: 	fmt.Fprintf(buf, "%s\n", signedHeaders)
		storage.go#L623: 			fmt.Fprintf(buf, "%s", strings.SplitN(h, ":", 2)[1])
		storage.go#L635: 	fmt.Fprintf(signBuf, "%s\n", timestamp)
		storage.go#L636: 	fmt.Fprintf(signBuf, "%s\n", credentialScope)
		storage.go#L637: 	fmt.Fprintf(signBuf, "%s", hexDigest)
		storage.go#L709: 	fmt.Fprintf(buf, "%s\n", opts.Method)
		storage.go#L710: 	fmt.Fprintf(buf, "%s\n", opts.MD5)
		storage.go#L711: 	fmt.Fprintf(buf, "%s\n", opts.ContentType)
		storage.go#L712: 	fmt.Fprintf(buf, "%d\n", opts.Expires.Unix())
		storage.go#L714: 		fmt.Fprintf(buf, "%s\n", strings.Join(opts.Headers, "\n"))
		storage.go#L716: 	fmt.Fprintf(buf, "%s", u.String())

	crypto/x509
		root_darwin.go#L48: 					fmt.Fprintf(os.Stderr, "crypto/x509: domain %d, certificate #%d: %v\n", domain, i, err)
		root_darwin.go#L63: 						fmt.Fprintf(os.Stderr, "crypto/x509: trust settings for %v: %v\n", cert.Subject, err)
		root_darwin.go#L68: 					fmt.Fprintf(os.Stderr, "crypto/x509: trust settings for %v: %d\n", cert.Subject, result)
		root_darwin.go#L100: 					fmt.Fprintf(os.Stderr, "crypto/x509: unknown trust setting for %v: %d\n", cert.Subject, result)
		root_darwin.go#L154: 			fmt.Fprintf(os.Stderr, "crypto/x509: SecTrustSettingsCopyTrustSettings for SecTrustSettingsDomainUser failed: %s\n", err)
		root_darwin.go#L171: 			fmt.Fprintf(os.Stderr, "crypto/x509: SecTrustSettingsCopyTrustSettings for SecTrustSettingsDomainAdmin failed: %s\n", err)

	encoding/gob
		type.go#L607: 		fmt.Fprintf(os.Stderr, "checkId: %d should be %d\n", int(got), int(want))

	expvar
		expvar.go#L115: 	fmt.Fprintf(&b, "{")
		expvar.go#L119: 			fmt.Fprintf(&b, ", ")
		expvar.go#L121: 		fmt.Fprintf(&b, "%q: %v", kv.Key, kv.Value)
		expvar.go#L124: 	fmt.Fprintf(&b, "}")
		expvar.go#L334: 	fmt.Fprintf(w, "{\n")
		expvar.go#L338: 			fmt.Fprintf(w, ",\n")
		expvar.go#L341: 		fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
		expvar.go#L343: 	fmt.Fprintf(w, "\n}\n")

	flag
		flag.go#L567: 		fmt.Fprintf(f.Output(), "Usage:\n")
		flag.go#L569: 		fmt.Fprintf(f.Output(), "Usage of %s:\n", f.name)
		flag.go#L588: 	fmt.Fprintf(CommandLine.Output(), "Usage of %s:\n", os.Args[0])

	github.com/aws/aws-sdk-go/aws/awsutil
		prettify.go#L29: 			fmt.Fprintf(buf, "%s", v.Interface())
		prettify.go#L66: 			fmt.Fprintf(buf, " len %d", v.Len())
		prettify.go#L111: 		fmt.Fprintf(buf, format, v.Interface())
		string_value.go#L86: 		fmt.Fprintf(buf, format, v.Interface())

	github.com/aws/aws-sdk-go/aws/credentials/stscreds
		assume_role_provider.go#L108: 	fmt.Fprintf(os.Stderr, "Assume Role MFA token code: ")

	github.com/aws/aws-sdk-go/aws/request
		validation.go#L82: 	fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message())
		validation.go#L85: 		fmt.Fprintf(w, "- %s\n", err.Message())

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L261: 			fmt.Fprintf(&buf, "%%%02X", c)

	github.com/go-git/gcfg/scanner
		errors.go#L116: 			fmt.Fprintf(w, "%s\n", e)
		errors.go#L119: 		fmt.Fprintf(w, "%s\n", err)

	github.com/go-git/go-git/v5
		blame.go#L270: 		fmt.Fprintf(&buf, format, v.Hash.String()[:8],
		repository.go#L144: 	_, err = fmt.Fprintf(f, "gitdir: %s\n", path)
		status.go#L51: 		fmt.Fprintf(buf, "%c%c %s\n", status.Staging, status.Worktree, path)

	github.com/go-git/go-git/v5/plumbing/format/config
		encoder.go#L75: 	_, err := fmt.Fprintf(e.w, msg, args...)

	github.com/go-git/go-git/v5/plumbing/format/index
		index.go#L156: 	fmt.Fprintf(buf, "%06o %s %d\t%s\n", e.Mode, e.Hash, e.Stage, e.Name)
		index.go#L157: 	fmt.Fprintf(buf, "  ctime: %d:%d\n", e.CreatedAt.Unix(), e.CreatedAt.Nanosecond())
		index.go#L158: 	fmt.Fprintf(buf, "  mtime: %d:%d\n", e.ModifiedAt.Unix(), e.ModifiedAt.Nanosecond())
		index.go#L159: 	fmt.Fprintf(buf, "  dev: %d\tino: %d\n", e.Dev, e.Inode)
		index.go#L160: 	fmt.Fprintf(buf, "  uid: %d\tgid: %d\n", e.UID, e.GID)
		index.go#L161: 	fmt.Fprintf(buf, "  size: %d\tflags: %x\n", e.Size, 0)

	github.com/go-git/go-git/v5/plumbing/object
		commit.go#L264: 	if _, err = fmt.Fprintf(w, "tree %s\n", b.TreeHash.String()); err != nil {
		commit.go#L269: 		if _, err = fmt.Fprintf(w, "parent %s\n", parent.String()); err != nil {
		commit.go#L306: 	if _, err = fmt.Fprintf(w, "\n\n%s", b.Message); err != nil {
		object.go#L113: 	if _, err := fmt.Fprintf(w, "%s <%s> ", s.Name, s.Email); err != nil {
		object.go#L161: 	_, err := fmt.Fprintf(w, "%d %s", u, s.When.Format("-0700"))
		tag.go#L187: 	if _, err = fmt.Fprintf(w,
		tree.go#L283: 		if _, err = fmt.Fprintf(w, "%o %s", entry.Mode, entry.Name); err != nil {

	github.com/go-git/go-git/v5/plumbing/transport
		common.go#L146: 					fmt.Fprintf(&buf, ":%d", u.Port)

	github.com/go-git/go-git/v5/storage/filesystem
		shallow.go#L29: 		if _, err := fmt.Fprintf(f, "%s\n", h); err != nil {

	github.com/golang/protobuf/proto
		text_encode.go#L434: 		fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
		text_encode.go#L484: 			fmt.Fprintf(w, "%q", v)
		text_encode.go#L489: 			fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
		text_encode.go#L541: 	fmt.Fprintf(w, "[%s]:", name)

	github.com/google/licensecheck/internal/match
		rematch.go#L236: 		fmt.Fprintf(&b, "%d\t", i)
		rematch.go#L239: 			fmt.Fprintf(&b, "word %s\n", words[inst.arg])
		rematch.go#L241: 			fmt.Fprintf(&b, "any\n")
		rematch.go#L243: 			fmt.Fprintf(&b, "alt %d\n", i+1+int(inst.arg))
		rematch.go#L245: 			fmt.Fprintf(&b, "jump %d\n", i+1+int(inst.arg))
		rematch.go#L247: 			fmt.Fprintf(&b, "match %d\n", int(inst.arg))
		rematch.go#L252: 			fmt.Fprintf(&b, "cut [%d, %d]\n", targ, targ+1+int(p[targ].arg))
		rematch.go#L749: 		fmt.Fprintf(&b, "%d", i)
		rematch.go#L753: 			fmt.Fprintf(&b, " m%d", dfa[i])
		rematch.go#L767: 			fmt.Fprintf(&b, " %s:%d", s, next)
		rematch.go#L769: 		fmt.Fprintf(&b, "\n")
		resyntax.go#L141: 		fmt.Fprintf(b, "__%d__", re.n)

	github.com/google/safehtml
		style.go#L176: 			fmt.Fprintf(&buf, "url(\"%s\")", cssEscapeString(URLSanitized(url).String()))
		style.go#L194: 			fmt.Fprintf(&buf, `"%s"`, cssEscapeString(unescaped))
		style.go#L199: 		fmt.Fprintf(&buf, "display:%s;", filter(properties.Display, safeEnumPropertyValuePattern))
		style.go#L202: 		fmt.Fprintf(&buf, "background-color:%s;", filter(properties.BackgroundColor, safeRegularPropertyValuePattern))
		style.go#L205: 		fmt.Fprintf(&buf, "background-position:%s;", filter(properties.BackgroundPosition, safeRegularPropertyValuePattern))
		style.go#L208: 		fmt.Fprintf(&buf, "background-repeat:%s;", filter(properties.BackgroundRepeat, safeRegularPropertyValuePattern))
		style.go#L211: 		fmt.Fprintf(&buf, "background-size:%s;", filter(properties.BackgroundSize, safeRegularPropertyValuePattern))
		style.go#L214: 		fmt.Fprintf(&buf, "color:%s;", filter(properties.Color, safeRegularPropertyValuePattern))
		style.go#L217: 		fmt.Fprintf(&buf, "height:%s;", filter(properties.Height, safeRegularPropertyValuePattern))
		style.go#L220: 		fmt.Fprintf(&buf, "width:%s;", filter(properties.Width, safeRegularPropertyValuePattern))
		style.go#L223: 		fmt.Fprintf(&buf, "left:%s;", filter(properties.Left, safeRegularPropertyValuePattern))
		style.go#L226: 		fmt.Fprintf(&buf, "right:%s;", filter(properties.Right, safeRegularPropertyValuePattern))
		style.go#L229: 		fmt.Fprintf(&buf, "top:%s;", filter(properties.Top, safeRegularPropertyValuePattern))
		style.go#L232: 		fmt.Fprintf(&buf, "bottom:%s;", filter(properties.Bottom, safeRegularPropertyValuePattern))
		style.go#L235: 		fmt.Fprintf(&buf, "font-weight:%s;", filter(properties.FontWeight, safeRegularPropertyValuePattern))
		style.go#L238: 		fmt.Fprintf(&buf, "padding:%s;", filter(properties.Padding, safeRegularPropertyValuePattern))
		style.go#L241: 		fmt.Fprintf(&buf, "z-index:%s;", filter(properties.ZIndex, safeRegularPropertyValuePattern))
		style.go#L298: 			fmt.Fprintf(&b, "\\%06X", c)

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L115: 		fmt.Fprintf(&b, "%%%02x", c)

	github.com/jackc/pgconn
		errors.go#L72: 	fmt.Fprintf(sb, "failed to connect to `host=%s user=%s database=%s`: %s", e.config.Host, e.config.User, e.config.Database, e.msg)
		errors.go#L74: 		fmt.Fprintf(sb, " (%s)", e.err.Error())

	github.com/jackc/pgx/v4
		tx.go#L49: 		fmt.Fprintf(buf, " isolation level %s", txOptions.IsoLevel)
		tx.go#L52: 		fmt.Fprintf(buf, " %s", txOptions.AccessMode)
		tx.go#L55: 		fmt.Fprintf(buf, " %s", txOptions.DeferrableMode)

	github.com/lann/ps
		map.go#L307: 		fmt.Fprintf(buf, "%s: %s, ", key, val)
		map.go#L309: 	fmt.Fprintf(buf, "}\n")

	github.com/Masterminds/squirrel
		placeholder.go#L107: 			fmt.Fprintf(buf, "%s%d", prefix, i)
		squirrel.go#L169: 			fmt.Fprintf(buf, "'%v'", args[i])

	github.com/prometheus/client_golang/prometheus
		registry.go#L222: 	fmt.Fprintf(buf, "%d error(s) occurred:", len(errs))
		registry.go#L224: 		fmt.Fprintf(buf, "\n* %s", err)

	github.com/russross/blackfriday/v2
		html.go#L924: 				fmt.Fprintf(&buf, ``, headingCount)

	github.com/yuin/goldmark-emoji
		emoji.go#L291: 		fmt.Fprintf(w, `:%s:`, util.EscapeHTML(util.StringToReadOnlyBytes(node.Value.Name)), node.ShortName)
		emoji.go#L302: 			fmt.Fprintf(w, "&#x%x;", r)
		emoji.go#L305: 		fmt.Fprintf(w, "%s", string(node.Value.Unicode))
		emoji.go#L315: 		fmt.Fprintf(w, r.TwemojiTemplate, util.EscapeHTML(util.StringToReadOnlyBytes(node.Value.Name)), strings.Join(values, "-"), s)

	github.com/yuin/goldmark/extension
		table.go#L483: 		fmt.Fprintf(w, "<%s", tag)
		table.go#L496: 					fmt.Fprintf(w, ` align="%s"`, n.Alignment.String())
		table.go#L519: 		fmt.Fprintf(w, "\n", tag)

	github.com/yuin/goldmark/renderer/html
		html.go#L334: 			fmt.Fprintf(w, " start=\"%d\"", n.Start)

	go.opencensus.io/zpages
		rpcz.go#L114: 			fmt.Fprintf(tw, "%s\t%d\t%d\t%d\t%v\t%v\t%v\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%d\t%d\t%d\n",
		tracez.go#L158: 		fmt.Fprintf(tw, "%d\t", x)
		tracez.go#L382: 			fmt.Fprintf(tw, "trace_id: %s span_id: %s", sc.TraceID, sc.SpanID)
		tracez.go#L384: 				fmt.Fprintf(tw, " parent_span_id: %s", r.ParentSpanID)

	go/ast
		commentmap.go#L328: 		fmt.Fprintf(&buf, "\t%p  %20s:  %s\n", node, s, summary(comment))
		print.go#L101: 			_, err = fmt.Fprintf(p.output, "%6d  ", p.line)
		print.go#L129: 	if _, err := fmt.Fprintf(p, format, args...); err != nil {
		scope.go#L53: 	fmt.Fprintf(&buf, "scope %p {", s)
		scope.go#L57: 			fmt.Fprintf(&buf, "\t%s %s\n", obj.Kind, obj.Name)
		scope.go#L60: 	fmt.Fprintf(&buf, "}\n")

	go/printer
		printer.go#L976: 			fmt.Fprintf(os.Stderr, "print: unsupported argument %v (%T)\n", arg, arg)

	go/scanner
		errors.go#L119: 			fmt.Fprintf(w, "%s\n", e)
		errors.go#L122: 		fmt.Fprintf(w, "%s\n", err)

	golang.org/x/mod/modfile
		print.go#L31: 	fmt.Fprintf(p, format, args...)
		read.go#L688: 			fmt.Fprintf(os.Stderr, "LINE %q :%d:%d #%d\n", c.Token, c.Start.Line, c.Start.LineRune, c.Start.Byte)
		read.go#L696: 			fmt.Fprintf(os.Stderr, "pre %T :%d:%d #%d\n", x, start.Line, start.LineRune, start.Byte)
		read.go#L701: 				fmt.Fprintf(os.Stderr, "ASSIGN LINE %q #%d\n", line[0].Token, line[0].Start.Byte)
		read.go#L713: 			fmt.Fprintf(os.Stderr, "SUFFIX %q :%d:%d #%d\n", c.Token, c.Start.Line, c.Start.LineRune, c.Start.Byte)
		read.go#L723: 			fmt.Fprintf(os.Stderr, "post %T :%d:%d #%d :%d:%d #%d\n", x, start.Line, start.LineRune, start.Byte, end.Line, end.LineRune, end.Byte)
		read.go#L746: 				fmt.Fprintf(os.Stderr, "ASSIGN SUFFIX %q #%d\n", suffix[len(suffix)-1].Token, suffix[len(suffix)-1].Start.Byte)

	golang.org/x/net/http2
		frame.go#L201: 				fmt.Fprintf(buf, "0x%x", 1<frame.go#L206: 		fmt.Fprintf(buf, " stream=%d", h.StreamID)
		frame.go#L208: 	fmt.Fprintf(buf, " len=%d", h.Length)
		frame.go#L1584: 			fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
		frame.go#L1596: 		fmt.Fprintf(&buf, " data=%q", data)
		frame.go#L1598: 			fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
		frame.go#L1604: 		fmt.Fprintf(&buf, " incr=%v", f.Increment)
		frame.go#L1606: 		fmt.Fprintf(&buf, " ping=%q", f.Data[:])
		frame.go#L1608: 		fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
		frame.go#L1611: 		fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)

	golang.org/x/net/trace
		events.go#L386: 		fmt.Fprintf(w, "#   %s\t%s:%d\n", name, file, line)

	golang.org/x/pkgsite/cmd/prober
		main.go#L198: 		fmt.Fprintf(flag.CommandLine.Output(), "usage: %s [flags]\n", os.Args[0])
		main.go#L306: 		fmt.Fprintf(w, "All probes succeeded.\n")
		main.go#L309: 		fmt.Fprintf(w, "SOME PROBES FAILED:\n")
		main.go#L311: 			fmt.Fprintf(w, "%3d /%s\n", b.Code, b.Probe.RelativeURL)

	golang.org/x/pkgsite/devtools/cmd/csphash
		main.go#L26: 		fmt.Fprintf(flag.CommandLine.Output(), "usage: %s [flags] FILES\n", os.Args[0])
		main.go#L27: 		fmt.Fprintf(flag.CommandLine.Output(), "suggestion for FILES: content/static/html/**/*.tmpl\n")

	golang.org/x/pkgsite/internal/database
		database.go#L388: 	fmt.Fprintf(&b, "INSERT INTO %s", table)
		database.go#L389: 	fmt.Fprintf(&b, "(%s) VALUES", strings.Join(columns, ", "))
		database.go#L402: 		fmt.Fprintf(&b, "(%s)", strings.Join(placeholders, ", "))
		database.go#L415: 		fmt.Fprintf(&b, " RETURNING %s", strings.Join(returningColumns, ", "))

	golang.org/x/pkgsite/internal/dcensus
		debug.go#L45: 	fmt.Fprintf(&buf, "Name: %q\n", s.Name)
		debug.go#L48: 		fmt.Fprintf(&buf, "  annotation: %q\n", a.Message)
		debug.go#L51: 	fmt.Fprintf(&buf, "Status.Message: %q\n", s.Status.Message)
		debug.go#L61: 		fmt.Fprintf(w, "  %q: %#v\n", k, v)

	golang.org/x/pkgsite/internal/middleware
		experiment.go#L126: 	fmt.Fprintf(h, "%s %s", ip, e.Name)

	golang.org/x/pkgsite/internal/queue
		queue.go#L207: 			fmt.Fprintf(&b, "_%04x", r)

	golang.org/x/pkgsite/internal/worker
		server.go#L233: 	fmt.Fprintf(w, "updated %d packages", n)
		server.go#L274: 		fmt.Fprintf(w, "
Hello, Go Discovery Fetch Service!
")
		server.go#L275: 		fmt.Fprintf(w, `
Fetch an example module
`)
		server.go#L526: 		fmt.Fprintf(w, "Scheduled latest version of modules to be reprocessed for appVersion > %q.", appVersion)
		server.go#L540: 		fmt.Fprintf(w, "Scheduled modules to be reprocessed for appVersion > %q and status = %d.", appVersion, code)
		server.go#L550: 		fmt.Fprintf(w, "Scheduled release and non-incompatible version of modules to be reprocessed for appVersion > %q.", appVersion)
		server.go#L558: 	fmt.Fprintf(w, "Scheduled modules to be reprocessed for appVersion > %q.", appVersion)
		server.go#L582: 	fmt.Fprintf(w, "Deleted %s@%s", modulePath, version)
		server.go#L620: 		fmt.Fprintf(w, "Cleaned %d module versions.\n", len(mvs))
		server.go#L628: 		fmt.Fprintf(w, "Cleaned module %q\n", module)

	golang.org/x/tools/txtar
		archive.go#L61: 		fmt.Fprintf(&buf, "-- %s --\n", f.Name)

	golang.org/x/xerrors
		adaptor.go#L119: 		fmt.Fprintf(s, string(format), p.buf.String())
		adaptor.go#L186: 		fmt.Fprintf((*state)(s), format, args...)

	google.golang.org/api/googleapi
		googleapi.go#L96: 	fmt.Fprintf(&buf, "googleapi: Error %d: ", e.Code)
		googleapi.go#L98: 		fmt.Fprintf(&buf, "%s", e.Message)
		googleapi.go#L106: 			fmt.Fprintf(&buf, "\n%s", detailBuf.String())
		googleapi.go#L114: 		fmt.Fprintf(&buf, ", %s", e.Errors[0].Reason)
		googleapi.go#L119: 		fmt.Fprintf(&buf, "Reason: %s, Message: %s\n", v.Reason, v.Message)

	google.golang.org/grpc
		trace.go#L80: 	fmt.Fprintf(&line, " %v deadline:", f.remoteAddr)

	html/template
		html.go#L163: 			fmt.Fprintf(b, "%s&#x%x;", s[written:i], r)
		url.go#L137: 		fmt.Fprintf(b, "%%%02x", c)

	math/big
		ftoa.go#L486: 		fmt.Fprintf(s, "%%!%c(*big.Float=%s)", format, x.String())
		intconv.go#L81: 		fmt.Fprintf(s, "%%!%c(big.Int=%s)", ch, x.String())

	mime/multipart
		writer.go#L105: 		fmt.Fprintf(&b, "\r\n--%s\r\n", w.boundary)
		writer.go#L107: 		fmt.Fprintf(&b, "--%s\r\n", w.boundary)
		writer.go#L117: 			fmt.Fprintf(&b, "%s: %s\r\n", k, v)
		writer.go#L120: 	fmt.Fprintf(&b, "\r\n")
		writer.go#L177: 	_, err := fmt.Fprintf(w.w, "\r\n--%s--\r\n", w.boundary)

	net/http
		fs.go#L152: 	fmt.Fprintf(w, "
\n")
		fs.go#L162: 		fmt.Fprintf(w, "%s\n", url.String(), htmlReplacer.Replace(name))
		fs.go#L164: 	fmt.Fprintf(w, "
\n")
		h2_bundle.go#L1441: 				fmt.Fprintf(buf, "0x%x", 1<h2_bundle.go#L1446: 		fmt.Fprintf(buf, " stream=%d", h.StreamID)
		h2_bundle.go#L1448: 	fmt.Fprintf(buf, " len=%d", h.Length)
		h2_bundle.go#L2827: 			fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
		h2_bundle.go#L2839: 		fmt.Fprintf(&buf, " data=%q", data)
		h2_bundle.go#L2841: 			fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
		h2_bundle.go#L2847: 		fmt.Fprintf(&buf, " incr=%v", f.Increment)
		h2_bundle.go#L2849: 		fmt.Fprintf(&buf, " ping=%q", f.Data[:])
		h2_bundle.go#L2851: 		fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
		h2_bundle.go#L2854: 		fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)
		request.go#L610: 	_, err = fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(r.Method, "GET"), ruri)
		request.go#L616: 	_, err = fmt.Fprintf(w, "Host: %s\r\n", host)
		request.go#L631: 		_, err = fmt.Fprintf(w, "User-Agent: %s\r\n", userAgent)
		response.go#L260: 	if _, err := fmt.Fprintf(w, "HTTP/%d.%d %03d %s\r\n", r.ProtoMajor, r.ProtoMinor, r.StatusCode, text); err != nil {
		server.go#L377: 		_, err = fmt.Fprintf(cw.res.conn.bufw, "%x\r\n", len(p))
		server.go#L1525: 		fmt.Fprintf(bw, "%03d status code %d\r\n", code, code)
		server.go#L1894: 				fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)
		server.go#L1907: 				fmt.Fprintf(c.rwc, "HTTP/1.1 %d %s%sUnsupported transfer encoding", code, StatusText(code), errorHeaders)
		server.go#L1915: 					fmt.Fprintf(c.rwc, "HTTP/1.1 %d %s: %s%s%d %s: %s", v.code, StatusText(v.code), v.text, errorHeaders, v.code, StatusText(v.code), v.text)
		server.go#L1919: 				fmt.Fprintf(c.rwc, "HTTP/1.1 "+publicErr+errorHeaders+publicErr)

	net/http/httptest
		server.go#L258: 		fmt.Fprintf(&buf, "  %T %p %v in state %v\n", c, c, c.RemoteAddr(), st)

	net/http/httputil
		dump.go#L243: 	fmt.Fprintf(&b, "%s %s HTTP/%d.%d\r\n", valueOrDefault(req.Method, "GET"),
		dump.go#L253: 			fmt.Fprintf(&b, "Host: %s\r\n", host)
		dump.go#L259: 		fmt.Fprintf(&b, "Transfer-Encoding: %s\r\n", strings.Join(req.TransferEncoding, ","))
		dump.go#L262: 		fmt.Fprintf(&b, "Connection: close\r\n")

	net/http/internal
		chunked.go#L203: 	if _, err = fmt.Fprintf(cw.Wire, "%x\r\n", len(data)); err != nil {

	net/textproto
		writer.go#L31: 	fmt.Fprintf(w.W, format, args...)

	runtime/pprof
		pprof.go#L409: 		fmt.Fprintf(&buf, "@")
		pprof.go#L411: 			fmt.Fprintf(&buf, " %#x", pc)
		pprof.go#L437: 		fmt.Fprintf(tw, "%s profile: total %d\n", name, p.Len())
		pprof.go#L439: 			fmt.Fprintf(tw, "%d %s\n", count[k], k)
		pprof.go#L500: 			fmt.Fprintf(w, "#\t%#x\n", frame.PC)
		pprof.go#L505: 			fmt.Fprintf(w, "#\t%#x\t%s+%#x\t%s:%d\n", frame.PC, name, frame.PC-frame.Entry, frame.File, frame.Line)
		pprof.go#L517: 	fmt.Fprintf(w, "\n")
		pprof.go#L597: 	fmt.Fprintf(w, "heap profile: %d: %d [%d: %d] @ heap/%d\n",
		pprof.go#L604: 		fmt.Fprintf(w, "%d: %d [%d: %d] @",
		pprof.go#L608: 			fmt.Fprintf(w, " %#x", pc)
		pprof.go#L610: 		fmt.Fprintf(w, "\n")
		pprof.go#L617: 	fmt.Fprintf(w, "\n# runtime.MemStats\n")
		pprof.go#L618: 	fmt.Fprintf(w, "# Alloc = %d\n", s.Alloc)
		pprof.go#L619: 	fmt.Fprintf(w, "# TotalAlloc = %d\n", s.TotalAlloc)
		pprof.go#L620: 	fmt.Fprintf(w, "# Sys = %d\n", s.Sys)
		pprof.go#L621: 	fmt.Fprintf(w, "# Lookups = %d\n", s.Lookups)
		pprof.go#L622: 	fmt.Fprintf(w, "# Mallocs = %d\n", s.Mallocs)
		pprof.go#L623: 	fmt.Fprintf(w, "# Frees = %d\n", s.Frees)
		pprof.go#L625: 	fmt.Fprintf(w, "# HeapAlloc = %d\n", s.HeapAlloc)
		pprof.go#L626: 	fmt.Fprintf(w, "# HeapSys = %d\n", s.HeapSys)
		pprof.go#L627: 	fmt.Fprintf(w, "# HeapIdle = %d\n", s.HeapIdle)
		pprof.go#L628: 	fmt.Fprintf(w, "# HeapInuse = %d\n", s.HeapInuse)
		pprof.go#L629: 	fmt.Fprintf(w, "# HeapReleased = %d\n", s.HeapReleased)
		pprof.go#L630: 	fmt.Fprintf(w, "# HeapObjects = %d\n", s.HeapObjects)
		pprof.go#L632: 	fmt.Fprintf(w, "# Stack = %d / %d\n", s.StackInuse, s.StackSys)
		pprof.go#L633: 	fmt.Fprintf(w, "# MSpan = %d / %d\n", s.MSpanInuse, s.MSpanSys)
		pprof.go#L634: 	fmt.Fprintf(w, "# MCache = %d / %d\n", s.MCacheInuse, s.MCacheSys)
		pprof.go#L635: 	fmt.Fprintf(w, "# BuckHashSys = %d\n", s.BuckHashSys)
		pprof.go#L636: 	fmt.Fprintf(w, "# GCSys = %d\n", s.GCSys)
		pprof.go#L637: 	fmt.Fprintf(w, "# OtherSys = %d\n", s.OtherSys)
		pprof.go#L639: 	fmt.Fprintf(w, "# NextGC = %d\n", s.NextGC)
		pprof.go#L640: 	fmt.Fprintf(w, "# LastGC = %d\n", s.LastGC)
		pprof.go#L641: 	fmt.Fprintf(w, "# PauseNs = %d\n", s.PauseNs)
		pprof.go#L642: 	fmt.Fprintf(w, "# PauseEnd = %d\n", s.PauseEnd)
		pprof.go#L643: 	fmt.Fprintf(w, "# NumGC = %d\n", s.NumGC)
		pprof.go#L644: 	fmt.Fprintf(w, "# NumForcedGC = %d\n", s.NumForcedGC)
		pprof.go#L645: 	fmt.Fprintf(w, "# GCCPUFraction = %v\n", s.GCCPUFraction)
		pprof.go#L646: 	fmt.Fprintf(w, "# DebugGC = %v\n", s.DebugGC)
		pprof.go#L867: 	fmt.Fprintf(w, "--- contention:\n")
		pprof.go#L868: 	fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond())
		pprof.go#L871: 		fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count)
		pprof.go#L873: 			fmt.Fprintf(w, " %#x", pc)
		pprof.go#L919: 	fmt.Fprintf(w, "--- mutex:\n")
		pprof.go#L920: 	fmt.Fprintf(w, "cycles/second=%v\n", runtime_cyclesPerSecond())
		pprof.go#L921: 	fmt.Fprintf(w, "sampling period=%d\n", runtime.SetMutexProfileFraction(-1))
		pprof.go#L924: 		fmt.Fprintf(w, "%v %v @", r.Cycles, r.Count)
		pprof.go#L926: 			fmt.Fprintf(w, " %#x", pc)
		pprof_rusage.go#L30: 	fmt.Fprintf(w, "# MaxRSS = %d\n", uintptr(rusage.Maxrss)*rssToBytes)

	testing
		benchmark.go#L236: 		fmt.Fprintf(b.w, "--- FAIL: %s\n%s", b.name, b.output)
		benchmark.go#L248: 			fmt.Fprintf(b.w, "--- %s: %s\n%s", tag, b.name, b.output)
		benchmark.go#L261: 		fmt.Fprintf(b.w, "goos: %s\n", runtime.GOOS)
		benchmark.go#L262: 		fmt.Fprintf(b.w, "goarch: %s\n", runtime.GOARCH)
		benchmark.go#L264: 			fmt.Fprintf(b.w, "pkg: %s\n", b.importPath)
		benchmark.go#L267: 			fmt.Fprintf(b.w, "cpu: %s\n", cpu)
		benchmark.go#L417: 	fmt.Fprintf(buf, "%8d", r.N)
		benchmark.go#L430: 		fmt.Fprintf(buf, "\t%7.2f MB/s", mbs)
		benchmark.go#L476: 	fmt.Fprintf(w, format, x, unit)
		benchmark.go#L563: 				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
		benchmark.go#L585: 				fmt.Fprintf(b.w, "--- FAIL: %s\n%s", benchName, b.output)
		benchmark.go#L590: 				fmt.Fprintf(b.w, "%-*s\t", ctx.maxLen, benchName)
		benchmark.go#L600: 				fmt.Fprintf(b.w, "--- BENCH: %s\n%s", benchName, b.output)
		benchmark.go#L603: 				fmt.Fprintf(os.Stderr, "testing: %s left GOMAXPROCS set to %d\n", benchName, p)
		cover.go#L74: 		fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		cover.go#L86: 		fmt.Fprintf(f, "mode: %s\n", cover.Mode)
		cover.go#L102: 				_, err := fmt.Fprintf(f, "%s:%d.%d,%d.%d %d %d\n", name,
		example.go#L37: 			fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
		match.go#L38: 				fmt.Fprintf(os.Stderr, "testing: invalid regexp for element %d of %s (%q): %s\n", i, name, s, err)
		run_example.go#L40: 			fmt.Fprintf(os.Stderr, "testing: copying pipe: %v\n", err)
		testing.go#L360: 	fmt.Fprintf(p.w, format, args...)
		testing.go#L372: 		fmt.Fprintf(p.w, "=== CONT  %s\n", testName)
		testing.go#L376: 	fmt.Fprintf(p.w, format, args...)
		testing.go#L550: 	fmt.Fprintf(buf, "%s:%d: ", file, line)
		testing.go#L596: 		fmt.Fprintf(p.w, format, args...)
		testing.go#L1139: 					fmt.Fprintf(root.parent.w, "cleanup panicked with %v", r)
		testing.go#L1453: 		fmt.Fprintf(os.Stderr, "testing: invalid regexp in -test.list (%q): %s\n", *matchList, err)
		testing.go#L1533: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1537: 			fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s\n", err)
		testing.go#L1546: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1550: 			fmt.Fprintf(os.Stderr, "testing: can't start tracing: %s\n", err)
		testing.go#L1563: 		fmt.Fprintf(os.Stderr, "testing: cannot use -test.coverprofile because test binary was not built with coverage enabled\n")
		testing.go#L1580: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1608: 			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
		testing.go#L1612: 			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *testlog, err)
		testing.go#L1625: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1630: 			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *memProfile, err)
		testing.go#L1638: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1642: 			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *blockProfile, err)
		testing.go#L1650: 			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
		testing.go#L1654: 			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s\n", *mutexProfile, err)
		testing.go#L1720: 			fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)

	text/template
		exec.go#L242: 		fmt.Fprintf(&b, "%q", name)
		funcs.go#L704: 				fmt.Fprintf(w, "\\u%04X", r)

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.