func fmt.Errorf

2523 uses

	fmt (current package)
		errors.go#L17: func Errorf(format string, a ...interface{}) error {

	cloud.google.com/go/errorreporting
		errors.go#L104: 		return nil, fmt.Errorf("creating client: %v", err)

	cloud.google.com/go/internal
		annotate.go#L48: 	return fmt.Errorf("%s: %v", msg, err)

	cloud.google.com/go/logging
		logging.go#L220: 		err = fmt.Errorf("saw %d errors; last: %v", c.nErrs, c.lastErr)
		logging.go#L726: 			return nil, fmt.Errorf("logging: json.Marshal: %v", err)
		logging.go#L732: 		return nil, fmt.Errorf("logging: json.Unmarshal: %v", err)

	cloud.google.com/go/profiler
		heap.go#L101: 		return nil, fmt.Errorf("failed to write heap profile: %v", err)
		heap.go#L108: 		return nil, fmt.Errorf("invalid heap profile: got %d sample types, want 4", got)
		heap.go#L112: 			return nil, fmt.Errorf("invalid heap profile: got %q sample type at index %d, want %q", got, i, want)
		profiler.go#L231: 			return fmt.Errorf("mutex profiling is not supported by %s, requires Go 1.8 or later", runtime.Version())
		profiler.go#L519: 		return nil, fmt.Errorf("collection is not enabled for any profile types")
		profiler.go#L545: 		return fmt.Errorf("service name %q does not match regular expression %v", config.Service, serviceRegexp)
		profiler.go#L570: 				return fmt.Errorf("failed to get the project ID from Compute Engine metadata: %v", err)
		profiler.go#L576: 				return fmt.Errorf("failed to get zone from Compute Engine metadata: %v", err)
		profiler.go#L583: 					return fmt.Errorf("failed to get instance name from Compute Engine metadata: %v", err)
		profiler.go#L590: 			return fmt.Errorf("project ID must be specified in the configuration if running outside of GCP")

	cloud.google.com/go/storage
		bucket.go#L824: 		return fmt.Errorf("storage: %s: empty conditions", method)
		bucket.go#L827: 		return fmt.Errorf("storage: %s: multiple conditions specified for metageneration", method)
		bucket.go#L877: 			return fmt.Errorf("storage: %s: ifMetagenerationMatch not supported", method)
		bucket.go#L881: 			return fmt.Errorf("storage: %s: ifMetagenerationNotMatch not supported", method)
		copy.go#L204: 			return nil, fmt.Errorf("storage: all source objects must be in bucket %q, found %q", c.dst.bucket, src.bucket)
		copy.go#L207: 			return nil, fmt.Errorf("storage: compose source %s.%s must not have encryption key", src.bucket, src.object)
		hmac.go#L171: 		return nil, fmt.Errorf("field CreatedTime: %v", err)
		hmac.go#L175: 		return nil, fmt.Errorf("field UpdatedTime: %v", err)
		hmac.go#L246: 		return nil, fmt.Errorf("storage: invalid state %q for update, must be either %q or %q", au.State, Active, Inactive)
		post_policy_v4.go#L296: 		return nil, fmt.Errorf("storage: PostPolicyV4 JSON serialization failed: %v", err)
		reader.go#L102: 		return nil, fmt.Errorf("storage: invalid offset %d < 0 requires negative length", offset)
		reader.go#L217: 			return nil, fmt.Errorf("storage: invalid Content-Range %q", cr)
		reader.go#L221: 			return nil, fmt.Errorf("storage: invalid Content-Range %q", cr)
		reader.go#L228: 				return nil, fmt.Errorf("storage: invalid Content-Range %q: %v", cr, err)
		reader.go#L358: 				return n, fmt.Errorf("storage: bad CRC on read: got %d, want %d",
		storage.go#L59: 	errMethodNotValid = fmt.Errorf("storage: HTTP method should be one of %v", reflect.ValueOf(signedURLMethods).MapKeys())
		storage.go#L119: 		return nil, fmt.Errorf("dialing: %v", err)
		storage.go#L123: 		return nil, fmt.Errorf("storage client: %v", err)
		storage.go#L135: 			return nil, fmt.Errorf("supplied endpoint %v is not valid: %v", ep, err)
		storage.go#L1017: 		return fmt.Errorf("storage: object name %q is not valid UTF-8", o.object)
		storage.go#L1265: 		return 0, fmt.Errorf("storage: %q does not encode a 32-bit value", d)
		storage.go#L1347: 			return fmt.Errorf("storage: attr %v is not valid", attr)
		storage.go#L1412: 		return fmt.Errorf("storage: %s: empty conditions", method)
		storage.go#L1415: 		return fmt.Errorf("storage: %s: multiple conditions specified for generation", method)
		storage.go#L1418: 		return fmt.Errorf("storage: %s: multiple conditions specified for metageneration", method)
		storage.go#L1447: 			return fmt.Errorf("storage: %s: generation not supported", method)
		storage.go#L1459: 			return fmt.Errorf("storage: %s: ifGenerationMatch not supported", method)
		storage.go#L1463: 			return fmt.Errorf("storage: %s: ifGenerationNotMatch not supported", method)
		storage.go#L1467: 			return fmt.Errorf("storage: %s: DoesNotExist not supported", method)
		storage.go#L1473: 			return fmt.Errorf("storage: %s: ifMetagenerationMatch not supported", method)
		storage.go#L1477: 			return fmt.Errorf("storage: %s: ifMetagenerationNotMatch not supported", method)
		writer.go#L94: 		return fmt.Errorf("storage: Writer.Name %q does not match object name %q", attrs.Name, w.o.object)
		writer.go#L97: 		return fmt.Errorf("storage: object name %q is not valid UTF-8", attrs.Name)

	compress/flate
		deflate.go#L606: 		return fmt.Errorf("flate: invalid compression level %d: want value in range [-2, 9]", level)

	compress/gzip
		gzip.go#L62: 		return nil, fmt.Errorf("gzip: invalid compression level: %d", level)

	compress/zlib
		writer.go#L66: 		return nil, fmt.Errorf("zlib: invalid compression level: %d", level)

	contrib.go.opencensus.io/exporter/prometheus
		prometheus.go#L79: 			c.opts.onError(fmt.Errorf("cannot register the collector: %v", err))
		prometheus.go#L248: 		return nil, fmt.Errorf("aggregation %T is not yet supported", metric.Descriptor.Type)
		prometheus.go#L264: 	return fmt.Errorf("point type %T does not match metric type", point)

	contrib.go.opencensus.io/exporter/stackdriver
		metrics.go#L133: 	return fmt.Errorf("[%s]", strings.Join(errMsgs, "; "))
		metrics.go#L200: 		return nil, fmt.Errorf("length mismatch: len(labelKeys)=%d len(labelValues)=%d", len(labelKeys), len(labelValues))
		metrics.go#L415: 		err = fmt.Errorf("protoToMetricPoint: unknown Data type: %T", pt.Value)
		metrics_batcher.go#L123: 	return fmt.Errorf("[%s]", strings.Join(errMsgs, "; "))
		metrics_proto.go#L281: 		return nil, fmt.Errorf("length mismatch: len(labelKeys)=%d len(labelValues)=%d", len(labelKeys), len(labelValues))
		metrics_proto.go#L475: 		return nil, fmt.Errorf("protoToMetricPoint: unknown Data type: %T", value)
		stackdriver.go#L315: 			return nil, fmt.Errorf("stackdriver: %v", err)
		stackdriver.go#L327: 				err = fmt.Errorf("setting Stackdriver default location failed: %s", err)
		stackdriver.go#L352: 			return nil, fmt.Errorf("stackdriver: detect resource: %s", err)
		stats.go#L304: 		return nil, fmt.Errorf("unsupported aggregation type: %s", agg.Type.String())
		trace.go#L56: 		return nil, fmt.Errorf("stackdriver: couldn't initialize trace client: %v", err)

	crypto/tls
		auth.go#L27: 			return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
		auth.go#L35: 			return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
		auth.go#L43: 			return fmt.Errorf("expected an RSA public key, got %T", pubkey)
		auth.go#L51: 			return fmt.Errorf("expected an RSA public key, got %T", pubkey)
		auth.go#L109: 		return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
		auth.go#L123: 		return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
		auth.go#L142: 		return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
		auth.go#L144: 		return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
		auth.go#L256: 		return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
		auth.go#L259: 		return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
		auth.go#L264: 		return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
		auth.go#L275: 			return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
		auth.go#L278: 		return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
		auth.go#L281: 		return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
		auth.go#L285: 		return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
		auth.go#L288: 	return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
		common.go#L1088: 			return fmt.Errorf("failed to parse certificate: %w", err)
		common.go#L1091: 			return fmt.Errorf("certificate is not valid for requested server name: %w", err)
		common.go#L1237: 				return fmt.Errorf("failed to parse certificate #%d in the chain: %w", j, err)
		common.go#L1504: 	return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
		conn.go#L1017: 		return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake))
		conn.go#L1224: 		return fmt.Errorf("tls: received unexpected handshake message of type %T", msg)
		conn.go#L1331: 			alertErr = fmt.Errorf("tls: failed to send closeNotify alert (but connection was closed anyway): %w", err)
		handshake_client.go#L358: 		return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
		handshake_client.go#L592: 			return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
		handshake_client.go#L859: 		return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", certs[0].PublicKey)
		handshake_messages.go#L27: 			return fmt.Errorf("invalid value length: expected %d, got %d", n, len(v))
		handshake_server.go#L158: 		return nil, fmt.Errorf("tls: client offered only unsupported versions: %x", clientVersions)
		handshake_server.go#L257: 			return fmt.Errorf("tls: unsupported signing key type (%T)", priv.Public())
		handshake_server.go#L266: 			return fmt.Errorf("tls: unsupported decryption key type (%T)", priv.Public())
		handshake_server.go#L817: 			return fmt.Errorf("tls: client certificate contains an unsupported public key of type %T", certs[0].PublicKey)
		key_agreement.go#L178: 		return nil, fmt.Errorf("tls: certificate private key of type %T does not implement crypto.Signer", cert.PrivateKey)
		prf.go#L259: 			return nil, fmt.Errorf("crypto/tls: reserved ExportKeyingMaterial label: %s", label)
		prf.go#L273: 				return nil, fmt.Errorf("crypto/tls: ExportKeyingMaterial context too long")
		tls.go#L301: 		return fail(fmt.Errorf("tls: failed to find \"CERTIFICATE\" PEM block in certificate input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
		tls.go#L315: 			return fail(fmt.Errorf("tls: failed to find PEM block with type ending in \"PRIVATE KEY\" in key input after skipping PEM blocks of the following types: %v", skippedBlockTypes))

	crypto/x509
		pkcs8.go#L70: 			return nil, fmt.Errorf("x509: invalid Ed25519 private key: %v", err)
		pkcs8.go#L73: 			return nil, fmt.Errorf("x509: invalid Ed25519 private key length: %d", l)
		pkcs8.go#L78: 		return nil, fmt.Errorf("x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
		pkcs8.go#L127: 			return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
		pkcs8.go#L132: 		return nil, fmt.Errorf("x509: unknown key type while marshaling PKCS#8: %T", key)
		sec1.go#L80: 		return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
		verify.go#L421: 			return false, fmt.Errorf("x509: internal error: cannot parse constraint %q", constraint)
		verify.go#L442: 		return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
		verify.go#L455: 		return false, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
		verify.go#L484: 		return false, fmt.Errorf("x509: internal error: cannot parse domain %q", domain)
		verify.go#L500: 		return false, fmt.Errorf("x509: internal error: cannot parse domain %q", constraint)
		verify.go#L638: 					return fmt.Errorf("x509: cannot parse rfc822Name %q", mailbox)
		verify.go#L651: 					return fmt.Errorf("x509: cannot parse dnsName %q", name)
		verify.go#L665: 					return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", name)
		verify.go#L678: 					return fmt.Errorf("x509: internal error: IP SAN %x failed to parse", data)
		verify.go#L767: 			return nil, fmt.Errorf("crypto/x509: error fetching intermediate: %w", err)
		x509.go#L104: 		return nil, pkix.AlgorithmIdentifier{}, fmt.Errorf("x509: unsupported public key type: %T", pub)
		x509.go#L807: 	return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
		x509.go#L1085: 				return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
		x509.go#L1089: 					return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
		x509.go#L1174: 				return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
		x509.go#L1200: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
		x509.go#L1218: 					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
		x509.go#L1222: 					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
		x509.go#L1237: 						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
		x509.go#L1246: 						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
		x509.go#L1258: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
		x509.go#L1270: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
		x509.go#L1682: 			return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
		x509.go#L2248: 			return nil, fmt.Errorf("x509: signature over certificate returned by signer is invalid: %w", err)

	database/sql
		convert.go#L37: 	return fmt.Errorf("name %q does not begin with a letter", name)
		convert.go#L69: 			return fmt.Errorf("non-subset type %T returned from Value", sv)
		convert.go#L88: 		return fmt.Errorf("driver ColumnConverter error converted %T to unsupported type %T", arg, nv.Value)
		convert.go#L194: 			return nil, fmt.Errorf("sql: converting argument %s type: %v", describeNamedValue(nv), err)
		convert.go#L201: 		return nil, fmt.Errorf("sql: expected %d arguments, got %d", want, len(nvargs))
		convert.go#L431: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L437: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L443: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L449: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L455: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L461: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L467: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L479: 	return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
		sql.go#L767: 		return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
		sql.go#L3141: 		return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", len(rs.lastcols), len(dest))
		sql.go#L3146: 			return fmt.Errorf(`sql: Scan error on column index %d, name %q: %w`, i, rs.rowsi.Columns()[i], err)

	database/sql/driver
		types.go#L70: 			return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
		types.go#L76: 			return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
		types.go#L88: 		return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
		types.go#L94: 		return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
		types.go#L97: 	return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
		types.go#L114: 			return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
		types.go#L120: 			return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
		types.go#L126: 			return nil, fmt.Errorf("sql/driver: value %q can't be converted to int32", v)
		types.go#L130: 	return nil, fmt.Errorf("sql/driver: unsupported value %v (type %T) converting to int32", v, v)
		types.go#L170: 		return nil, fmt.Errorf("nil value not allowed")
		types.go#L248: 			return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
		types.go#L273: 			return nil, fmt.Errorf("uint64 values with high bit set are not supported")
		types.go#L285: 		return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
		types.go#L289: 	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())

	encoding/asn1
		asn1.go#L353: 		err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
		asn1.go#L376: 		err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
		marshal.go#L581: 		return nil, fmt.Errorf("asn1: cannot marshal nil value")

	encoding/gob
		error.go#L24: 	error_(fmt.Errorf("gob: "+format, args...))

	encoding/json
		decode.go#L722: 								d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
		decode.go#L738: 				d.saveError(fmt.Errorf("json: unknown field %q", key))
		decode.go#L762: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
		decode.go#L854: 		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L865: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L881: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L895: 			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L908: 			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L914: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L932: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L953: 				return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
		decode.go#L967: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L981: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		encode.go#L628: 			e.error(fmt.Errorf("json: invalid number literal %q", numStr))
		encode.go#L802: 			e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))

	encoding/xml
		marshal.go#L218: 			return fmt.Errorf("xml: EncodeToken of Comment containing --> marker")
		marshal.go#L228: 			return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
		marshal.go#L231: 			return fmt.Errorf("xml: EncodeToken of ProcInst with invalid Target")
		marshal.go#L234: 			return fmt.Errorf("xml: EncodeToken of ProcInst containing ?> marker")
		marshal.go#L245: 			return fmt.Errorf("xml: EncodeToken of Directive containing wrong < or > markers")
		marshal.go#L251: 		return fmt.Errorf("xml: EncodeToken of invalid token type")
		marshal.go#L410: 		return fmt.Errorf("xml: EncodeElement of StartElement with missing name")
		marshal.go#L672: 		return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
		marshal.go#L694: 		return fmt.Errorf("xml: start tag with no name")
		marshal.go#L732: 		return fmt.Errorf("xml: end tag with no name")
		marshal.go#L735: 		return fmt.Errorf("xml: end tag  without start tag", name.Local)
		marshal.go#L739: 			return fmt.Errorf("xml: end tag  does not match start tag <%s>", name.Local, top.Local)
		marshal.go#L741: 		return fmt.Errorf("xml: end tag  in namespace %s does not match start tag <%s> in namespace %s", name.Local, name.Space, top.Local, top.Space)
		marshal.go#L891: 				return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
		marshal.go#L919: 				return fmt.Errorf(`xml: comments must not contain "--"`)
		read.go#L214: 		return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
		typeinfo.go#L167: 			return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
		typeinfo.go#L174: 		return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
		typeinfo.go#L204: 		return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
		typeinfo.go#L209: 			return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
		typeinfo.go#L221: 			return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
		xml.go#L634: 				d.err = fmt.Errorf("xml: unsupported version %q; only version 1.0 is supported", ver)
		xml.go#L640: 					d.err = fmt.Errorf("xml: encoding %q declared but Decoder.CharsetReader is nil", enc)
		xml.go#L645: 					d.err = fmt.Errorf("xml: opening charset %q: %v", enc, err)

	flag
		flag.go#L433: 		return fmt.Errorf("no such flag -%v", name)
		flag.go#L892: 	err := fmt.Errorf(format, a...)

	github.com/andybalholm/cascadia
		parser.go#L107: 		return "", fmt.Errorf("expected identifier, found %c instead", c)
		parser.go#L312: 		return idSelector{}, fmt.Errorf("expected id selector (#id), found EOF instead")
		parser.go#L315: 		return idSelector{}, fmt.Errorf("expected id selector (#id), found '%c' instead", p.s[p.i])
		parser.go#L330: 		return classSelector{}, fmt.Errorf("expected class selector (.class), found EOF instead")
		parser.go#L333: 		return classSelector{}, fmt.Errorf("expected class selector (.class), found '%c' instead", p.s[p.i])
		parser.go#L348: 		return attrSelector{}, fmt.Errorf("expected attribute selector ([attribute]), found EOF instead")
		parser.go#L351: 		return attrSelector{}, fmt.Errorf("expected attribute selector ([attribute]), found '%c' instead", p.s[p.i])
		parser.go#L380: 		return attrSelector{}, fmt.Errorf(`expected equality operator, found "%s" instead`, op)
		parser.go#L409: 		return attrSelector{}, fmt.Errorf("expected ']', found '%c' instead", p.s[p.i])
		parser.go#L417: 		return attrSelector{}, fmt.Errorf("attribute operator %q is not supported", op)
		parser.go#L428: 		return nil, fmt.Errorf("expected pseudoclass selector (:pseudoclass), found EOF instead")
		parser.go#L431: 		return nil, fmt.Errorf("expected attribute selector (:pseudoclass), found '%c' instead", p.s[p.i])
		parser.go#L540: 		return out, fmt.Errorf("unknown pseudoclass or pseudoelement :%s", name)
		parser.go#L596: 		return 0, 0, fmt.Errorf("expected 'odd' or 'even', but found '%s' instead", id)
		selector.go#L35: 		return nil, fmt.Errorf("parsing %q: %d bytes left over", sel, len(sel)-p.i)
		selector.go#L50: 		return nil, fmt.Errorf("parsing %q: %d bytes left over", sel, len(sel)-p.i)

	github.com/aws/aws-sdk-go/aws/csm
		enable.go#L66: 			panic(fmt.Errorf("inconsistent client IDs. %q was expected, but received %q", sender.clientID, clientID))
		enable.go#L70: 			panic(fmt.Errorf("inconsistent URLs. %q was expected, but received %q", sender.url, url))

	github.com/aws/aws-sdk-go/aws/endpoints
		endpoints.go#L101: 		return UnsetSTSEndpoint, fmt.Errorf("unable to resolve the value of STSRegionalEndpoint for %v", s)
		endpoints.go#L150: 			fmt.Errorf("unable to resolve the value of S3UsEast1RegionalEndpoint for %v", s)
		v3model.go#L155: 		return fmt.Errorf("unable to strip quotes from regex, %v", err)
		v3model.go#L160: 		return fmt.Errorf("unable to unmarshal region regex, %v", err)
		v3model.go#L266: 		return ResolvedEndpoint{}, fmt.Errorf("invalid region identifier format provided")

	github.com/aws/aws-sdk-go/aws/session
		env_config.go#L313: 				return cfg, fmt.Errorf("failed to load, %v from env config, %v", k, err)
		env_config.go#L323: 				return cfg, fmt.Errorf("failed to load, %v from env config, %v", k, err)
		env_config.go#L337: 			return envConfig{}, fmt.Errorf(
		session.go#L302: 			return nil, fmt.Errorf("failed to load shared config, %v", err)
		session.go#L307: 			return nil, fmt.Errorf("failed to load environment config, %v", err)
		shared_config.go#L288: 				return fmt.Errorf("failed to load %s from shared config, %s, %v",
		shared_config.go#L297: 				return fmt.Errorf("failed to load %s from shared config, %s, %v",

	github.com/aws/aws-sdk-go/aws/signer/v4
		v4.go#L562: 					return nil, fmt.Errorf("invalid request signature authorization header")
		v4.go#L573: 	return nil, fmt.Errorf("request not signed")
		v4.go#L703: 				return fmt.Errorf("cannot use unseekable request body %T, for signed request with body", ctx.Body)

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L250: 				return fmt.Errorf("unable to encode JSONValue, %v", err)
		build.go#L254: 			return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L128: 		return fmt.Errorf("JSON value is not a structure (%#v)", data)
		unmarshal.go#L186: 		return fmt.Errorf("JSON value is not a list (%#v)", data)
		unmarshal.go#L210: 		return fmt.Errorf("JSON value is not a map (%#v)", data)
		unmarshal.go#L262: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L284: 				return fmt.Errorf("unsupported float time representation: %v", d.String())
		unmarshal.go#L291: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L298: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L301: 		return fmt.Errorf("unsupported JSON value (%v)", data)

	github.com/aws/aws-sdk-go/private/protocol/query
		unmarshal_error.go#L39: 		return fmt.Errorf("unknown error response tag, %v", start)

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L243: 		return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L26: var errValueNotSet = fmt.Errorf("value not set")
		build.go#L152: 							fmt.Errorf("unknown payload type %s", payload.Type()))
		build.go#L303: 			return "", fmt.Errorf("unable to encode JSONValue, %v", err)
		build.go#L306: 		err := fmt.Errorf("unsupported value for param %v (%s)", v.Interface(), v.Type())
		unmarshal.go#L105: 								fmt.Errorf("unknown payload type %s", payload.Type()))
		unmarshal.go#L253: 		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L303: 		return fmt.Errorf("unsupported value for param %s: %v (%s)",
		unmarshal.go#L296: 		return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())

	github.com/evanw/esbuild/internal/config
		config.go#L386: 		return nil, fmt.Errorf("[%s] %q is missing a filter", pluginName, kind)
		config.go#L391: 		return nil, fmt.Errorf("[%s] %q filter is not a valid Go regular expression: %q", pluginName, kind, filter)

	github.com/evanw/esbuild/internal/fs
		fs_real.go#L83: 		return nil, fmt.Errorf("The working directory %q is not an absolute path", fp.cwd)

	github.com/evanw/esbuild/internal/resolver
		dataurl.go#L65: 			return "", fmt.Errorf("Could not decode base64 data: %s", err.Error())
		dataurl.go#L73: 		return "", fmt.Errorf("Could not decode percent-escaped data: %s", err.Error())

	github.com/evanw/esbuild/pkg/api
		serve_other.go#L426: 		return ServeResult{}, fmt.Errorf("Cannot use \"watch\" with \"serve\"")
		serve_other.go#L434: 			return ServeResult{}, fmt.Errorf("Invalid serve path: %s", serveOptions.Servedir)
		serve_other.go#L452: 				return ServeResult{}, fmt.Errorf("Invalid outdir path: %s", buildOptions.Outdir)
		serve_other.go#L458: 				return ServeResult{}, fmt.Errorf("Invalid outdir path: %s", buildOptions.Outfile)
		serve_other.go#L465: 			return ServeResult{}, fmt.Errorf(
		serve_other.go#L470: 			return ServeResult{}, fmt.Errorf(

	github.com/ghodss/yaml
		yaml.go#L18: 		return nil, fmt.Errorf("error marshaling into JSON: %v", err)
		yaml.go#L23: 		return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
		yaml.go#L34: 		return fmt.Errorf("error converting YAML to JSON: %v", err)
		yaml.go#L39: 		return fmt.Errorf("error unmarshaling JSON: %v", err)
		yaml.go#L164: 				return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",

	github.com/go-git/gcfg
		read.go#L60: 		return fmt.Errorf("%s: %s", fset.Position(pos), msg)
		set.go#L60: var errUnsupportedType = fmt.Errorf("unsupported type")
		set.go#L61: var errBlankUnsupported = fmt.Errorf("blank value not supported for type")
		set.go#L221: 		panic(fmt.Errorf("config must be a pointer to a struct"))
		set.go#L238: 			panic(fmt.Errorf("map field for section must have string keys and "+
		set.go#L256: 		panic(fmt.Errorf("field for section must be a map or a struct: "+

	github.com/go-git/gcfg/types
		enum.go#L41: 		return false, fmt.Errorf("failed to parse %s %#q", ep.Type, s)
		int.go#L34: var errIntAmbig = fmt.Errorf("ambiguous integer value; must include '0' prefix")
		scan.go#L17: 		return fmt.Errorf("failed to parse %q as %v: %v", val, t, err)
		scan.go#L19: 		return fmt.Errorf("failed to parse %q as %v: extra characters %q", val, t, string(b))

	github.com/go-git/go-git/v5
		object_walker.go#L63: 		return fmt.Errorf("Getting object %s failed: %v", hash, err)
		object_walker.go#L101: 		return fmt.Errorf("Unknown object %X %s %T\n", obj.ID(), obj.Type(), obj)
		remote.go#L89: 		return fmt.Errorf("remote names don't match: %s != %s", o.RemoteName, r.c.Name)
		remote.go#L756: 		return fmt.Errorf("couldn't find remote ref %q", s.Src())
		remote.go#L804: 		return fmt.Errorf("non-fast-forward update: %s", cmd.Name.String())
		remote.go#L813: 		return fmt.Errorf("non-fast-forward update: %s", cmd.Name.String())
		repository.go#L319: 		return nil, fmt.Errorf(".git file has no %s prefix", prefix)
		repository.go#L390: 		return false, false, fmt.Errorf("path is not a directory: %s", path)
		repository.go#L1092: 		return nil, fmt.Errorf("invalid Order=%v", o.Order)
		repository.go#L1513: 				return &plumbing.ZeroHash, fmt.Errorf(`No commit message match regexp : "%s"`, re.String())
		repository.go#L1580: 		return h, fmt.Errorf("Repository storer is not a storer.PackfileWriter")
		worktree.go#L183: 		return fmt.Errorf("a branch named %q already exists", opts.Branch)
		worktree.go#L226: 			return plumbing.ZeroHash, fmt.Errorf("unsupported tag object target %q", o.TargetType)
		worktree.go#L234: 	return plumbing.ZeroHash, fmt.Errorf("unsupported tag target %q", o.Type())
		worktree.go#L443: 		return fmt.Errorf("invalid HEAD target should be a branch, found %s", branch.Type())

	github.com/go-git/go-git/v5/config
		config.go#L141: 		return nil, fmt.Errorf("LocalScope should be read from the a ConfigStorer.")

	github.com/go-git/go-git/v5/plumbing/filemode
		filemode.go#L78: 			return Empty, fmt.Errorf("no equivalent git mode for %s", m)
		filemode.go#L81: 			return Empty, fmt.Errorf("no equivalent git mode for %s", m)
		filemode.go#L97: 	return Empty, fmt.Errorf("no equivalent git mode for %s", m)
		filemode.go#L187: 	return os.FileMode(0), fmt.Errorf("malformed mode (%s)", m)

	github.com/go-git/go-git/v5/plumbing/format/idxfile
		writer.go#L98: 		return nil, fmt.Errorf("the index still hasn't finished building")

	github.com/go-git/go-git/v5/plumbing/format/packfile
		encoder.go#L177: 		return fmt.Errorf("bad offset for OFS_DELTA entry: %d", relativeOffset)
		scanner.go#L252: 		return fmt.Errorf(
		scanner.go#L330: 		return 0, fmt.Errorf("zlib reset error: %s", err)

	github.com/go-git/go-git/v5/plumbing/object
		change.go#L28: 			fmt.Errorf("malformed change: empty from and to")
		change_adaptor.go#L19: 		return nil, fmt.Errorf("From field: %s", err)
		change_adaptor.go#L23: 		return nil, fmt.Errorf("To field: %s", err)
		change_adaptor.go#L56: 			return nil, fmt.Errorf("change #%d: %s", i, err)
		merge_base.go#L12: var errIsReachable = fmt.Errorf("first is reachable from second")

	github.com/go-git/go-git/v5/plumbing/protocol/packp
		advrefs.go#L187: 			err := fmt.Errorf("bad number of `:` in symref value (%q)", symref)
		advrefs_decode.go#L247: 		return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: no space was found")
		advrefs_decode.go#L249: 		return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: more than one space found")
		report_status.go#L32: 		return fmt.Errorf("unpack error: %s", s.UnpackStatus)
		report_status.go#L86: 		return fmt.Errorf("missing flush")
		report_status.go#L106: 		return fmt.Errorf("premature flush")
		report_status.go#L114: 		return fmt.Errorf("malformed unpack status: %s", line)
		report_status.go#L130: 		return fmt.Errorf("malformed command status: %s", line)
		report_status.go#L154: 	return fmt.Errorf("command error on %s: %s",
		shallowupd.go#L69: 		return plumbing.ZeroHash, fmt.Errorf("malformed %s%q", prefix, line)
		srvresp.go#L90: 		return fmt.Errorf("unexpected flush")
		srvresp.go#L101: 	return fmt.Errorf("unexpected content %q", string(line))
		srvresp.go#L106: 		return fmt.Errorf("malformed ACK %q", line)
		ulreq.go#L114: 		return fmt.Errorf("want can't be empty")
		ulreq.go#L132: 		return fmt.Errorf(msg, capability.Shallow)
		ulreq.go#L139: 				return fmt.Errorf(msg, capability.Shallow)
		ulreq.go#L144: 			return fmt.Errorf(msg, capability.DeepenSince)
		ulreq.go#L148: 			return fmt.Errorf(msg, capability.DeepenNot)
		ulreq.go#L159: 		return fmt.Errorf(msg, capability.Sideband, capability.Sideband64k)
		ulreq.go#L164: 		return fmt.Errorf(msg, capability.MultiACK, capability.MultiACKDetailed)
		ulreq_decode.go#L101: 		d.err = fmt.Errorf("malformed hash: %v", d.line)
		ulreq_decode.go#L217: 		d.err = fmt.Errorf("negative depth")
		ulreq_decode.go#L253: 		d.err = fmt.Errorf("unexpected payload while expecting a flush-pkt: %q", d.line)
		ulreq_encode.go#L39: 		return fmt.Errorf("empty wants provided")
		ulreq_encode.go#L63: 		e.err = fmt.Errorf("encoding first want line: %s", err)
		ulreq_encode.go#L78: 			e.err = fmt.Errorf("encoding want %q: %s", w, err)
		ulreq_encode.go#L98: 			e.err = fmt.Errorf("encoding shallow %q: %s", s, err)
		ulreq_encode.go#L114: 				e.err = fmt.Errorf("encoding depth %d: %s", depth, err)
		ulreq_encode.go#L121: 			e.err = fmt.Errorf("encoding depth %s: %s", when, err)
		ulreq_encode.go#L127: 			e.err = fmt.Errorf("encoding depth %s: %s", reference, err)
		ulreq_encode.go#L131: 		e.err = fmt.Errorf("unsupported depth type")
		ulreq_encode.go#L140: 		e.err = fmt.Errorf("encoding flush-pkt: %s", err)
		updreq_decode.go#L28: 	return fmt.Errorf("malformed request: %s", reason)
		updreq_decode.go#L32: 	return fmt.Errorf("invalid hash size: expected %d, got %d",
		updreq_decode.go#L37: 	return fmt.Errorf("invalid hash: %s", err.Error())
		uppackreq.go#L85: 			return fmt.Errorf("sending haves for %q: %s", have, err)
		uppackreq.go#L93: 			return fmt.Errorf("sending flush-pkt after haves: %s", err)

	github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband
		demux.go#L131: 		return nil, fmt.Errorf("unexpected error: %s", content[1:])
		demux.go#L133: 		return nil, fmt.Errorf("unknown channel %s", content)

	github.com/go-git/go-git/v5/plumbing/revlist
		revlist.go#L109: 		return fmt.Errorf("object type not valid: %s. "+

	github.com/go-git/go-git/v5/plumbing/transport
		common.go#L179: 		return nil, plumbing.NewPermanentError(fmt.Errorf(

	github.com/go-git/go-git/v5/plumbing/transport/client
		client.go#L40: 		return nil, fmt.Errorf("unsupported scheme %q", endpoint.Protocol)
		client.go#L44: 		return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", endpoint.Protocol)

	github.com/go-git/go-git/v5/plumbing/transport/file
		server.go#L25: 		return fmt.Errorf("error creating session: %s", err)
		server.go#L43: 		return fmt.Errorf("error creating session: %s", err)

	github.com/go-git/go-git/v5/plumbing/transport/http
		upload_pack.go#L111: 		return nil, fmt.Errorf("sending upload-req message: %s", err)
		upload_pack.go#L115: 		return nil, fmt.Errorf("sending haves message: %s", err)

	github.com/go-git/go-git/v5/plumbing/transport/internal/common
		common.go#L381: 		return fmt.Errorf("unknown error: %s", line)
		common.go#L440: 		return fmt.Errorf("sending upload-req message: %s", err)
		common.go#L444: 		return fmt.Errorf("sending haves message: %s", err)
		common.go#L448: 		return fmt.Errorf("sending done message: %s", err)
		common.go#L452: 		return fmt.Errorf("closing input: %s", err)
		common.go#L470: 		return nil, fmt.Errorf("error decoding upload-pack response: %s", err)
		server.go#L49: 		return fmt.Errorf("internal error in advertised references: %s", err)
		server.go#L53: 		return fmt.Errorf("error in advertised references encoding: %s", err)
		server.go#L58: 		return fmt.Errorf("error decoding: %s", err)
		server.go#L64: 			return fmt.Errorf("error in encoding report status %s", err)
		server.go#L69: 		return fmt.Errorf("error in receive pack: %s", err)

	github.com/go-git/go-git/v5/plumbing/transport/server
		server.go#L99: 			return fmt.Errorf("unsupported capability: %s", c)
		server.go#L157: 		return nil, fmt.Errorf("shallow not supported")

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		auth_method.go#L212: 		return nil, fmt.Errorf("error creating SSH agent: %q", err)
		auth_method.go#L294: 		return nil, fmt.Errorf("unable to find any valid known_hosts file, set SSH_KNOWN_HOSTS env variable")

	github.com/go-git/go-git/v5/storage/filesystem/dotgit
		dotgit_setref.go#L77: 			return fmt.Errorf("reference has changed concurrently")

	github.com/go-git/go-git/v5/storage/memory
		storage.go#L15: var ErrUnsupportedObjectType = fmt.Errorf("unsupported object type")
		storage.go#L196: var errNotSupported = fmt.Errorf("Not supported")

	github.com/go-git/go-git/v5/utils/merkletrie
		change.go#L47: 		return Action(0), fmt.Errorf("malformed change: nil from and to")
		difftree.go#L388: 		return fmt.Errorf("bad status from double iterator")
		difftree.go#L424: 		return fmt.Errorf("both dirs are empty but has different hash")
		doubleiter.go#L44: 		return nil, fmt.Errorf("from: %s", err)
		doubleiter.go#L47: 		return nil, fmt.Errorf("from: %s", err)
		doubleiter.go#L51: 		return nil, fmt.Errorf("to: %s", err)
		doubleiter.go#L54: 		return nil, fmt.Errorf("to: %s", err)
		doubleiter.go#L151: 		return comparison{}, fmt.Errorf("from: %s", err)
		doubleiter.go#L156: 		return comparison{}, fmt.Errorf("to: %s", err)

	github.com/go-redis/redis/v8
		cluster.go#L22: var errClusterNoNodes = fmt.Errorf("redis: cluster has no nodes")
		cluster.go#L1397: 		return fmt.Errorf("redis: expected '*', but got line %q", line)
		cluster.go#L1434: 		return fmt.Errorf("redis: Watch requires at least one key")
		cluster.go#L1440: 			err := fmt.Errorf("redis: Watch requires all keys to be in the same slot")
		command.go#L203: 		err := fmt.Errorf("redis: unexpected type=%T for String", val)
		command.go#L218: 		err := fmt.Errorf("redis: unexpected type=%T for Int", val)
		command.go#L233: 		err := fmt.Errorf("redis: unexpected type=%T for Int64", val)
		command.go#L248: 		err := fmt.Errorf("redis: unexpected type=%T for Uint64", val)
		command.go#L267: 		err := fmt.Errorf("redis: unexpected type=%T for Float32", val)
		command.go#L282: 		err := fmt.Errorf("redis: unexpected type=%T for Float64", val)
		command.go#L297: 		err := fmt.Errorf("redis: unexpected type=%T for Bool", val)
		command.go#L575: 			return nil, fmt.Errorf("got %d elements, expected 2", n)
		command.go#L646: 		cmd.err = fmt.Errorf("got %T, wanted int64 or string", v)
		command.go#L1172: 					return nil, fmt.Errorf("got %d, wanted 2", n)
		command.go#L1240: 			return nil, fmt.Errorf("got %d, wanted 4", n)
		command.go#L1267: 						return nil, fmt.Errorf("got %d, wanted 2", n)
		command.go#L1345: 					return nil, fmt.Errorf("got %d, wanted 4", n)
		command.go#L1439: 		return nil, fmt.Errorf("redis: got %d elements in XINFO GROUPS reply,"+
		command.go#L1468: 			return nil, fmt.Errorf("redis: unexpected content %s "+
		command.go#L1567: 			return nil, fmt.Errorf("got %d elements, expected 3", n)
		command.go#L1691: 				err := fmt.Errorf("redis: got %d elements in cluster info, expected at least 2", n)
		command.go#L1712: 					err := fmt.Errorf("got %d elements in cluster info address, expected 2 or 3", n)
		command.go#L1863: 				return nil, fmt.Errorf("got %T, expected string or *GeoLocation", v)
		command.go#L1897: 				return nil, fmt.Errorf("got %d coordinates, expected 2", n)
		command.go#L2050: 		return nil, fmt.Errorf("redis: got %d elements in COMMAND reply, wanted 7", n)
		command.go#L2222: 				err := fmt.Errorf("redis: got %d elements in slowlog get, expected at least 4", n)
		command.go#L2248: 				err := fmt.Errorf("redis: got %d elements commands reply in slowlog get, expected at least 1", cmdLen)
		options.go#L232: 			return nil, fmt.Errorf("invalid redis database number: %q", f[0])
		pubsub.go#L345: 				return nil, fmt.Errorf("redis: unsupported pubsub message payload: %T", payload)
		pubsub.go#L358: 			return nil, fmt.Errorf("redis: unsupported pubsub message: %q", kind)
		pubsub.go#L361: 		return nil, fmt.Errorf("redis: unsupported pubsub message: %#v", reply)
		pubsub.go#L415: 			err := fmt.Errorf("redis: unknown message: %T", msg)
		pubsub.go#L440: 		err := fmt.Errorf("redis: Channel can't be called after ChannelWithSubscriptions")
		pubsub.go#L444: 		err := fmt.Errorf("redis: PubSub.Channel size can not be changed once created")
		pubsub.go#L461: 		err := fmt.Errorf("redis: ChannelWithSubscriptions can't be called after Channel")
		pubsub.go#L465: 		err := fmt.Errorf("redis: PubSub.Channel size can not be changed once created")
		redis.go#L508: 		err := fmt.Errorf("redis: expected '*', but got line %q", line)
		ring.go#L706: 		return fmt.Errorf("redis: Watch requires at least one key")
		ring.go#L722: 		return fmt.Errorf("redis: Watch requires at least one shard")
		ring.go#L728: 				err := fmt.Errorf("redis: Watch requires all keys to be in the same shard")

	github.com/go-redis/redis/v8/internal/pool
		pool_sticky.go#L96: 	return nil, fmt.Errorf("redis: StickyConnPool.Get: infinite loop")
		pool_sticky.go#L167: 		return fmt.Errorf("redis: invalid StickyConnPool state: %d", state)

	github.com/go-redis/redis/v8/internal/proto
		reader.go#L77: 		return nil, fmt.Errorf("redis: invalid reply: %q", b)
		reader.go#L104: 			err := fmt.Errorf("redis: got %.100q, but multi bulk parser is nil", line)
		reader.go#L109: 	return nil, fmt.Errorf("redis: can't parse %.100q", line)
		reader.go#L123: 		return 0, fmt.Errorf("redis: can't parse int reply: %.100q", line)
		reader.go#L142: 		return "", fmt.Errorf("redis: can't parse reply=%.100q reading string", line)
		reader.go#L180: 		return nil, fmt.Errorf("redis: can't parse array reply: %.100q", line)
		reader.go#L195: 		return 0, fmt.Errorf("redis: can't parse array reply: %.100q", line)
		reader.go#L205: 		return nil, 0, fmt.Errorf("redis: got %d elements in scan reply, expected 2", n)
		reader.go#L267: 		return nil, fmt.Errorf("redis: can't parse string reply: %.100q", line)
		scan.go#L14: 		return fmt.Errorf("redis: Scan(nil)")
		scan.go#L105: 		return fmt.Errorf(
		scan.go#L113: 		return fmt.Errorf("redis: ScanSlice(nil)")
		scan.go#L116: 		return fmt.Errorf("redis: ScanSlice(non-pointer %T)", slice)
		scan.go#L120: 		return fmt.Errorf("redis: ScanSlice(non-slice %T)", slice)
		scan.go#L127: 			err = fmt.Errorf("redis: ScanSlice index=%d value=%q failed: %s", i, s, err)
		writer.go#L108: 		return fmt.Errorf(

	github.com/golang-migrate/migrate/v4
		migrate.go#L770: 			return fmt.Errorf("unknown type: %T with value: %+v", r, r)
		migrate.go#L809: 	m.logErr(fmt.Errorf("no migration found for version %d", version))

	github.com/golang-migrate/migrate/v4/database
		driver.go#L16: 	ErrLocked = fmt.Errorf("can't acquire lock")
		driver.go#L94: 		return nil, fmt.Errorf("database driver: unknown driver %v (forgotten import?)", scheme)

	github.com/golang-migrate/migrate/v4/database/postgres
		postgres.go#L30: 	ErrNilConfig      = fmt.Errorf("no config")
		postgres.go#L31: 	ErrNoDatabaseName = fmt.Errorf("no database name")
		postgres.go#L32: 	ErrNoSchema       = fmt.Errorf("no schema")
		postgres.go#L33: 	ErrDatabaseDirty  = fmt.Errorf("database is dirty")
		postgres.go#L137: 		return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)

	github.com/golang-migrate/migrate/v4/source
		driver.go#L83: 		return nil, fmt.Errorf("source driver: invalid URL scheme")
		driver.go#L90: 		return nil, fmt.Errorf("source driver: unknown driver %v (forgotten import?)", u.Scheme)
		parse.go#L10: 	ErrParse = fmt.Errorf("no match")

	github.com/golang-migrate/migrate/v4/source/file
		file.go#L74: 				return nil, fmt.Errorf("unable to parse file %v", fi.Name())

	github.com/golang/protobuf/proto
		deprecated.go#L75: 			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
		deprecated.go#L82: 		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
		extensions.go#L145: 		return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
		extensions.go#L231: 		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType)
		extensions.go#L235: 			return fmt.Errorf("proto: SetExtension called with nil value of type %T", v)
		extensions.go#L244: 		return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
		registry.go#L203: 		panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
		text_decode.go#L734: 			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
		text_decode.go#L740: 			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
		text_decode.go#L754: 			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
		text_decode.go#L760: 			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
		text_decode.go#L766: 			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
		text_decode.go#L770: 	return "", "", fmt.Errorf(`unknown escape \%c`, r)

	github.com/golang/protobuf/ptypes
		any.go#L28: 		return "", fmt.Errorf("message is nil")
		any.go#L35: 		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
		any.go#L97: 		return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
		duration.go#L30: 		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
		duration.go#L35: 			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
		duration.go#L62: 		return fmt.Errorf("duration: %v: seconds out of range", dur)
		duration.go#L65: 		return fmt.Errorf("duration: %v: nanos out of range", dur)
		duration.go#L69: 		return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur)
		timestamp.go#L94: 		return fmt.Errorf("timestamp: %v before 0001-01-01", ts)
		timestamp.go#L97: 		return fmt.Errorf("timestamp: %v after 10000-01-01", ts)
		timestamp.go#L100: 		return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts)

	github.com/google/go-cmp/cmp/cmpopts
		struct_filter.go#L145: 		return nil, fmt.Errorf("name must not be empty")
		struct_filter.go#L158: 		return nil, fmt.Errorf("%v must be a struct", t)
		struct_filter.go#L176: 		return []string{name}, fmt.Errorf("does not exist")

	github.com/google/licensecheck
		license.go#L239: 			return 0, fmt.Errorf("parsing %q: malformed Type", s)
		license.go#L241: 		return 0, fmt.Errorf("parsing %q: unknown Type %q", s, f)
		scan.go#L79: 				return fmt.Errorf("parsing %v: %v", l.ID, err)

	github.com/google/licensecheck/internal/match
		regexp.go#L139: 			return nil, fmt.Errorf("%s: no leading phrases", sub.File())
		regexp.go#L143: 				return nil, fmt.Errorf("%s: invalid pattern: matches empty text", sub.File())
		regexp.go#L147: 					return nil, fmt.Errorf("%s: invalid pattern: matches a single wildcard", sub.File())
		regexp.go#L150: 					return nil, fmt.Errorf("%s: invalid pattern: begins with two wildcards", sub.File())
		regexp.go#L152: 				return nil, fmt.Errorf("%s: invalid pattern: begins with wildcard phrase: __ %s", sub.File(), dict.Words()[p[1]])
		regexp.go#L155: 				return nil, fmt.Errorf("%s: invalid pattern: matches single word %s", sub.File(), dict.Words()[p[0]])
		regexp.go#L158: 				return nil, fmt.Errorf("%s: invalid pattern: begins with wildcard phrase: %s __", sub.File(), dict.Words()[p[0]])
		rematch.go#L362: 			c.err = fmt.Errorf("__%d__ wildcard with no required text following", re.n)
		resyntax.go#L198: 				return nil, reSyntaxError(s, i, fmt.Errorf("(( not at beginning of line"))
		resyntax.go#L208: 				return nil, reSyntaxError(s, i, fmt.Errorf("|| outside (( ))"))
		resyntax.go#L225: 					return nil, reSyntaxError(s, i, fmt.Errorf(")) not at end of line"))
		resyntax.go#L245: 					return nil, reSyntaxError(s, i, fmt.Errorf("?? not preceded by ))"))
		resyntax.go#L249: 				return nil, reSyntaxError(s, i, fmt.Errorf("?? not at end of line"))
		resyntax.go#L305: 		return nil, reSyntaxError(s, len(s), fmt.Errorf("missing )) at end"))
		resyntax.go#L410: 		return fmt.Errorf("unexpected ))")
		resyntax.go#L416: 		return fmt.Errorf("unexpected ))")
		resyntax.go#L427: 		return fmt.Errorf("missing argument to ??")
		resyntax.go#L431: 		return fmt.Errorf("missing argument to ??")

	github.com/google/pprof/profile
		index.go#L40: 			return 0, fmt.Errorf("sample_index %s is outside the range [0..%d]", sampleIndex, len(p.SampleType)-1)
		index.go#L55: 	return 0, fmt.Errorf("sample_index %q must be one of: %v", sampleIndex, sampleTypes(p))
		legacy_java_profile.go#L145: 					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
		legacy_java_profile.go#L150: 					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
		legacy_java_profile.go#L185: 				return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_java_profile.go#L206: 				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
		legacy_java_profile.go#L209: 				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
		legacy_java_profile.go#L216: 					return nil, nil, fmt.Errorf("parsing sample %s: second value must be non-zero", line)
		legacy_java_profile.go#L263: 			return fmt.Errorf("parsing sample %s: %v", line, err)
		legacy_profile.go#L588: 		return nil, 0, nil, fmt.Errorf("unexpected number of sample values: got %d, want 6", len(sampleData))
		legacy_profile.go#L596: 			return fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L600: 			return fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L603: 			return fmt.Errorf("%s count was 0 but %s bytes was %d", label, label, size)
		legacy_profile.go#L627: 		return nil, 0, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L644: 			return nil, fmt.Errorf("failed to parse as hex 64-bit number: %s", s)
		legacy_profile.go#L808: 		return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L812: 		return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L829: 		return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L941: 			return "", nil, fmt.Errorf("malformed sample: %s: %v", line, err)
		merge.go#L41: 		return nil, fmt.Errorf("no profiles to merge")
		merge.go#L460: 		return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
		merge.go#L464: 		return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		merge.go#L469: 			return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		profile.go#L164: 			return nil, fmt.Errorf("decompressing profile: %v", err)
		profile.go#L172: 		return nil, fmt.Errorf("parsing profile: %v", err)
		profile.go#L176: 		return nil, fmt.Errorf("malformed profile: %v", err)
		profile.go#L181: var errUnrecognized = fmt.Errorf("unrecognized profile format")
		profile.go#L182: var errMalformed = fmt.Errorf("malformed profile format")
		profile.go#L183: var errNoData = fmt.Errorf("empty input file")
		profile.go#L184: var errConcatProfile = fmt.Errorf("concatenated profiles detected")
		profile.go#L339: 		return fmt.Errorf("missing sample type information")
		profile.go#L343: 			return fmt.Errorf("profile has nil sample")
		profile.go#L346: 			return fmt.Errorf("mismatch: sample has %d values vs. %d types", len(s.Value), len(p.SampleType))
		profile.go#L350: 				return fmt.Errorf("sample has nil location")
		profile.go#L360: 			return fmt.Errorf("profile has nil mapping")
		profile.go#L363: 			return fmt.Errorf("found mapping with reserved ID=0")
		profile.go#L366: 			return fmt.Errorf("multiple mappings with same id: %d", m.ID)
		profile.go#L373: 			return fmt.Errorf("profile has nil function")
		profile.go#L376: 			return fmt.Errorf("found function with reserved ID=0")
		profile.go#L379: 			return fmt.Errorf("multiple functions with same id: %d", f.ID)
		profile.go#L386: 			return fmt.Errorf("profile has nil location")
		profile.go#L389: 			return fmt.Errorf("found location with reserved id=0")
		profile.go#L392: 			return fmt.Errorf("multiple locations with same id: %d", l.ID)
		profile.go#L397: 				return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
		profile.go#L403: 				return fmt.Errorf("location id: %d has a line with nil function", l.ID)
		profile.go#L406: 				return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
		profile.go#L730: 		return fmt.Errorf("mismatched scale ratios, got %d, want %d", len(ratios), len(p.SampleType))
		proto.go#L241: 		return nil, fmt.Errorf("unknown wire type: %d", b.typ)
		prune.go#L127: 			return fmt.Errorf("failed to compile regexp %s: %v", p.DropFrames, err)
		prune.go#L131: 				return fmt.Errorf("failed to compile regexp %s: %v", p.KeepFrames, err)

	github.com/google/safehtml
		script.go#L69: 		return Script{}, fmt.Errorf("variable name %q is an invalid Javascript identifier", string(name))
		stylesheet.go#L50: 		return StyleSheet{}, fmt.Errorf("selector %q contains '<'", selector)
		stylesheet.go#L54: 		return StyleSheet{}, fmt.Errorf("selector %q contains %q, which is disallowed outside of CSS strings", selector, matches[0])
		stylesheet.go#L57: 		return StyleSheet{}, fmt.Errorf("selector %q contains unbalanced () or [] brackets", selector)
		trustedresourceurl.go#L127: 		return TrustedResourceURL{}, fmt.Errorf("%q is a disallowed TrustedResourceURL format string", format)
		trustedresourceurl.go#L136: 				err = fmt.Errorf("expected argument named %q", argName)
		trustedresourceurl.go#L143: 			err = fmt.Errorf(`argument %q with value %q must not contain ".."`, argName, argVal)
		trustedresourceurl.go#L185: 		return TrustedResourceURL{}, fmt.Errorf("cannot append to TrustedResourceURL %q because it has an unsafe prefix", t)

	github.com/google/safehtml/template
		escape.go#L847: 			return fmt.Errorf("Missing closing ` in JS template")
		escape.go#L869: 			return fmt.Errorf("Missing closing } in JS template")
		sanitize.go#L18: 		return nil, fmt.Errorf("actions must not affect element or attribute names")
		sanitize.go#L30: 			return nil, fmt.Errorf("unquoted attribute values disallowed")
		sanitize.go#L74: 				return nil, fmt.Errorf(`conditional branch with {element=%q, attribute=%q} results in sanitization error: %s`, elem, attr, err)
		sanitize.go#L81: 				return nil, fmt.Errorf(
		sanitize.go#L88: 		return nil, fmt.Errorf("partial substitutions are disallowed in the %q attribute value context of a %q element", c.attr.name, c.element.name)
		sanitize.go#L92: 			return nil, fmt.Errorf("action cannot be interpolated into the %q attribute value of this %q element: %s", c.attr.name, c.element.name, err)
		sanitize.go#L113: 		return nil, fmt.Errorf("actions must not occur after an ambiguous URL prefix in the %q attribute value context of a %q element", c.attr.name, c.element.name)
		sanitize.go#L117: 		return nil, fmt.Errorf("cannot validate attribute value prefix %q in the %q sanitization context", c.attr.value, sc0)
		sanitize.go#L120: 		return nil, fmt.Errorf("action cannot be interpolated into the %q URL attribute value of this %q element: %s", c.attr.name, c.element.name, err)
		sanitize.go#L176: 	return 0, fmt.Errorf("actions must not occur in the %q attribute value context of a %q element", attr, element)
		sanitize.go#L195: 		return fmt.Errorf(`prefix %q ends with an incomplete HTML character reference; did you mean "&" instead of "&"?`, prefix)
		sanitize.go#L226: 			return "", fmt.Errorf(`conditional branch with element %q results in sanitization error: %s`, elem, err)
		sanitize.go#L234: 				fmt.Errorf(`conditional branches end in different element content sanitization contexts: element %q has sanitization context %q, element %q has sanitization context %q`,
		sanitize.go#L245: 		return 0, fmt.Errorf("actions must not occur in the element content context of a %q element", element)
		sanitizers.go#L502: 	return "", fmt.Errorf(`expected one of the following strings: ["async"]`)
		sanitizers.go#L516: 	return "", fmt.Errorf(`expected one of the following strings: ["auto" "ltr" "rtl"]`)
		sanitizers.go#L535: 	return "", fmt.Errorf(`expected a safehtml.HTML value`)
		sanitizers.go#L544: 	return "", fmt.Errorf(`expected a safehtml.Identifier value`)
		sanitizers.go#L557: 	return "", fmt.Errorf(`expected one of the following strings: ["eager" "lazy"]`)
		sanitizers.go#L571: 	return "", fmt.Errorf(`expected a safehtml.Script value`)
		sanitizers.go#L580: 	return "", fmt.Errorf(`expected a safehtml.Style value`)
		sanitizers.go#L589: 	return "", fmt.Errorf(`expected a safehtml.StyleSheet value`)
		sanitizers.go#L602: 	return "", fmt.Errorf(`expected one of the following strings: ["_blank" "_self"]`)
		sanitizers.go#L611: 	return "", fmt.Errorf(`expected a safehtml.TrustedResourceURL value`)
		template.go#L37: var errEscapeOK = fmt.Errorf("template escaped correctly")
		template.go#L96: 		return fmt.Errorf("html/template: cannot Parse after Execute")
		template.go#L108: 			return fmt.Errorf("template: %q is an incomplete or empty template", t.Name())
		template.go#L201: 		return nil, fmt.Errorf("html/template: %q is undefined", name)
		template.go#L207: 		return nil, fmt.Errorf("html/template: %q is an incomplete template", name)
		template.go#L296: 		return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
		template.go#L315: 			return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
		template.go#L529: 		return nil, fmt.Errorf("html/template: no files named in call to ParseFiles")
		template.go#L633: 		return nil, fmt.Errorf("html/template: pattern matches no files: %#q", pattern)
		trustedsource.go#L58: 		return TrustedSource{}, fmt.Errorf("filename %q must not contain the separator %q", filename, filename[i])
		trustedsource.go#L61: 		return TrustedSource{}, fmt.Errorf("filename must not be the special name %q", filename)
		url.go#L49: 			return fmt.Errorf("URL prefix %q contains an unsafe scheme", prefix)
		url.go#L56: 		return fmt.Errorf("URL prefix %q is unsafe; it might be interpreted as part of a scheme", prefix)
		url.go#L74: 		return fmt.Errorf("%q is a disallowed TrustedResourceURL prefix", prefix)
		url.go#L97: 		return "", fmt.Errorf("URL prefix %q contains whitespace or control characters", prefix)
		url.go#L100: 		return "", fmt.Errorf("URL %s", err)
		url.go#L106: 		return "", fmt.Errorf("URL prefix %q contains whitespace or control characters", prefix)
		url.go#L109: 		return "", fmt.Errorf("URL prefix %q ends with an incomplete percent-encoding character triplet", prefix)
		url.go#L119: 		return "", fmt.Errorf(`cannot substitute %q after TrustedResourceURL prefix: ".." is disallowed`, input)

	github.com/imdario/mergo
		map.go#L114: 				return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)
		merge.go#L89: 		err = fmt.Errorf("cannot append two different types (%s, %s)", src.Kind(), dst.Kind())
		merge.go#L178: 				return dst, fmt.Errorf("cannot override two slices with different type (%s, %s)", src.Type(), dst.Type())
		merge.go#L183: 				err = fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
		merge.go#L318: 		return fmt.Errorf("cannot set dst, needs reference")

	github.com/jackc/pgconn
		auth_scram.go#L195: 		return fmt.Errorf("invalid SCRAM salt received from server: %w", err)
		auth_scram.go#L200: 		return fmt.Errorf("invalid SCRAM iteration count received from server: %w", err)
		config.go#L412: 			return nil, fmt.Errorf("failed to split host:port in '%s', err: %w", host, err)
		config.go#L517: 		return nil, fmt.Errorf("failed to read service file: %v", servicefilePath)
		config.go#L522: 		return nil, fmt.Errorf("unable to find service: %v", serviceName)
		config.go#L620: 			return nil, fmt.Errorf("unable to read CA file: %w", err)
		config.go#L638: 			return nil, fmt.Errorf("unable to read cert: %w", err)
		pgconn.go#L1052: 		result.concludeCommand(nil, fmt.Errorf("extended protocol limited to %v parameters", math.MaxUint16))

	github.com/jackc/pgproto3/v2
		backend.go#L90: 		return nil, fmt.Errorf("unknown startup message code: %d", code)
		backend.go#L132: 		return nil, fmt.Errorf("unknown message type: %c", b.msgType)
		frontend.go#L141: 		return nil, fmt.Errorf("unknown message type: %c", f.msgType)
		frontend.go#L178: 		return nil, fmt.Errorf("unknown authentication type: %d", authType)
		startup_message.go#L34: 		return fmt.Errorf("Bad startup message version number. Expected %d, got %d", ProtocolVersionNumber, dst.ProtocolVersion)
		startup_message.go#L57: 				return fmt.Errorf("Bad startup message last byte. Expected 0, got %d", src[rp])

	github.com/jackc/pgservicefile
		pgservicefile.go#L63: 				return nil, fmt.Errorf("unable to parse line %d", lineNum)

	github.com/jackc/pgtype
		aclitem.go#L51: 		return fmt.Errorf("cannot convert %v to ACLItem", value)
		aclitem.go#L79: 			return fmt.Errorf("unable to assign to %T", dst)
		aclitem.go#L85: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		aclitem.go#L125: 	return fmt.Errorf("cannot scan %T", src)
		aclitem_array.go#L96: 			return fmt.Errorf("cannot find dimensions of %v for ACLItemArray", src)
		aclitem_array.go#L106: 			return fmt.Errorf("cannot convert %v to ACLItemArray", src)
		aclitem_array.go#L137: 			return fmt.Errorf("cannot convert %v to ACLItemArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		aclitem_array.go#L155: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		aclitem_array.go#L168: 		return 0, fmt.Errorf("cannot convert all values to ACLItemArray")
		aclitem_array.go#L171: 		return 0, fmt.Errorf("%v in ACLItemArray", err)
		aclitem_array.go#L233: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		aclitem_array.go#L248: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		aclitem_array.go#L256: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		aclitem_array.go#L272: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		aclitem_array.go#L290: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		aclitem_array.go#L293: 		return 0, fmt.Errorf("cannot assign all values from ACLItemArray")
		aclitem_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from ACLItemArray")
		aclitem_array.go#L414: 	return fmt.Errorf("cannot scan %T", src)
		array.go#L33: 		return 0, fmt.Errorf("array header too short: %d", len(src))
		array.go#L51: 		return 0, fmt.Errorf("array header too short for %d dimensions: %d", numDims, len(src))
		array.go#L98: 		return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L110: 				return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L116: 				return nil, fmt.Errorf("invalid array, expected '[' or '=' got %v", r)
		array.go#L121: 				return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L126: 				return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L130: 				return nil, fmt.Errorf("invalid array, expected ':' got %v", r)
		array.go#L135: 				return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L140: 				return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L144: 				return nil, fmt.Errorf("invalid array, expected ']' got %v", r)
		array.go#L152: 			return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L157: 		return nil, fmt.Errorf("invalid array, expected '{': %v", err)
		array.go#L166: 			return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L183: 			return nil, fmt.Errorf("invalid array: %v", err)
		array.go#L202: 				return nil, fmt.Errorf("invalid array value: %v", err)
		array.go#L219: 		return nil, fmt.Errorf("unexpected trailing data: %v", buf.String())
		array_type.go#L61: 		return fmt.Errorf("cannot set non-slice")
		array_type.go#L103: 		return fmt.Errorf("cannot assign to non-pointer")
		array_type.go#L110: 		return fmt.Errorf("cannot assign to pointer to non-slice")
		array_type.go#L135: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		array_type.go#L339: 	return fmt.Errorf("cannot scan %T", src)
		bool.go#L53: 		return fmt.Errorf("cannot convert %v to Bool", value)
		bool.go#L81: 			return fmt.Errorf("unable to assign to %T", dst)
		bool.go#L87: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		bool.go#L97: 		return fmt.Errorf("invalid length for bool: %v", len(src))
		bool.go#L111: 		return fmt.Errorf("invalid length for bool: %v", len(src))
		bool.go#L171: 	return fmt.Errorf("cannot scan %T", src)
		bool_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for BoolArray", src)
		bool_array.go#L109: 			return fmt.Errorf("cannot convert %v to BoolArray", src)
		bool_array.go#L140: 			return fmt.Errorf("cannot convert %v to BoolArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		bool_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		bool_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to BoolArray")
		bool_array.go#L174: 		return 0, fmt.Errorf("%v in BoolArray", err)
		bool_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		bool_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		bool_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		bool_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		bool_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		bool_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from BoolArray")
		bool_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from BoolArray")
		bool_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "bool")
		bool_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		box.go#L20: 	return fmt.Errorf("cannot convert %v to Box", src)
		box.go#L35: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		box.go#L45: 		return fmt.Errorf("invalid length for Box: %v", len(src))
		box.go#L92: 		return fmt.Errorf("invalid length for Box: %v", len(src))
		box.go#L159: 	return fmt.Errorf("cannot scan %T", src)
		bpchar_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for BPCharArray", src)
		bpchar_array.go#L109: 			return fmt.Errorf("cannot convert %v to BPCharArray", src)
		bpchar_array.go#L140: 			return fmt.Errorf("cannot convert %v to BPCharArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		bpchar_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		bpchar_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to BPCharArray")
		bpchar_array.go#L174: 		return 0, fmt.Errorf("%v in BPCharArray", err)
		bpchar_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		bpchar_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		bpchar_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		bpchar_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		bpchar_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		bpchar_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from BPCharArray")
		bpchar_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from BPCharArray")
		bpchar_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "bpchar")
		bpchar_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		bytea.go#L38: 		return fmt.Errorf("cannot convert %v to Bytea", value)
		bytea.go#L68: 			return fmt.Errorf("unable to assign to %T", dst)
		bytea.go#L74: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		bytea.go#L86: 		return fmt.Errorf("invalid hex format")
		bytea.go#L150: 	return fmt.Errorf("cannot scan %T", src)
		bytea_array.go#L80: 			return fmt.Errorf("cannot find dimensions of %v for ByteaArray", src)
		bytea_array.go#L90: 			return fmt.Errorf("cannot convert %v to ByteaArray", src)
		bytea_array.go#L121: 			return fmt.Errorf("cannot convert %v to ByteaArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		bytea_array.go#L139: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		bytea_array.go#L152: 		return 0, fmt.Errorf("cannot convert all values to ByteaArray")
		bytea_array.go#L155: 		return 0, fmt.Errorf("%v in ByteaArray", err)
		bytea_array.go#L208: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		bytea_array.go#L223: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		bytea_array.go#L231: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		bytea_array.go#L247: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		bytea_array.go#L265: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		bytea_array.go#L268: 		return 0, fmt.Errorf("cannot assign all values from ByteaArray")
		bytea_array.go#L272: 		return 0, fmt.Errorf("cannot assign all values from ByteaArray")
		bytea_array.go#L431: 		return nil, fmt.Errorf("unable to find oid for type name %v", "bytea")
		bytea_array.go#L475: 	return fmt.Errorf("cannot scan %T", src)
		cidr_array.go#L119: 			return fmt.Errorf("cannot find dimensions of %v for CIDRArray", src)
		cidr_array.go#L129: 			return fmt.Errorf("cannot convert %v to CIDRArray", src)
		cidr_array.go#L160: 			return fmt.Errorf("cannot convert %v to CIDRArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		cidr_array.go#L178: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		cidr_array.go#L191: 		return 0, fmt.Errorf("cannot convert all values to CIDRArray")
		cidr_array.go#L194: 		return 0, fmt.Errorf("%v in CIDRArray", err)
		cidr_array.go#L265: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		cidr_array.go#L280: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		cidr_array.go#L288: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		cidr_array.go#L304: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		cidr_array.go#L322: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		cidr_array.go#L325: 		return 0, fmt.Errorf("cannot assign all values from CIDRArray")
		cidr_array.go#L329: 		return 0, fmt.Errorf("cannot assign all values from CIDRArray")
		cidr_array.go#L488: 		return nil, fmt.Errorf("unable to find oid for type name %v", "cidr")
		cidr_array.go#L532: 	return fmt.Errorf("cannot scan %T", src)
		circle.go#L21: 	return fmt.Errorf("cannot convert %v to Circle", src)
		circle.go#L36: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		circle.go#L46: 		return fmt.Errorf("invalid length for Circle: %v", len(src))
		circle.go#L82: 		return fmt.Errorf("invalid length for Circle: %v", len(src))
		circle.go#L144: 	return fmt.Errorf("cannot scan %T", src)
		composite_fields.go#L14: 		return fmt.Errorf("cannot decode into empty CompositeFields")
		composite_fields.go#L18: 		return fmt.Errorf("cannot decode unexpected null into CompositeFields")
		composite_fields.go#L36: 		return fmt.Errorf("cannot decode into empty CompositeFields")
		composite_fields.go#L40: 		return fmt.Errorf("cannot decode unexpected null into CompositeFields")
		composite_fields.go#L88: 			return nil, fmt.Errorf("Unknown OID for %#v", f)
		composite_fields.go#L101: 				return nil, fmt.Errorf("Cannot encode binary format for %v", f)
		composite_type.go#L35: 			return nil, fmt.Errorf("no data type registered for oid: %d", fields[i].OID)
		composite_type.go#L41: 			return nil, fmt.Errorf("data type for oid does not implement ValueTranscoder: %d", fields[i].OID)
		composite_type.go#L106: 			return fmt.Errorf("Number of fields don't match. CompositeType has %d fields", len(dst.valueTranscoders))
		composite_type.go#L121: 		return fmt.Errorf("Can not convert %v to Composite", src)
		composite_type.go#L134: 				return fmt.Errorf("Number of fields don't match. CompositeType has %d fields", len(src.valueTranscoders))
		composite_type.go#L143: 					return fmt.Errorf("unable to assign to dst[%d]: %v", i, err)
		composite_type.go#L157: 			return fmt.Errorf("unable to assign to %T", dst)
		composite_type.go#L162: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		composite_type.go#L214: 			return true, fmt.Errorf("unable to assign to field %s: %v", dstElemType.Field(exportedFields[i]).Name, err)
		composite_type.go#L314: 		return &CompositeBinaryScanner{err: fmt.Errorf("Record incomplete %v", src)}
		composite_type.go#L366: 		cfs.err = fmt.Errorf("Record incomplete %v", cfs.src)
		composite_type.go#L377: 			cfs.err = fmt.Errorf("Record incomplete rp=%d src=%v", cfs.rp, cfs.src)
		composite_type.go#L420: 		return &CompositeTextScanner{err: fmt.Errorf("Record incomplete %v", src)}
		composite_type.go#L424: 		return &CompositeTextScanner{err: fmt.Errorf("composite text format must start with '('")}
		composite_type.go#L428: 		return &CompositeTextScanner{err: fmt.Errorf("composite text format must end with ')'")}
		composite_type.go#L547: 		b.err = fmt.Errorf("unknown data type for OID: %d", oid)
		composite_type.go#L559: 		b.err = fmt.Errorf("unable to encode binary for OID: %d", oid)
		composite_type.go#L622: 		b.err = fmt.Errorf("unknown data type for field: %v", field)
		composite_type.go#L634: 		b.err = fmt.Errorf("unable to encode text for value: %v", field)
		convert.go#L214: 				return fmt.Errorf("%d is less than minimum value for int", srcVal)
		convert.go#L216: 				return fmt.Errorf("%d is greater than maximum value for int", srcVal)
		convert.go#L221: 				return fmt.Errorf("%d is less than minimum value for int8", srcVal)
		convert.go#L223: 				return fmt.Errorf("%d is greater than maximum value for int8", srcVal)
		convert.go#L228: 				return fmt.Errorf("%d is less than minimum value for int16", srcVal)
		convert.go#L230: 				return fmt.Errorf("%d is greater than maximum value for int16", srcVal)
		convert.go#L235: 				return fmt.Errorf("%d is less than minimum value for int32", srcVal)
		convert.go#L237: 				return fmt.Errorf("%d is greater than maximum value for int32", srcVal)
		convert.go#L242: 				return fmt.Errorf("%d is less than minimum value for int64", srcVal)
		convert.go#L244: 				return fmt.Errorf("%d is greater than maximum value for int64", srcVal)
		convert.go#L249: 				return fmt.Errorf("%d is less than zero for uint", srcVal)
		convert.go#L251: 				return fmt.Errorf("%d is greater than maximum value for uint", srcVal)
		convert.go#L256: 				return fmt.Errorf("%d is less than zero for uint8", srcVal)
		convert.go#L258: 				return fmt.Errorf("%d is greater than maximum value for uint8", srcVal)
		convert.go#L263: 				return fmt.Errorf("%d is less than zero for uint32", srcVal)
		convert.go#L265: 				return fmt.Errorf("%d is greater than maximum value for uint16", srcVal)
		convert.go#L270: 				return fmt.Errorf("%d is less than zero for uint32", srcVal)
		convert.go#L272: 				return fmt.Errorf("%d is greater than maximum value for uint32", srcVal)
		convert.go#L277: 				return fmt.Errorf("%d is less than zero for uint64", srcVal)
		convert.go#L295: 						return fmt.Errorf("cannot put %d into %T", srcVal, dst)
		convert.go#L301: 						return fmt.Errorf("%d is less than zero for %T", srcVal, dst)
		convert.go#L304: 						return fmt.Errorf("cannot put %d into %T", srcVal, dst)
		convert.go#L310: 			return fmt.Errorf("cannot assign %v into %T", srcVal, dst)
		convert.go#L324: 	return fmt.Errorf("cannot assign %v %v into %T", srcVal, srcStatus, dst)
		convert.go#L352: 			return fmt.Errorf("cannot assign %v into %T", srcVal, dst)
		convert.go#L366: 	return fmt.Errorf("cannot assign %v %v into %T", srcVal, srcStatus, dst)
		date.go#L58: 		return fmt.Errorf("cannot convert %v to Date", value)
		date.go#L84: 				return fmt.Errorf("cannot assign %v to %T", src, dst)
		date.go#L92: 			return fmt.Errorf("unable to assign to %T", dst)
		date.go#L98: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		date.go#L132: 		return fmt.Errorf("invalid length for date: %v", len(src))
		date.go#L216: 	return fmt.Errorf("cannot scan %T", src)
		date_array.go#L100: 			return fmt.Errorf("cannot find dimensions of %v for DateArray", src)
		date_array.go#L110: 			return fmt.Errorf("cannot convert %v to DateArray", src)
		date_array.go#L141: 			return fmt.Errorf("cannot convert %v to DateArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		date_array.go#L159: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		date_array.go#L172: 		return 0, fmt.Errorf("cannot convert all values to DateArray")
		date_array.go#L175: 		return 0, fmt.Errorf("%v in DateArray", err)
		date_array.go#L237: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		date_array.go#L252: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		date_array.go#L260: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		date_array.go#L276: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		date_array.go#L294: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		date_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from DateArray")
		date_array.go#L301: 		return 0, fmt.Errorf("cannot assign all values from DateArray")
		date_array.go#L460: 		return nil, fmt.Errorf("unable to find oid for type name %v", "date")
		date_array.go#L504: 	return fmt.Errorf("cannot scan %T", src)
		daterange.go#L33: 		return fmt.Errorf("cannot convert %v to Daterange", src)
		daterange.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		daterange.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		daterange.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		daterange.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		daterange.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		daterange.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		daterange.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		daterange.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		daterange.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		daterange.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		enum_array.go#L96: 			return fmt.Errorf("cannot find dimensions of %v for EnumArray", src)
		enum_array.go#L106: 			return fmt.Errorf("cannot convert %v to EnumArray", src)
		enum_array.go#L137: 			return fmt.Errorf("cannot convert %v to EnumArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		enum_array.go#L155: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		enum_array.go#L168: 		return 0, fmt.Errorf("cannot convert all values to EnumArray")
		enum_array.go#L171: 		return 0, fmt.Errorf("%v in EnumArray", err)
		enum_array.go#L233: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		enum_array.go#L248: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		enum_array.go#L256: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		enum_array.go#L272: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		enum_array.go#L290: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		enum_array.go#L293: 		return 0, fmt.Errorf("cannot assign all values from EnumArray")
		enum_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from EnumArray")
		enum_array.go#L414: 	return fmt.Errorf("cannot scan %T", src)
		enum_type.go#L82: 		return fmt.Errorf("cannot convert %v to enum %s", value, dst.typeName)
		enum_type.go#L114: 			return fmt.Errorf("unable to assign to %T", dst)
		enum_type.go#L120: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		float4.go#L49: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L56: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L63: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L70: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L77: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L84: 			return fmt.Errorf("%v cannot be exactly represented as float32", value)
		float4.go#L174: 		return fmt.Errorf("cannot convert %v to Float8", value)
		float4.go#L217: 		return fmt.Errorf("invalid length for float4: %v", len(src))
		float4.go#L269: 	return fmt.Errorf("cannot scan %T", src)
		float4_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for Float4Array", src)
		float4_array.go#L109: 			return fmt.Errorf("cannot convert %v to Float4Array", src)
		float4_array.go#L140: 			return fmt.Errorf("cannot convert %v to Float4Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		float4_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		float4_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to Float4Array")
		float4_array.go#L174: 		return 0, fmt.Errorf("%v in Float4Array", err)
		float4_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		float4_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		float4_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		float4_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		float4_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		float4_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from Float4Array")
		float4_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from Float4Array")
		float4_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "float4")
		float4_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		float8.go#L53: 			return fmt.Errorf("%v cannot be exactly represented as float64", value)
		float8.go#L60: 			return fmt.Errorf("%v cannot be exactly represented as float64", value)
		float8.go#L67: 			return fmt.Errorf("%v cannot be exactly represented as float64", value)
		float8.go#L74: 			return fmt.Errorf("%v cannot be exactly represented as float64", value)
		float8.go#L164: 		return fmt.Errorf("cannot convert %v to Float8", value)
		float8.go#L207: 		return fmt.Errorf("invalid length for float4: %v", len(src))
		float8.go#L259: 	return fmt.Errorf("cannot scan %T", src)
		float8_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for Float8Array", src)
		float8_array.go#L109: 			return fmt.Errorf("cannot convert %v to Float8Array", src)
		float8_array.go#L140: 			return fmt.Errorf("cannot convert %v to Float8Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		float8_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		float8_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to Float8Array")
		float8_array.go#L174: 		return 0, fmt.Errorf("%v in Float8Array", err)
		float8_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		float8_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		float8_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		float8_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		float8_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		float8_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from Float8Array")
		float8_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from Float8Array")
		float8_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "float8")
		float8_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		hstore.go#L44: 		return fmt.Errorf("cannot convert %v to Hstore", src)
		hstore.go#L69: 					return fmt.Errorf("cannot decode %#v into %T", src, dst)
		hstore.go#L78: 			return fmt.Errorf("unable to assign to %T", dst)
		hstore.go#L84: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		hstore.go#L116: 		return fmt.Errorf("hstore incomplete %v", src)
		hstore.go#L125: 			return fmt.Errorf("hstore incomplete %v", src)
		hstore.go#L131: 			return fmt.Errorf("hstore incomplete %v", src)
		hstore.go#L137: 			return fmt.Errorf("hstore incomplete %v", src)
		hstore.go#L341: 						err = fmt.Errorf("Invalid character '%c' after '=>', expecting '\"' or 'NULL'", r)
		hstore.go#L344: 					err = fmt.Errorf("Invalid character after '=', expecting '>'")
		hstore.go#L347: 				err = fmt.Errorf("Invalid character '%c' after value, expecting '='", r)
		hstore.go#L384: 				err = fmt.Errorf("Invalid NULL value: 'N%s'", string(nulBuf))
		hstore.go#L396: 					err = fmt.Errorf("Invalid character '%c' after ', ', expecting \"", r)
		hstore.go#L399: 				err = fmt.Errorf("Invalid character '%c' after value, expecting ','", r)
		hstore.go#L433: 	return fmt.Errorf("cannot scan %T", src)
		hstore_array.go#L80: 			return fmt.Errorf("cannot find dimensions of %v for HstoreArray", src)
		hstore_array.go#L90: 			return fmt.Errorf("cannot convert %v to HstoreArray", src)
		hstore_array.go#L121: 			return fmt.Errorf("cannot convert %v to HstoreArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		hstore_array.go#L139: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		hstore_array.go#L152: 		return 0, fmt.Errorf("cannot convert all values to HstoreArray")
		hstore_array.go#L155: 		return 0, fmt.Errorf("%v in HstoreArray", err)
		hstore_array.go#L208: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		hstore_array.go#L223: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		hstore_array.go#L231: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		hstore_array.go#L247: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		hstore_array.go#L265: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		hstore_array.go#L268: 		return 0, fmt.Errorf("cannot assign all values from HstoreArray")
		hstore_array.go#L272: 		return 0, fmt.Errorf("cannot assign all values from HstoreArray")
		hstore_array.go#L431: 		return nil, fmt.Errorf("unable to find oid for type name %v", "hstore")
		hstore_array.go#L475: 	return fmt.Errorf("cannot scan %T", src)
		inet.go#L75: 		return fmt.Errorf("cannot convert %v to Inet", value)
		inet.go#L106: 				return fmt.Errorf("cannot assign %v to %T", src, dst)
		inet.go#L115: 			return fmt.Errorf("unable to assign to %T", dst)
		inet.go#L121: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		inet.go#L159: 		return fmt.Errorf("Received an invalid size for a inet: %d", len(src))
		inet.go#L204: 		return nil, fmt.Errorf("Unexpected IP length: %v", len(src.IPNet.IP))
		inet.go#L236: 	return fmt.Errorf("cannot scan %T", src)
		inet_array.go#L119: 			return fmt.Errorf("cannot find dimensions of %v for InetArray", src)
		inet_array.go#L129: 			return fmt.Errorf("cannot convert %v to InetArray", src)
		inet_array.go#L160: 			return fmt.Errorf("cannot convert %v to InetArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		inet_array.go#L178: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		inet_array.go#L191: 		return 0, fmt.Errorf("cannot convert all values to InetArray")
		inet_array.go#L194: 		return 0, fmt.Errorf("%v in InetArray", err)
		inet_array.go#L265: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		inet_array.go#L280: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		inet_array.go#L288: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		inet_array.go#L304: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		inet_array.go#L322: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		inet_array.go#L325: 		return 0, fmt.Errorf("cannot assign all values from InetArray")
		inet_array.go#L329: 		return 0, fmt.Errorf("cannot assign all values from InetArray")
		inet_array.go#L488: 		return nil, fmt.Errorf("unable to find oid for type name %v", "inet")
		inet_array.go#L532: 	return fmt.Errorf("cannot scan %T", src)
		int2.go#L40: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L45: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L48: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L53: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L58: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L61: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L66: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L71: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L74: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L79: 			return fmt.Errorf("%d is greater than maximum value for Int2", value)
		int2.go#L90: 			return fmt.Errorf("%f is greater than maximum value for Int2", value)
		int2.go#L95: 			return fmt.Errorf("%f is greater than maximum value for Int2", value)
		int2.go#L180: 		return fmt.Errorf("cannot convert %v to Int2", value)
		int2.go#L223: 		return fmt.Errorf("invalid length for int2: %v", len(src))
		int2.go#L263: 			return fmt.Errorf("%d is greater than maximum value for Int2", src)
		int2.go#L266: 			return fmt.Errorf("%d is greater than maximum value for Int2", src)
		int2.go#L278: 	return fmt.Errorf("cannot scan %T", src)
		int2_array.go#L365: 			return fmt.Errorf("cannot find dimensions of %v for Int2Array", src)
		int2_array.go#L375: 			return fmt.Errorf("cannot convert %v to Int2Array", src)
		int2_array.go#L406: 			return fmt.Errorf("cannot convert %v to Int2Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		int2_array.go#L424: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		int2_array.go#L437: 		return 0, fmt.Errorf("cannot convert all values to Int2Array")
		int2_array.go#L440: 		return 0, fmt.Errorf("%v in Int2Array", err)
		int2_array.go#L628: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		int2_array.go#L643: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		int2_array.go#L651: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		int2_array.go#L667: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		int2_array.go#L685: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		int2_array.go#L688: 		return 0, fmt.Errorf("cannot assign all values from Int2Array")
		int2_array.go#L692: 		return 0, fmt.Errorf("cannot assign all values from Int2Array")
		int2_array.go#L851: 		return nil, fmt.Errorf("unable to find oid for type name %v", "int2")
		int2_array.go#L895: 	return fmt.Errorf("cannot scan %T", src)
		int4.go#L45: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L50: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L53: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L58: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L63: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L66: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L71: 			return fmt.Errorf("%d is greater than maximum value for Int4", value)
		int4.go#L82: 			return fmt.Errorf("%f is greater than maximum value for Int4", value)
		int4.go#L87: 			return fmt.Errorf("%f is greater than maximum value for Int4", value)
		int4.go#L172: 		return fmt.Errorf("cannot convert %v to Int4", value)
		int4.go#L215: 		return fmt.Errorf("invalid length for int4: %v", len(src))
		int4.go#L255: 			return fmt.Errorf("%d is greater than maximum value for Int4", src)
		int4.go#L258: 			return fmt.Errorf("%d is greater than maximum value for Int4", src)
		int4.go#L270: 	return fmt.Errorf("cannot scan %T", src)
		int4_array.go#L365: 			return fmt.Errorf("cannot find dimensions of %v for Int4Array", src)
		int4_array.go#L375: 			return fmt.Errorf("cannot convert %v to Int4Array", src)
		int4_array.go#L406: 			return fmt.Errorf("cannot convert %v to Int4Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		int4_array.go#L424: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		int4_array.go#L437: 		return 0, fmt.Errorf("cannot convert all values to Int4Array")
		int4_array.go#L440: 		return 0, fmt.Errorf("%v in Int4Array", err)
		int4_array.go#L628: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		int4_array.go#L643: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		int4_array.go#L651: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		int4_array.go#L667: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		int4_array.go#L685: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		int4_array.go#L688: 		return 0, fmt.Errorf("cannot assign all values from Int4Array")
		int4_array.go#L692: 		return 0, fmt.Errorf("cannot assign all values from Int4Array")
		int4_array.go#L851: 		return nil, fmt.Errorf("unable to find oid for type name %v", "int4")
		int4_array.go#L895: 	return fmt.Errorf("cannot scan %T", src)
		int4range.go#L33: 		return fmt.Errorf("cannot convert %v to Int4range", src)
		int4range.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		int4range.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		int4range.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		int4range.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		int4range.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		int4range.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		int4range.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		int4range.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		int4range.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		int4range.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		int8.go#L49: 			return fmt.Errorf("%d is greater than maximum value for Int8", value)
		int8.go#L54: 			return fmt.Errorf("%d is greater than maximum value for Int8", value)
		int8.go#L57: 			return fmt.Errorf("%d is greater than maximum value for Int8", value)
		int8.go#L62: 			return fmt.Errorf("%d is greater than maximum value for Int8", value)
		int8.go#L73: 			return fmt.Errorf("%f is greater than maximum value for Int8", value)
		int8.go#L78: 			return fmt.Errorf("%f is greater than maximum value for Int8", value)
		int8.go#L163: 		return fmt.Errorf("cannot convert %v to Int8", value)
		int8.go#L206: 		return fmt.Errorf("invalid length for int8: %v", len(src))
		int8.go#L256: 	return fmt.Errorf("cannot scan %T", src)
		int8_array.go#L365: 			return fmt.Errorf("cannot find dimensions of %v for Int8Array", src)
		int8_array.go#L375: 			return fmt.Errorf("cannot convert %v to Int8Array", src)
		int8_array.go#L406: 			return fmt.Errorf("cannot convert %v to Int8Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		int8_array.go#L424: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		int8_array.go#L437: 		return 0, fmt.Errorf("cannot convert all values to Int8Array")
		int8_array.go#L440: 		return 0, fmt.Errorf("%v in Int8Array", err)
		int8_array.go#L628: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		int8_array.go#L643: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		int8_array.go#L651: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		int8_array.go#L667: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		int8_array.go#L685: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		int8_array.go#L688: 		return 0, fmt.Errorf("cannot assign all values from Int8Array")
		int8_array.go#L692: 		return 0, fmt.Errorf("cannot assign all values from Int8Array")
		int8_array.go#L851: 		return nil, fmt.Errorf("unable to find oid for type name %v", "int8")
		int8_array.go#L895: 	return fmt.Errorf("cannot scan %T", src)
		int8range.go#L33: 		return fmt.Errorf("cannot convert %v to Int8range", src)
		int8range.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		int8range.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		int8range.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		int8range.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		int8range.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		int8range.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		int8range.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		int8range.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		int8range.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		int8range.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		interval.go#L49: 		return fmt.Errorf("cannot convert %v to Interval", value)
		interval.go#L78: 			return fmt.Errorf("unable to assign to %T", dst)
		interval.go#L84: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		interval.go#L102: 			return fmt.Errorf("bad interval format")
		interval.go#L118: 			return fmt.Errorf("bad interval format")
		interval.go#L129: 			return fmt.Errorf("bad interval hour format: %s", timeParts[0])
		interval.go#L134: 			return fmt.Errorf("bad interval minute format: %s", timeParts[1])
		interval.go#L141: 			return fmt.Errorf("bad interval second format: %s", secondParts[0])
		interval.go#L148: 				return fmt.Errorf("bad interval decimal format: %s", secondParts[1])
		interval.go#L177: 		return fmt.Errorf("Received an invalid size for a interval: %d", len(src))
		interval.go#L251: 	return fmt.Errorf("cannot scan %T", src)
		json.go#L85: 			return fmt.Errorf("cannot assign non-present status to %T", dst)
		json.go#L169: 	return fmt.Errorf("cannot scan %T", src)
		jsonb.go#L37: 		return fmt.Errorf("jsonb too short")
		jsonb.go#L41: 		return fmt.Errorf("unknown jsonb version number %d", src[0])
		jsonb_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for JSONBArray", src)
		jsonb_array.go#L109: 			return fmt.Errorf("cannot convert %v to JSONBArray", src)
		jsonb_array.go#L140: 			return fmt.Errorf("cannot convert %v to JSONBArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		jsonb_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		jsonb_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to JSONBArray")
		jsonb_array.go#L174: 		return 0, fmt.Errorf("%v in JSONBArray", err)
		jsonb_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		jsonb_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		jsonb_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		jsonb_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		jsonb_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		jsonb_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from JSONBArray")
		jsonb_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from JSONBArray")
		jsonb_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "jsonb")
		jsonb_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		line.go#L20: 	return fmt.Errorf("cannot convert %v to Line", src)
		line.go#L35: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		line.go#L45: 		return fmt.Errorf("invalid length for Line: %v", len(src))
		line.go#L50: 		return fmt.Errorf("invalid format for line")
		line.go#L79: 		return fmt.Errorf("invalid length for Line: %v", len(src))
		line.go#L142: 	return fmt.Errorf("cannot scan %T", src)
		lseg.go#L20: 	return fmt.Errorf("cannot convert %v to Lseg", src)
		lseg.go#L35: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		lseg.go#L45: 		return fmt.Errorf("invalid length for Lseg: %v", len(src))
		lseg.go#L92: 		return fmt.Errorf("invalid length for Lseg: %v", len(src))
		lseg.go#L159: 	return fmt.Errorf("cannot scan %T", src)
		macaddr.go#L54: 		return fmt.Errorf("cannot convert %v to Macaddr", value)
		macaddr.go#L86: 			return fmt.Errorf("unable to assign to %T", dst)
		macaddr.go#L92: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		macaddr.go#L117: 		return fmt.Errorf("Received an invalid size for a macaddr: %d", len(src))
		macaddr.go#L167: 	return fmt.Errorf("cannot scan %T", src)
		macaddr_array.go#L100: 			return fmt.Errorf("cannot find dimensions of %v for MacaddrArray", src)
		macaddr_array.go#L110: 			return fmt.Errorf("cannot convert %v to MacaddrArray", src)
		macaddr_array.go#L141: 			return fmt.Errorf("cannot convert %v to MacaddrArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		macaddr_array.go#L159: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		macaddr_array.go#L172: 		return 0, fmt.Errorf("cannot convert all values to MacaddrArray")
		macaddr_array.go#L175: 		return 0, fmt.Errorf("%v in MacaddrArray", err)
		macaddr_array.go#L237: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		macaddr_array.go#L252: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		macaddr_array.go#L260: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		macaddr_array.go#L276: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		macaddr_array.go#L294: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		macaddr_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from MacaddrArray")
		macaddr_array.go#L301: 		return 0, fmt.Errorf("cannot assign all values from MacaddrArray")
		macaddr_array.go#L460: 		return nil, fmt.Errorf("unable to find oid for type name %v", "macaddr")
		macaddr_array.go#L504: 	return fmt.Errorf("cannot scan %T", src)
		numeric.go#L200: 		return fmt.Errorf("cannot convert %v to Numeric", value)
		numeric.go#L239: 				return fmt.Errorf("%v is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L242: 				return fmt.Errorf("%v is less than minimum value for %T", normalizedInt, *v)
		numeric.go#L251: 				return fmt.Errorf("%v is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L254: 				return fmt.Errorf("%v is less than minimum value for %T", normalizedInt, *v)
		numeric.go#L263: 				return fmt.Errorf("%v is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L266: 				return fmt.Errorf("%v is less than minimum value for %T", normalizedInt, *v)
		numeric.go#L275: 				return fmt.Errorf("%v is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L278: 				return fmt.Errorf("%v is less than minimum value for %T", normalizedInt, *v)
		numeric.go#L287: 				return fmt.Errorf("%v is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L290: 				return fmt.Errorf("%v is less than minimum value for %T", normalizedInt, *v)
		numeric.go#L299: 				return fmt.Errorf("%d is less than zero for %T", normalizedInt, *v)
		numeric.go#L301: 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L310: 				return fmt.Errorf("%d is less than zero for %T", normalizedInt, *v)
		numeric.go#L312: 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L321: 				return fmt.Errorf("%d is less than zero for %T", normalizedInt, *v)
		numeric.go#L323: 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L332: 				return fmt.Errorf("%d is less than zero for %T", normalizedInt, *v)
		numeric.go#L334: 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L343: 				return fmt.Errorf("%d is less than zero for %T", normalizedInt, *v)
		numeric.go#L345: 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
		numeric.go#L352: 			return fmt.Errorf("unable to assign to %T", dst)
		numeric.go#L380: 		return nil, fmt.Errorf("cannot convert %v to integer", dst)
		numeric.go#L438: 		return nil, 0, fmt.Errorf("%s is not a number", str)
		numeric.go#L451: 		return fmt.Errorf("numeric incomplete %v", src)
		numeric.go#L475: 		return fmt.Errorf("numeric incomplete %v", src)
		numeric.go#L496: 				return fmt.Errorf("invalid digitsRead: %d (this can't happen)", digitsRead)
		numeric.go#L698: 	return fmt.Errorf("cannot scan %T", src)
		numeric_array.go#L213: 			return fmt.Errorf("cannot find dimensions of %v for NumericArray", src)
		numeric_array.go#L223: 			return fmt.Errorf("cannot convert %v to NumericArray", src)
		numeric_array.go#L254: 			return fmt.Errorf("cannot convert %v to NumericArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		numeric_array.go#L272: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		numeric_array.go#L285: 		return 0, fmt.Errorf("cannot convert all values to NumericArray")
		numeric_array.go#L288: 		return 0, fmt.Errorf("%v in NumericArray", err)
		numeric_array.go#L404: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		numeric_array.go#L419: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		numeric_array.go#L427: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		numeric_array.go#L443: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		numeric_array.go#L461: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		numeric_array.go#L464: 		return 0, fmt.Errorf("cannot assign all values from NumericArray")
		numeric_array.go#L468: 		return 0, fmt.Errorf("cannot assign all values from NumericArray")
		numeric_array.go#L627: 		return nil, fmt.Errorf("unable to find oid for type name %v", "numeric")
		numeric_array.go#L671: 	return fmt.Errorf("cannot scan %T", src)
		numrange.go#L33: 		return fmt.Errorf("cannot convert %v to Numrange", src)
		numrange.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		numrange.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		numrange.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		numrange.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		numrange.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		numrange.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		numrange.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		numrange.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		numrange.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		numrange.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		oid.go#L23: 		return fmt.Errorf("cannot decode nil into OID")
		oid.go#L37: 		return fmt.Errorf("cannot decode nil into OID")
		oid.go#L41: 		return fmt.Errorf("invalid length: %v", len(src))
		oid.go#L60: 		return fmt.Errorf("cannot scan NULL into %T", src)
		oid.go#L75: 	return fmt.Errorf("cannot scan %T", src)
		path.go#L21: 	return fmt.Errorf("cannot convert %v to Path", src)
		path.go#L36: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		path.go#L46: 		return fmt.Errorf("invalid length for Path: %v", len(src))
		path.go#L89: 		return fmt.Errorf("invalid length for Path: %v", len(src))
		path.go#L98: 		return fmt.Errorf("invalid length for Path with %d points: %v", pointCount, len(src))
		path.go#L189: 	return fmt.Errorf("cannot scan %T", src)
		pgtype.go#L627: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L631: 		return fmt.Errorf("invalid length for int2: %v", len(src))
		pgtype.go#L647: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L651: 		return fmt.Errorf("invalid length for int4: %v", len(src))
		pgtype.go#L667: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L671: 		return fmt.Errorf("invalid length for int8: %v", len(src))
		pgtype.go#L687: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L691: 		return fmt.Errorf("invalid length for int4: %v", len(src))
		pgtype.go#L708: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L712: 		return fmt.Errorf("invalid length for int8: %v", len(src))
		pgtype.go#L741: 		return fmt.Errorf("cannot scan null into %T", dst)
		pgtype.go#L843: 			return fmt.Errorf("unknown oid %d in binary format cannot be scanned into %T", oid, dest)
		pgtype.go#L854: 		return fmt.Errorf("unknown oid %d cannot be scanned into %T", oid, dest)
		pguint32.go#L27: 			return fmt.Errorf("%d is less than minimum value for pguint32", value)
		pguint32.go#L30: 			return fmt.Errorf("%d is greater than maximum value for pguint32", value)
		pguint32.go#L36: 		return fmt.Errorf("cannot convert %v to pguint32", value)
		pguint32.go#L61: 			return fmt.Errorf("cannot assign %v into %T", src, dst)
		pguint32.go#L97: 		return fmt.Errorf("invalid length: %v", len(src))
		pguint32.go#L149: 	return fmt.Errorf("cannot scan %T", src)
		point.go#L30: 	err := fmt.Errorf("cannot convert %v to Point", src)
		point.go#L53: 		return nil, fmt.Errorf("invalid length for point: %v", len(src))
		point.go#L60: 		return nil, fmt.Errorf("invalid format for point")
		point.go#L88: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		point.go#L98: 		return fmt.Errorf("invalid length for point: %v", len(src))
		point.go#L103: 		return fmt.Errorf("invalid format for point")
		point.go#L127: 		return fmt.Errorf("invalid length for point: %v", len(src))
		point.go#L183: 	return fmt.Errorf("cannot scan %T", src)
		polygon.go#L30: 	err := fmt.Errorf("cannot convert %v to Polygon", src)
		polygon.go#L63: 		return p, fmt.Errorf("invalid length for polygon: %v", len(src))
		polygon.go#L85: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		polygon.go#L95: 		return fmt.Errorf("invalid length for Polygon: %v", len(src))
		polygon.go#L137: 		return fmt.Errorf("invalid length for Polygon: %v", len(src))
		polygon.go#L144: 		return fmt.Errorf("invalid length for Polygon with %d points: %v", pointCount, len(src))
		polygon.go#L220: 	return fmt.Errorf("cannot scan %T", src)
		qchar.go#L43: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L48: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L51: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L56: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L61: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L64: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L69: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L74: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L77: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L82: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L87: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L90: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L95: 			return fmt.Errorf("%d is greater than maximum value for QChar", value)
		qchar.go#L108: 		return fmt.Errorf("cannot convert %v to QChar", value)
		qchar.go#L136: 		return fmt.Errorf(`invalid length for "char": %v`, len(src))
		range.go#L43: 		return nil, fmt.Errorf("invalid lower bound: %v", err)
		range.go#L51: 		return nil, fmt.Errorf("missing lower bound, instead got: %v", string(r))
		range.go#L56: 		return nil, fmt.Errorf("invalid lower value: %v", err)
		range.go#L65: 			return nil, fmt.Errorf("invalid lower value: %v", err)
		range.go#L71: 		return nil, fmt.Errorf("missing range separator: %v", err)
		range.go#L74: 		return nil, fmt.Errorf("missing range separator: %v", r)
		range.go#L79: 		return nil, fmt.Errorf("invalid upper value: %v", err)
		range.go#L88: 			return nil, fmt.Errorf("invalid upper value: %v", err)
		range.go#L93: 			return nil, fmt.Errorf("missing upper bound: %v", err)
		range.go#L101: 			return nil, fmt.Errorf("missing upper bound, instead got: %v", string(r))
		range.go#L108: 		return nil, fmt.Errorf("unexpected trailing data: %v", buf.String())
		range.go#L204: 		return nil, fmt.Errorf("range too short: %v", len(src))
		range.go#L212: 			return nil, fmt.Errorf("unexpected trailing bytes parsing empty range: %v", len(src[rp:]))
		range.go#L237: 			return nil, fmt.Errorf("unexpected trailing bytes parsing unbounded range: %v", len(src[rp:]))
		range.go#L243: 		return nil, fmt.Errorf("too few bytes for size: %v", src[rp:])
		range.go#L256: 			return nil, fmt.Errorf("unexpected trailing bytes parsing range: %v", len(src[rp:]))
		range.go#L263: 			return nil, fmt.Errorf("too few bytes for size: %v", src[rp:])
		range.go#L272: 		return nil, fmt.Errorf("unexpected trailing bytes parsing range: %v", len(src[rp:]))
		record.go#L35: 		return fmt.Errorf("cannot convert %v to Record", src)
		record.go#L70: 			return fmt.Errorf("unable to assign to %T", dst)
		record.go#L76: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		record.go#L85: 		return nil, fmt.Errorf("unknown oid while decoding record: %v", fieldOID)
		record.go#L89: 		return nil, fmt.Errorf("no binary decoder registered for: %v", fieldOID)
		text.go#L46: 		return fmt.Errorf("cannot convert %v to Text", value)
		text.go#L78: 			return fmt.Errorf("unable to assign to %T", dst)
		text.go#L84: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		text.go#L140: 	return fmt.Errorf("cannot scan %T", src)
		text_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for TextArray", src)
		text_array.go#L109: 			return fmt.Errorf("cannot convert %v to TextArray", src)
		text_array.go#L140: 			return fmt.Errorf("cannot convert %v to TextArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		text_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		text_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to TextArray")
		text_array.go#L174: 		return 0, fmt.Errorf("%v in TextArray", err)
		text_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		text_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		text_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		text_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		text_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		text_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from TextArray")
		text_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from TextArray")
		text_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "text")
		text_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)
		tid.go#L31: 	return fmt.Errorf("cannot convert %v to TID", src)
		tid.go#L55: 			return fmt.Errorf("unable to assign to %T", dst)
		tid.go#L59: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		tid.go#L69: 		return fmt.Errorf("invalid length for tid: %v", len(src))
		tid.go#L74: 		return fmt.Errorf("invalid format for tid")
		tid.go#L98: 		return fmt.Errorf("invalid length for tid: %v", len(src))
		tid.go#L150: 	return fmt.Errorf("cannot scan %T", src)
		time.go#L54: 		return fmt.Errorf("cannot convert %v to Time", value)
		time.go#L79: 				return fmt.Errorf("%d microseconds cannot be represented as time.Time", src.Microseconds)
		time.go#L96: 			return fmt.Errorf("unable to assign to %T", dst)
		time.go#L102: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		time.go#L115: 		return fmt.Errorf("cannot decode %v into Time", s)
		time.go#L120: 		return fmt.Errorf("cannot decode %v into Time", s)
		time.go#L126: 		return fmt.Errorf("cannot decode %v into Time", s)
		time.go#L132: 		return fmt.Errorf("cannot decode %v into Time", s)
		time.go#L140: 			return fmt.Errorf("cannot decode %v into Time", s)
		time.go#L163: 		return fmt.Errorf("invalid length for time: %v", len(src))
		time.go#L225: 	return fmt.Errorf("cannot scan %T", src)
		timestamp.go#L55: 		return fmt.Errorf("cannot convert %v to Timestamp", value)
		timestamp.go#L81: 				return fmt.Errorf("cannot assign %v to %T", src, dst)
		timestamp.go#L89: 			return fmt.Errorf("unable to assign to %T", dst)
		timestamp.go#L95: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		timestamp.go#L133: 		return fmt.Errorf("invalid length for timestamp: %v", len(src))
		timestamp.go#L162: 		return nil, fmt.Errorf("cannot encode non-UTC time into timestamp")
		timestamp.go#L189: 		return nil, fmt.Errorf("cannot encode non-UTC time into timestamp")
		timestamp.go#L225: 	return fmt.Errorf("cannot scan %T", src)
		timestamp_array.go#L100: 			return fmt.Errorf("cannot find dimensions of %v for TimestampArray", src)
		timestamp_array.go#L110: 			return fmt.Errorf("cannot convert %v to TimestampArray", src)
		timestamp_array.go#L141: 			return fmt.Errorf("cannot convert %v to TimestampArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		timestamp_array.go#L159: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		timestamp_array.go#L172: 		return 0, fmt.Errorf("cannot convert all values to TimestampArray")
		timestamp_array.go#L175: 		return 0, fmt.Errorf("%v in TimestampArray", err)
		timestamp_array.go#L237: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		timestamp_array.go#L252: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		timestamp_array.go#L260: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		timestamp_array.go#L276: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		timestamp_array.go#L294: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		timestamp_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from TimestampArray")
		timestamp_array.go#L301: 		return 0, fmt.Errorf("cannot assign all values from TimestampArray")
		timestamp_array.go#L460: 		return nil, fmt.Errorf("unable to find oid for type name %v", "timestamp")
		timestamp_array.go#L504: 	return fmt.Errorf("cannot scan %T", src)
		timestamptz.go#L57: 		return fmt.Errorf("cannot convert %v to Timestamptz", value)
		timestamptz.go#L83: 				return fmt.Errorf("cannot assign %v to %T", src, dst)
		timestamptz.go#L91: 			return fmt.Errorf("unable to assign to %T", dst)
		timestamptz.go#L97: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		timestamptz.go#L140: 		return fmt.Errorf("invalid length for timestamptz: %v", len(src))
		timestamptz.go#L222: 	return fmt.Errorf("cannot scan %T", src)
		timestamptz_array.go#L100: 			return fmt.Errorf("cannot find dimensions of %v for TimestamptzArray", src)
		timestamptz_array.go#L110: 			return fmt.Errorf("cannot convert %v to TimestamptzArray", src)
		timestamptz_array.go#L141: 			return fmt.Errorf("cannot convert %v to TimestamptzArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		timestamptz_array.go#L159: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		timestamptz_array.go#L172: 		return 0, fmt.Errorf("cannot convert all values to TimestamptzArray")
		timestamptz_array.go#L175: 		return 0, fmt.Errorf("%v in TimestamptzArray", err)
		timestamptz_array.go#L237: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		timestamptz_array.go#L252: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		timestamptz_array.go#L260: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		timestamptz_array.go#L276: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		timestamptz_array.go#L294: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		timestamptz_array.go#L297: 		return 0, fmt.Errorf("cannot assign all values from TimestamptzArray")
		timestamptz_array.go#L301: 		return 0, fmt.Errorf("cannot assign all values from TimestamptzArray")
		timestamptz_array.go#L460: 		return nil, fmt.Errorf("unable to find oid for type name %v", "timestamptz")
		timestamptz_array.go#L504: 	return fmt.Errorf("cannot scan %T", src)
		tsrange.go#L33: 		return fmt.Errorf("cannot convert %v to Tsrange", src)
		tsrange.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		tsrange.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		tsrange.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		tsrange.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		tsrange.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		tsrange.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		tsrange.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		tsrange.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		tsrange.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		tsrange.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		tsrange_array.go#L61: 			return fmt.Errorf("cannot find dimensions of %v for TsrangeArray", src)
		tsrange_array.go#L71: 			return fmt.Errorf("cannot convert %v to TsrangeArray", src)
		tsrange_array.go#L102: 			return fmt.Errorf("cannot convert %v to TsrangeArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		tsrange_array.go#L120: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		tsrange_array.go#L133: 		return 0, fmt.Errorf("cannot convert all values to TsrangeArray")
		tsrange_array.go#L136: 		return 0, fmt.Errorf("%v in TsrangeArray", err)
		tsrange_array.go#L189: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		tsrange_array.go#L204: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		tsrange_array.go#L212: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		tsrange_array.go#L228: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		tsrange_array.go#L246: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		tsrange_array.go#L249: 		return 0, fmt.Errorf("cannot assign all values from TsrangeArray")
		tsrange_array.go#L253: 		return 0, fmt.Errorf("cannot assign all values from TsrangeArray")
		tsrange_array.go#L412: 		return nil, fmt.Errorf("unable to find oid for type name %v", "tsrange")
		tsrange_array.go#L456: 	return fmt.Errorf("cannot scan %T", src)
		tstzrange.go#L33: 		return fmt.Errorf("cannot convert %v to Tstzrange", src)
		tstzrange.go#L51: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		tstzrange.go#L140: 		return nil, fmt.Errorf("unknown lower bound type %v", src.LowerType)
		tstzrange.go#L150: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		tstzrange.go#L161: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		tstzrange.go#L171: 		return nil, fmt.Errorf("unknown upper bound type %v", src.UpperType)
		tstzrange.go#L195: 		return nil, fmt.Errorf("unknown LowerType: %v", src.LowerType)
		tstzrange.go#L205: 		return nil, fmt.Errorf("unknown UpperType: %v", src.UpperType)
		tstzrange.go#L221: 			return nil, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
		tstzrange.go#L236: 			return nil, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
		tstzrange.go#L261: 	return fmt.Errorf("cannot scan %T", src)
		tstzrange_array.go#L61: 			return fmt.Errorf("cannot find dimensions of %v for TstzrangeArray", src)
		tstzrange_array.go#L71: 			return fmt.Errorf("cannot convert %v to TstzrangeArray", src)
		tstzrange_array.go#L102: 			return fmt.Errorf("cannot convert %v to TstzrangeArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		tstzrange_array.go#L120: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		tstzrange_array.go#L133: 		return 0, fmt.Errorf("cannot convert all values to TstzrangeArray")
		tstzrange_array.go#L136: 		return 0, fmt.Errorf("%v in TstzrangeArray", err)
		tstzrange_array.go#L189: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		tstzrange_array.go#L204: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		tstzrange_array.go#L212: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		tstzrange_array.go#L228: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		tstzrange_array.go#L246: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		tstzrange_array.go#L249: 		return 0, fmt.Errorf("cannot assign all values from TstzrangeArray")
		tstzrange_array.go#L253: 		return 0, fmt.Errorf("cannot assign all values from TstzrangeArray")
		tstzrange_array.go#L412: 		return nil, fmt.Errorf("unable to find oid for type name %v", "tstzrange")
		tstzrange_array.go#L456: 	return fmt.Errorf("cannot scan %T", src)
		uuid.go#L34: 				return fmt.Errorf("[]byte must be 16 bytes to convert to UUID: %d", len(value))
		uuid.go#L57: 		return fmt.Errorf("cannot convert %v to UUID", value)
		uuid.go#L97: 	return fmt.Errorf("cannot assign %v into %T", src, dst)
		uuid.go#L109: 		return dst, fmt.Errorf("cannot parse UUID %v", src)
		uuid.go#L133: 		return fmt.Errorf("invalid length for UUID: %v", len(src))
		uuid.go#L152: 		return fmt.Errorf("invalid length for UUID: %v", len(src))
		uuid.go#L198: 	return fmt.Errorf("cannot scan %T", src)
		uuid.go#L227: 		return fmt.Errorf("invalid length for UUID: %v", len(src))
		uuid_array.go#L137: 			return fmt.Errorf("cannot find dimensions of %v for UUIDArray", src)
		uuid_array.go#L147: 			return fmt.Errorf("cannot convert %v to UUIDArray", src)
		uuid_array.go#L178: 			return fmt.Errorf("cannot convert %v to UUIDArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		uuid_array.go#L196: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		uuid_array.go#L209: 		return 0, fmt.Errorf("cannot convert all values to UUIDArray")
		uuid_array.go#L212: 		return 0, fmt.Errorf("%v in UUIDArray", err)
		uuid_array.go#L292: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		uuid_array.go#L307: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		uuid_array.go#L315: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		uuid_array.go#L331: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		uuid_array.go#L349: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		uuid_array.go#L352: 		return 0, fmt.Errorf("cannot assign all values from UUIDArray")
		uuid_array.go#L356: 		return 0, fmt.Errorf("cannot assign all values from UUIDArray")
		uuid_array.go#L515: 		return nil, fmt.Errorf("unable to find oid for type name %v", "uuid")
		uuid_array.go#L559: 	return fmt.Errorf("cannot scan %T", src)
		varbit.go#L18: 	return fmt.Errorf("cannot convert %v to Varbit", src)
		varbit.go#L33: 	return fmt.Errorf("cannot assign %v to %T", src, dst)
		varbit.go#L68: 		return fmt.Errorf("invalid length for varbit: %v", len(src))
		varbit.go#L127: 	return fmt.Errorf("cannot scan %T", src)
		varchar_array.go#L99: 			return fmt.Errorf("cannot find dimensions of %v for VarcharArray", src)
		varchar_array.go#L109: 			return fmt.Errorf("cannot convert %v to VarcharArray", src)
		varchar_array.go#L140: 			return fmt.Errorf("cannot convert %v to VarcharArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount)
		varchar_array.go#L158: 			return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions")
		varchar_array.go#L171: 		return 0, fmt.Errorf("cannot convert all values to VarcharArray")
		varchar_array.go#L174: 		return 0, fmt.Errorf("%v in VarcharArray", err)
		varchar_array.go#L236: 			return fmt.Errorf("cannot assign %T to %T", src, dst)
		varchar_array.go#L251: 			return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
		varchar_array.go#L259: 	return fmt.Errorf("cannot decode %#v into %T", src, dst)
		varchar_array.go#L275: 				return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len())
		varchar_array.go#L293: 		return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension)
		varchar_array.go#L296: 		return 0, fmt.Errorf("cannot assign all values from VarcharArray")
		varchar_array.go#L300: 		return 0, fmt.Errorf("cannot assign all values from VarcharArray")
		varchar_array.go#L459: 		return nil, fmt.Errorf("unable to find oid for type name %v", "varchar")
		varchar_array.go#L503: 	return fmt.Errorf("cannot scan %T", src)

	github.com/jackc/pgx/v4
		conn.go#L143: 			return nil, fmt.Errorf("cannot parse statement_cache_capacity: %w", err)
		conn.go#L156: 			return nil, fmt.Errorf("invalid statement_cache_mod: %s", s)
		conn.go#L172: 			return nil, fmt.Errorf("invalid prefer_simple_protocol: %v", err)
		conn.go#L489: 		return fmt.Errorf("expected %d arguments, got %d", len(sd.ParamOIDs), len(arguments))
		conn.go#L632: 		rows.fatal(fmt.Errorf("expected %d arguments, got %d", len(sd.ParamOIDs), len(args)))
		conn.go#L794: 			return &batchResults{ctx: ctx, conn: c, err: fmt.Errorf("mismatched param and argument count")}
		copy_from.go#L176: 			return false, nil, fmt.Errorf("expected %d values, got %d values", len(ct.columnNames), len(values))
		rows.go#L199: 		err := fmt.Errorf("number of field descriptions must equal number of values, got %d and %d", len(fieldDescriptions), len(values))
		rows.go#L204: 		err := fmt.Errorf("number of field descriptions must equal number of destinations, got %d and %d", len(fieldDescriptions), len(dest))
		rows.go#L329: 		return fmt.Errorf("number of field descriptions must equal number of values, got %d and %d", len(fieldDescriptions), len(values))
		rows.go#L332: 		return fmt.Errorf("number of field descriptions must equal number of destinations, got %d and %d", len(fieldDescriptions), len(dest))
		tx.go#L249: 		tx.conn.die(fmt.Errorf("rollback failed: %w", err))
		values.go#L105: 			return nil, fmt.Errorf("arg too big for int64: %v", arg)
		values.go#L110: 			return nil, fmt.Errorf("arg too big for int64: %v", arg)

	github.com/jackc/pgx/v4/internal/sanitize
		sanitize.go#L33: 				return "", fmt.Errorf("insufficient arguments")
		sanitize.go#L52: 				return "", fmt.Errorf("invalid arg type: %T", arg)
		sanitize.go#L56: 			return "", fmt.Errorf("invalid Part type: %T", part)
		sanitize.go#L63: 			return "", fmt.Errorf("unused argument: %d", i)

	github.com/jackc/pgx/v4/stdlib
		sql.go#L310: 		return nil, fmt.Errorf("unsupported isolation: %v", opts.Isolation)
		sql.go#L699: 				return fmt.Errorf("convert field %d failed: %v", i, err)
		sql.go#L788: 		return fmt.Errorf("can't release conn that is not acquired")

	github.com/jmespath/go-jmespath
		functions.go#L384: 	return fmt.Errorf("Invalid type for: %v, expected: %#v", arg, a.types)

	github.com/kevinburke/ssh_config
		config.go#L278: 				return "", fmt.Errorf("unknown Node type %v", t)
		validators.go#L72: 		return fmt.Errorf("ssh_config: value for key %q must be 'yes' or 'no', got %q", key, val)
		validators.go#L77: 			return fmt.Errorf("ssh_config: %v", err)

	github.com/lib/pq
		array.go#L78: 	return fmt.Errorf("pq: cannot convert %T to BoolArray", src)
		array.go#L92: 				return fmt.Errorf("pq: could not parse boolean array index %d: invalid boolean %q", i, v)
		array.go#L100: 				return fmt.Errorf("pq: could not parse boolean array index %d: invalid boolean %q", i, v)
		array.go#L152: 	return fmt.Errorf("pq: cannot convert %T to ByteaArray", src)
		array.go#L167: 				return fmt.Errorf("could not parse bytea array index %d: %s", i, err.Error())
		array.go#L224: 	return fmt.Errorf("pq: cannot convert %T to Float64Array", src)
		array.go#L238: 				return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
		array.go#L296: 			return fmt.Errorf("pq: scanning to %s is not implemented; only sql.Scanner", rt)
		array.go#L314: 		return fmt.Errorf("pq: destination %T is not a pointer to array or slice", a.A)
		array.go#L316: 		return fmt.Errorf("pq: destination %T is nil", a.A)
		array.go#L324: 		return fmt.Errorf("pq: destination %T is not a pointer to array or slice", a.A)
		array.go#L339: 	return fmt.Errorf("pq: cannot convert %T to %s", src, dv.Type())
		array.go#L352: 		return fmt.Errorf("pq: scanning from multidimensional ARRAY%s is not implemented",
		array.go#L366: 				return fmt.Errorf("pq: cannot convert ARRAY%s to %s",
		array.go#L377: 			return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
		array.go#L410: 		return nil, fmt.Errorf("pq: Unable to convert %T to array", a.A)
		array.go#L440: 	return fmt.Errorf("pq: cannot convert %T to Int64Array", src)
		array.go#L454: 				return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
		array.go#L501: 	return fmt.Errorf("pq: cannot convert %T to StringArray", src)
		array.go#L515: 				return fmt.Errorf("pq: parsing array element index %d: cannot convert nil to string", i)
		array.go#L646: 		return nil, nil, fmt.Errorf("pq: unable to parse array; expected %q at offset %d", '{', 0)
		array.go#L699: 						return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
		array.go#L721: 			return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
		array.go#L731: 			return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
		array.go#L735: 		err = fmt.Errorf("pq: unable to parse array; expected %q at offset %d", '}', i)
		array.go#L740: 				err = fmt.Errorf("pq: multidimensional arrays must have elements with matching dimensions")
		array.go#L753: 		return nil, fmt.Errorf("pq: cannot convert ARRAY%s to %s", strings.Replace(fmt.Sprint(dims), " ", "][", -1), typ)
		conn.go#L163: 				return fmt.Errorf("unrecognized value %q for %s", value, key)
		conn.go#L341: 			return nil, fmt.Errorf("invalid value for parameter connect_timeout: %s", err)
		conn.go#L447: 			return fmt.Errorf(`missing "=" after %q in connection info string"`, string(keyRunes))
		conn.go#L461: 						return fmt.Errorf(`missing character after backslash`)
		conn.go#L474: 					return fmt.Errorf(`unterminated quoted string literal in connection string`)
		conn.go#L523: 		return nil, fmt.Errorf("unexpected command tag %s", commandTag)
		conn.go#L527: 		return nil, fmt.Errorf("unexpected transaction status %v", cn.txnStatus)
		conn.go#L568: 		return fmt.Errorf("unexpected command tag %s", commandTag)
		conn.go#L593: 		return fmt.Errorf("unexpected command tag %s", commandTag)
		conn_go18.go#L61: 		return nil, fmt.Errorf("pq: isolation level not supported: %d", opts.Isolation)
		connector.go#L92: 			return nil, fmt.Errorf("setting datestyle must be absent or %v; got %v", "ISO, MDY", datestyle)
		copy.go#L165: 			ci.setError(fmt.Errorf("unknown response during CopyIn: %q", t))
		encode.go#L227: 		p.err = fmt.Errorf("expected '%v' at position %v; got '%v'", char, pos, c)
		encode.go#L242: 			p.err = fmt.Errorf("expected number; got '%v'", str)
		encode.go#L417: 			return time.Time{}, fmt.Errorf("expected '-' or '+' at position %v; got %v", tzStart, c)
		encode.go#L441: 		return time.Time{}, fmt.Errorf("expected end of input, got %v", str[remainderIdx:])
		encode.go#L534: 					return nil, fmt.Errorf("invalid bytea sequence %v", s)
		encode.go#L538: 					return nil, fmt.Errorf("could not parse bytea value: %s", err.Error())
		error.go#L460: 	panic(fmt.Errorf("pq: %s", fmt.Sprintf(s, args...)))
		error.go#L465: 	return fmt.Errorf("pq: %s", fmt.Sprintf(s, args...))
		error.go#L477: 		*err = fmt.Errorf("pq: unexpected error: %#v", e)
		notify.go#L166: 				return fmt.Errorf("unexpected CommandComplete")
		notify.go#L173: 				return fmt.Errorf("unexpected ReadyForQuery")
		notify.go#L180: 			return fmt.Errorf("unexpected message %q from server in listenerConnLoop", t)
		notify.go#L331: 			return false, fmt.Errorf("unknown response for simple query: %q", m.typ)
		url.go#L39: 		return "", fmt.Errorf("invalid connection protocol: %s", u.Scheme)
		uuid.go#L11: 		return nil, fmt.Errorf("pq: unable to decode uuid; bad length: %d", len(src))

	github.com/lib/pq/scram
		scram.go#L136: 			return fmt.Errorf("cannot read random SCRAM-SHA-256 nonce from operating system: %v", err)
		scram.go#L159: 		return fmt.Errorf("expected 3 fields in first SCRAM-SHA-256 server message, got %d: %q", len(fields), in)
		scram.go#L162: 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 nonce: %q", fields[0])
		scram.go#L165: 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 salt: %q", fields[1])
		scram.go#L168: 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 iteration count: %q", fields[2])
		scram.go#L173: 		return fmt.Errorf("server SCRAM-SHA-256 nonce is not prefixed by client nonce: got %q, want %q+\"...\"", c.serverNonce, c.clientNonce)
		scram.go#L179: 		return fmt.Errorf("cannot decode SCRAM-SHA-256 salt sent by server: %q", fields[1])
		scram.go#L184: 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 iteration count: %q", fields[2])
		scram.go#L206: 		return fmt.Errorf("SCRAM-SHA-256 authentication error: %s", fields[0][2:])
		scram.go#L208: 		return fmt.Errorf("unsupported SCRAM-SHA-256 final message from server: %q", in)
		scram.go#L211: 		return fmt.Errorf("cannot authenticate SCRAM-SHA-256 server signature: %q", fields[0][2:])

	github.com/Masterminds/squirrel
		delete.go#L33: 		err = fmt.Errorf("delete statements must specify a From table")
		expr.go#L99: 			return "", nil, fmt.Errorf("%#v is not a string or Sqlizer", part)
		expr.go#L240: 			err = fmt.Errorf("cannot use null with like operators")
		expr.go#L244: 				err = fmt.Errorf("cannot use array or slice with like operators")
		expr.go#L320: 			err = fmt.Errorf("cannot use null with less than or greater than operators")
		expr.go#L324: 			err = fmt.Errorf("cannot use array or slice with less than or greater than operators")
		part.go#L27: 		err = fmt.Errorf("expected string or Sqlizer, not %T", pred)
		select.go#L70: 		err = fmt.Errorf("select statements must have at least one result column")
		squirrel.go#L96: var RunnerNotSet = fmt.Errorf("cannot run; no Runner set (RunWith)")
		squirrel.go#L99: var RunnerNotQueryRunner = fmt.Errorf("cannot QueryRow; Runner is not a QueryRower")
		stmtcacher.go#L99: 		return fmt.Errorf("one or more Stmt.Close failed; last error: %v", err)
		update.go#L58: 		err = fmt.Errorf("update statements must specify a table")
		update.go#L62: 		err = fmt.Errorf("update statements must have at least one Set clause")
		where.go#L27: 		err = fmt.Errorf("expected string-keyed map or string, not %T", pred)

	github.com/prometheus/client_golang/prometheus
		desc.go#L85: 		d.err = fmt.Errorf("%q is not a valid metric name", fqName)
		desc.go#L97: 			d.err = fmt.Errorf("%q is not a valid label name for metric %q", labelName, fqName)
		desc.go#L119: 			d.err = fmt.Errorf("%q is not a valid label name for metric %q", labelName, fqName)
		histogram.go#L63: 	errBucketLabelNotAllowed = fmt.Errorf(
		histogram.go#L195: 				panic(fmt.Errorf(
		labels.go#L41: 	return fmt.Errorf(
		labels.go#L51: 		return fmt.Errorf(
		labels.go#L60: 			return fmt.Errorf("label %s: value %q is not valid UTF-8", name, val)
		labels.go#L69: 		return fmt.Errorf(
		labels.go#L78: 			return fmt.Errorf("label value %q is not valid UTF-8", val)
		registry.go#L289: 			return fmt.Errorf("descriptor %s is invalid: %s", desc, desc.err)
		registry.go#L295: 			duplicateDescErr = fmt.Errorf("descriptor %s already exists with the same fully-qualified name and const label values", desc)
		registry.go#L310: 				return fmt.Errorf("a previously registered descriptor with the same fully-qualified name as %s has different label names or a different help string", desc)
		registry.go#L316: 					return fmt.Errorf("descriptors reported by collector have inconsistent label names or help strings for the same fully-qualified name, offender is %s", desc)
		registry.go#L596: 		return fmt.Errorf("error collecting metric %v: %s", desc, err)
		registry.go#L601: 			return fmt.Errorf(
		registry.go#L610: 				return fmt.Errorf(
		registry.go#L617: 				return fmt.Errorf(
		registry.go#L624: 				return fmt.Errorf(
		registry.go#L631: 				return fmt.Errorf(
		registry.go#L638: 				return fmt.Errorf(
		registry.go#L663: 			return fmt.Errorf("empty metric collected: %s", dtoMetric)
		registry.go#L676: 			return fmt.Errorf(
		registry.go#L720: 					errs = append(errs, fmt.Errorf("[from Gatherer #%d] %s", i+1, err))
		registry.go#L723: 				errs = append(errs, fmt.Errorf("[from Gatherer #%d] %s", i+1, err))
		registry.go#L730: 					errs = append(errs, fmt.Errorf(
		registry.go#L737: 					errs = append(errs, fmt.Errorf(
		registry.go#L788: 					return fmt.Errorf(
		registry.go#L794: 				return fmt.Errorf(
		registry.go#L803: 			return fmt.Errorf(
		registry.go#L809: 			return fmt.Errorf(
		registry.go#L817: 			return fmt.Errorf(
		registry.go#L843: 		return fmt.Errorf(
		registry.go#L853: 			return fmt.Errorf(
		registry.go#L859: 			return fmt.Errorf(
		registry.go#L865: 			return fmt.Errorf(
		registry.go#L871: 			return fmt.Errorf(
		registry.go#L899: 		return fmt.Errorf(
		registry.go#L915: 		return fmt.Errorf(
		registry.go#L930: 		return fmt.Errorf(
		registry.go#L940: 			return fmt.Errorf(
		summary.go#L61: var errQuantileLabelNotAllowed = fmt.Errorf(
		summary.go#L192: 		panic(fmt.Errorf("illegal max age MaxAge=%v", opts.MaxAge))
		value.go#L137: 		return fmt.Errorf("encountered unknown type %v", t)
		vec.go#L104: 				return nil, fmt.Errorf("label name %q is already curried", label)
		vec.go#L116: 		return nil, fmt.Errorf("%d unknown label(s) found during currying", l)
		vec.go#L182: 				return 0, fmt.Errorf("label name %q is already curried", label)
		vec.go#L188: 				return 0, fmt.Errorf("label name %q missing in label map", label)
		wrap.go#L187: 				err:             fmt.Errorf("attempted wrapping with already existing label name %q", ln),

	github.com/prometheus/client_model/go
		metrics.pb.go#L12: var _ = fmt.Errorf

	github.com/prometheus/common/expfmt
		decode.go#L94: 		return fmt.Errorf("invalid metric name %q", v.GetName())
		decode.go#L105: 				return fmt.Errorf("invalid label value %q", l.GetValue())
		decode.go#L108: 				return fmt.Errorf("invalid label name %q", l.GetName())
		decode.go#L199: 	return nil, fmt.Errorf("expfmt.extractSamples: unknown metric family type %v", f.GetType())
		text_create.go#L70: 		return 0, fmt.Errorf("MetricFamily has no metrics: %s", in)
		text_create.go#L74: 		return 0, fmt.Errorf("MetricFamily has no name: %s", in)
		text_create.go#L146: 		return written, fmt.Errorf("unknown metric type %s", metricType.String())
		text_create.go#L158: 				return written, fmt.Errorf(
		text_create.go#L168: 				return written, fmt.Errorf(
		text_create.go#L178: 				return written, fmt.Errorf(
		text_create.go#L188: 				return written, fmt.Errorf(
		text_create.go#L217: 				return written, fmt.Errorf(
		text_create.go#L260: 			return written, fmt.Errorf(
		text_parse.go#L447: 		p.err = fmt.Errorf("unexpected type for metric name %q", p.currentMF.GetName())
		text_parse.go#L761: 		return 0, fmt.Errorf("unsupported character in float")

	github.com/prometheus/common/model
		alert.go#L87: 		return fmt.Errorf("start time missing")
		alert.go#L90: 		return fmt.Errorf("start time must be before end time")
		alert.go#L93: 		return fmt.Errorf("invalid label set: %s", err)
		alert.go#L96: 		return fmt.Errorf("at least one label pair required")
		alert.go#L99: 		return fmt.Errorf("invalid annotations: %s", err)
		labels.go#L114: 		return fmt.Errorf("%q is not a valid label name", s)
		labels.go#L127: 		return fmt.Errorf("%q is not a valid label name", s)
		labelset.go#L35: 			return fmt.Errorf("invalid name %q", ln)
		labelset.go#L38: 			return fmt.Errorf("invalid value %q", lv)
		labelset.go#L164: 			return fmt.Errorf("%q is not a valid label name", ln)
		silence.go#L37: 		return fmt.Errorf("label name in matcher must not be empty")
		silence.go#L50: 		return fmt.Errorf("invalid name %q", m.Name)
		silence.go#L54: 			return fmt.Errorf("invalid regular expression %q", m.Value)
		silence.go#L57: 		return fmt.Errorf("invalid value %q", m.Value)
		silence.go#L80: 		return fmt.Errorf("at least one matcher required")
		silence.go#L84: 			return fmt.Errorf("invalid matcher: %s", err)
		silence.go#L88: 		return fmt.Errorf("start time missing")
		silence.go#L91: 		return fmt.Errorf("end time missing")
		silence.go#L94: 		return fmt.Errorf("start time must be before end time")
		silence.go#L97: 		return fmt.Errorf("creator information missing")
		silence.go#L100: 		return fmt.Errorf("comment missing")
		silence.go#L103: 		return fmt.Errorf("creation timestamp missing")
		time.go#L162: 		return fmt.Errorf("invalid time %q", string(b))
		time.go#L191: 		return 0, fmt.Errorf("not a valid duration string: %q", durationStr)
		time.go#L213: 		return 0, fmt.Errorf("invalid time unit in duration string: %q", unit)
		value.go#L53: 		return fmt.Errorf("sample value must be a quoted string")
		value.go#L279: 		return fmt.Errorf("unknown value type %q", s)
		value.go#L327: 		return fmt.Errorf("error parsing sample value: %s", err)

	github.com/prometheus/procfs
		arp.go#L39: 		return nil, fmt.Errorf("error reading arp %s: %s", fs.proc.Path("net/arp"), err)
		arp.go#L62: 				return []ARPEntry{}, fmt.Errorf("failed to parse ARP entry: %s", err)
		arp.go#L66: 			return []ARPEntry{}, fmt.Errorf("%d columns were detected, but %d were expected", width, expectedDataWidth)
		buddyinfo.go#L58: 			return nil, fmt.Errorf("invalid number of fields when parsing buddyinfo")
		buddyinfo.go#L69: 				return nil, fmt.Errorf("mismatch in number of buddyinfo buckets, previous count %d, new count %d", bucketCount, arraySize)
		buddyinfo.go#L77: 				return nil, fmt.Errorf("invalid value in buddyinfo: %s", err)
		crypto.go#L57: 		return nil, fmt.Errorf("error parsing crypto %s: %s", fs.proc.Path("crypto"), err)
		crypto.go#L61: 		return nil, fmt.Errorf("error parsing crypto %s: %s", fs.proc.Path("crypto"), err)
		ipvs.go#L225: 			return nil, 0, fmt.Errorf("invalid IPv6 address: %s", s[1:40])
		ipvs.go#L228: 		return nil, 0, fmt.Errorf("unexpected IP:Port: %s", s)
		ipvs.go#L233: 		return nil, 0, fmt.Errorf("unexpected port string format: %s", portString)
		mdstat.go#L55: 		return nil, fmt.Errorf("error parsing mdstat %s: %s", fs.proc.Path("mdstat"), err)
		mdstat.go#L59: 		return nil, fmt.Errorf("error parsing mdstat %s: %s", fs.proc.Path("mdstat"), err)
		mdstat.go#L79: 			return nil, fmt.Errorf("not enough fields in mdline (expected at least 3): %s", line)
		mdstat.go#L85: 			return nil, fmt.Errorf(
		mdstat.go#L97: 			return nil, fmt.Errorf("error parsing md device lines: %s", err)
		mdstat.go#L126: 					return nil, fmt.Errorf("error parsing sync line in md device %s: %s", mdName, err)
		mdstat.go#L151: 		return 0, 0, 0, fmt.Errorf("unexpected statusLine %s: %s", statusLine, err)
		mdstat.go#L166: 		return 0, 0, 0, fmt.Errorf("couldn't find all the substring matches: %s", statusLine)
		mdstat.go#L171: 		return 0, 0, 0, fmt.Errorf("unexpected statusLine %s: %s", statusLine, err)
		mdstat.go#L176: 		return 0, 0, 0, fmt.Errorf("unexpected statusLine %s: %s", statusLine, err)
		mdstat.go#L185: 		return 0, fmt.Errorf("unexpected recoveryLine: %s", recoveryLine)
		mdstat.go#L190: 		return 0, fmt.Errorf("%s in recoveryLine: %s", err, recoveryLine)
		meminfo.go#L155: 		return Meminfo{}, fmt.Errorf("failed to parse meminfo: %v", err)
		meminfo.go#L168: 			return nil, fmt.Errorf("malformed meminfo line: %q", s.Text())
		mountinfo.go#L81: 		return nil, fmt.Errorf("couldn't find enough fields in mount string: %s", mountString)
		mountinfo.go#L85: 		return nil, fmt.Errorf("couldn't find separator in expected field: %s", mountInfo[mountInfoLength-4])
		mountinfo.go#L101: 		return nil, fmt.Errorf("failed to parse mount ID")
		mountinfo.go#L105: 		return nil, fmt.Errorf("failed to parse parent ID")
		mountstats.go#L265: 				return nil, fmt.Errorf("cannot parse MountStats for fstype %q", m.Type)
		mountstats.go#L288: 		return nil, fmt.Errorf("invalid device entry: %v", ss)
		mountstats.go#L306: 			return nil, fmt.Errorf("invalid device entry: %v", ss)
		mountstats.go#L340: 			return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
		mountstats.go#L380: 				return nil, fmt.Errorf("not enough information for NFS transport stats: %v", ss)
		mountstats.go#L419: 		return nil, fmt.Errorf("invalid NFS bytes stats: %v", ss)
		mountstats.go#L448: 		return nil, fmt.Errorf("invalid NFS events stats: %v", ss)
		mountstats.go#L512: 			return nil, fmt.Errorf("invalid NFS per-operations stats: %v", ss)
		mountstats.go#L557: 			return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.0 statement: %v", protocol, ss)
		mountstats.go#L560: 			return nil, fmt.Errorf("invalid NFS transport stats 1.0 statement: %v", ss)
		mountstats.go#L569: 			return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.1 statement: %v", protocol, ss)
		mountstats.go#L572: 			return nil, fmt.Errorf("invalid NFS transport stats 1.1 statement: %v", ss)
		mountstats.go#L575: 		return nil, fmt.Errorf("unrecognized NFS transport stats version: %q", statVersion)
		net_sockstat.go#L73: 		return nil, fmt.Errorf("failed to read sockstats from %q: %v", name, err)
		net_sockstat.go#L87: 			return nil, fmt.Errorf("malformed sockstat line: %q", s.Text())
		net_sockstat.go#L93: 			return nil, fmt.Errorf("error parsing sockstat key/value pairs from %q: %v", s.Text(), err)
		net_softnet.go#L42: 		return nil, fmt.Errorf("error reading softnet %s: %s", fs.proc.Path("net/softnet_stat"), err)
		net_softnet.go#L62: 			return []SoftnetEntry{}, fmt.Errorf("%d columns were detected, but %d were expected", width, expectedColumns)
		net_softnet.go#L78: 		return SoftnetEntry{}, fmt.Errorf("Unable to parse column 0: %s", err)
		net_softnet.go#L81: 		return SoftnetEntry{}, fmt.Errorf("Unable to parse column 1: %s", err)
		net_softnet.go#L84: 		return SoftnetEntry{}, fmt.Errorf("Unable to parse column 2: %s", err)
		net_unix.go#L145: 		return nil, fmt.Errorf(
		net_unix.go#L151: 		return nil, fmt.Errorf("Parse Unix domain num(%s) failed: %s", fields[netUnixKernelPtrIdx], err)
		net_unix.go#L155: 		return nil, fmt.Errorf("Parse Unix domain ref count(%s) failed: %s", fields[netUnixRefCountIdx], err)
		net_unix.go#L159: 		return nil, fmt.Errorf("Parse Unix domain flags(%s) failed: %s", fields[netUnixFlagsIdx], err)
		net_unix.go#L163: 		return nil, fmt.Errorf("Parse Unix domain type(%s) failed: %s", fields[netUnixTypeIdx], err)
		net_unix.go#L167: 		return nil, fmt.Errorf("Parse Unix domain state(%s) failed: %s", fields[netUnixStateIdx], err)
		net_unix.go#L174: 			return nil, fmt.Errorf("Parse Unix domain inode(%s) failed: %s", inodeStr, err)
		proc.go#L108: 		return Procs{}, fmt.Errorf("could not read %s: %s", d.Name(), err)
		proc.go#L188: 			return nil, fmt.Errorf("could not parse fd %s: %s", n, err)
		proc.go#L260: 		return nil, fmt.Errorf("could not read %s: %s", d.Name(), err)
		proc_limits.go#L102: 			return ProcLimits{}, fmt.Errorf(
		proc_limits.go#L154: 		return 0, fmt.Errorf("couldn't parse value %s: %s", s, err)
		proc_ns.go#L43: 		return nil, fmt.Errorf("failed to read contents of ns dir: %v", err)
		proc_ns.go#L55: 			return nil, fmt.Errorf("failed to parse namespace type and inode from '%v'", target)
		proc_ns.go#L61: 			return nil, fmt.Errorf("failed to parse inode from '%v': %v", fields[1], err)
		proc_psi.go#L62: 		return PSIStats{}, fmt.Errorf("psi_stats: unavailable for %s", resource)
		proc_stat.go#L130: 		return ProcStat{}, fmt.Errorf(
		stat.go#L96: 		return CPUStat{}, -1, fmt.Errorf("couldn't parse %s (cpu): %s", line, err)
		stat.go#L99: 		return CPUStat{}, -1, fmt.Errorf("couldn't parse %s (cpu): 0 elements parsed", line)
		stat.go#L119: 		return CPUStat{}, -1, fmt.Errorf("couldn't parse %s (cpu/cpuid): %s", line, err)
		stat.go#L139: 		return SoftIRQStat{}, 0, fmt.Errorf("couldn't parse %s (softirq): %s", line, err)
		stat.go#L187: 				return Stat{}, fmt.Errorf("couldn't parse %s (btime): %s", parts[1], err)
		stat.go#L191: 				return Stat{}, fmt.Errorf("couldn't parse %s (intr): %s", parts[1], err)
		stat.go#L197: 					return Stat{}, fmt.Errorf("couldn't parse %s (intr%d): %s", count, i, err)
		stat.go#L202: 				return Stat{}, fmt.Errorf("couldn't parse %s (ctxt): %s", parts[1], err)
		stat.go#L206: 				return Stat{}, fmt.Errorf("couldn't parse %s (processes): %s", parts[1], err)
		stat.go#L210: 				return Stat{}, fmt.Errorf("couldn't parse %s (procs_running): %s", parts[1], err)
		stat.go#L214: 				return Stat{}, fmt.Errorf("couldn't parse %s (procs_blocked): %s", parts[1], err)
		stat.go#L240: 		return Stat{}, fmt.Errorf("couldn't parse %s: %s", fileName, err)
		vm.go#L87: 		return nil, fmt.Errorf("%s is not a directory", path)
		xfrm.go#L115: 			return XfrmStat{}, fmt.Errorf(
		zoneinfo.go#L77: 		return nil, fmt.Errorf("error reading zoneinfo %s: %s", fs.proc.Path("zoneinfo"), err)
		zoneinfo.go#L81: 		return nil, fmt.Errorf("error parsing zoneinfo %s: %s", fs.proc.Path("zoneinfo"), err)

	github.com/prometheus/procfs/internal/fs
		fs.go#L42: 		return "", fmt.Errorf("could not read %s: %s", mountPoint, err)
		fs.go#L45: 		return "", fmt.Errorf("mount point %s is not a directory", mountPoint)

	github.com/prometheus/procfs/internal/util
		sysreadfile_compat.go#L25: 	return "", fmt.Errorf("not supported on this platform")

	github.com/sergi/go-diff/diffmatchpatch
		diff.go#L1309: 				return nil, fmt.Errorf("invalid UTF-8 token: %q", param)
		diff.go#L1341: 		return nil, fmt.Errorf("Delta length (%v) is different from source text length (%v)", i, len(text1))

	github.com/xanzy/ssh-agent
		sshagent.go#L40: 		return nil, nil, fmt.Errorf("Error connecting to SSH_AUTH_SOCK: %v", err)

	go.opencensus.io/metric/metricexport
		reader.go#L31: 	errReportingIntervalTooLow = fmt.Errorf("reporting interval less than %d", minimumReportingDuration)
		reader.go#L32: 	errAlreadyStarted          = fmt.Errorf("already started")
		reader.go#L33: 	errIntervalReaderNil       = fmt.Errorf("interval reader is nil")
		reader.go#L34: 	errExporterNil             = fmt.Errorf("exporter is nil")
		reader.go#L35: 	errReaderNil               = fmt.Errorf("reader is nil")

	go.opencensus.io/resource
		resource.go#L74: 			return nil, fmt.Errorf("invalid label formatting, remainder: %s", s)
		resource.go#L82: 				return nil, fmt.Errorf("invalid label formatting, remainder: %s, err: %s", s, err)

	go.opencensus.io/stats/view
		view.go#L80: 		return fmt.Errorf("cannot register view %q: measure not set", v.Name)
		view.go#L83: 		return fmt.Errorf("cannot register view %q: aggregation not set", v.Name)
		view.go#L215: 		return fmt.Errorf("view name cannot be larger than %v", maxNameLength)
		view.go#L218: 		return fmt.Errorf("view name needs to be an ASCII string")
		worker.go#L319: 			return nil, fmt.Errorf("cannot register view %q; a different view with the same name is already registered", v.Name)
		worker_commands.go#L130: 			fmt.Errorf("cannot retrieve data; view %q is not registered", cmd.v),
		worker_commands.go#L138: 			fmt.Errorf("cannot retrieve data; view %q has no subscriptions or collection is not forcibly started", cmd.v),

	go.opencensus.io/tag
		map.go#L193: 				return ctx, fmt.Errorf("key:%q: %v", k, errInvalidKeyName)
		map.go#L196: 				return ctx, fmt.Errorf("key:%q value:%q: %v", k.Name(), v, errInvalidValue)
		map_codec.go#L121: 		return nil, fmt.Errorf("unexpected end while readBytesWithVarintLen '%x' starting at idx '%v'", eg.buf, eg.readIdx)
		map_codec.go#L125: 		return nil, fmt.Errorf("unexpected end while readBytesWithVarintLen '%x' starting at idx '%v'", eg.buf, eg.readIdx)
		map_codec.go#L131: 		return nil, fmt.Errorf("malformed encoding: length:%v, upper:%v, maxLength:%v", length, valueEnd, len(eg.buf))
		map_codec.go#L205: 		return fmt.Errorf("cannot decode: unsupported version: %q; supports only up to: %q", version, tagsVersionID)
		map_codec.go#L212: 			return fmt.Errorf("cannot decode: invalid key type: %q", typ)

	go.opencensus.io/trace/tracestate
		tracestate.go#L81: 		return fmt.Errorf("adding %d key-value pairs to current %d pairs exceeds the limit of %d",
		tracestate.go#L129: 		return nil, fmt.Errorf("key-value pair {%s, %s} is invalid", entry.Key, entry.Value)
		tracestate.go#L133: 		return nil, fmt.Errorf("contains duplicate keys (%s)", key)

	go.opentelemetry.io/otel/api/metric/registry
		registry.go#L65: var ErrMetricKindMismatch = fmt.Errorf(
		registry.go#L93: 	return fmt.Errorf("Metric was %s (%s %s)registered as a %s %s: %w",

	go/build
		build.go#L526: 		return p, fmt.Errorf("import %q: invalid import path", path)
		build.go#L543: 		pkgerr = fmt.Errorf("import %q: unknown compiler %q", path, ctxt.Compiler)
		build.go#L560: 			return p, fmt.Errorf("import %q: import relative to unknown directory", path)
		build.go#L613: 			return p, fmt.Errorf("import %q: cannot import absolute path", path)
		build.go#L751: 		return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))
		build.go#L777: 		return p, fmt.Errorf("cannot find package %q in:\n\t%s", path, p.Dir)
		build.go#L901: 					badFile(fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
		build.go#L906: 					badFile(fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
		build.go#L916: 					badFile(fmt.Errorf("use of cgo in test %s not supported", filename))
		build.go#L1078: 			return fmt.Errorf("go/build: Dir is non-empty, so relative srcDir is not allowed: %v", srcDir)
		build.go#L1167: 		return fmt.Errorf("go/build: go list %s: %v\n%s\n", path, err, stderr.String())
		build.go#L1172: 		return fmt.Errorf("go/build: importGo %s: unexpected output:\n%s\n", path, stdout.String())
		build.go#L1420: 		return nil, fmt.Errorf("read %s: %v", info.name, err)
		build.go#L1638: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1645: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1664: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1669: 				return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg)
		build.go#L1694: 			return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig)
		read.go#L428: 				return fmt.Errorf("parser returned invalid quoted string: <%s>", quoted)
		read.go#L510: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
		read.go#L525: 						return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
		read.go#L533: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
		read.go#L540: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)

	go/doc
		doc.go#L163: 		panic(fmt.Errorf("doc.NewFromFiles: no token.FileSet provided (fset == nil)"))
		doc.go#L172: 			panic(fmt.Errorf("doc.NewFromFiles: option argument type must be doc.Mode"))
		doc.go#L176: 		panic(fmt.Errorf("doc.NewFromFiles: there must not be more than 1 option argument"))
		doc.go#L187: 			return nil, fmt.Errorf("file files[%d] is not found in the provided file set", i)
		doc.go#L195: 			return nil, fmt.Errorf("file files[%d] filename %q does not have a .go extension", i, name)

	go/format
		format.go#L80: 			return fmt.Errorf("format.Node internal error (%s)", err)

	go/printer
		printer.go#L1160: 	return fmt.Errorf("go/printer: unsupported node type %T", node)

	golang.org/x/crypto/curve25519
		curve25519.go#L77: 		return nil, fmt.Errorf("bad scalar length: %d, expected %d", l, 32)
		curve25519.go#L80: 		return nil, fmt.Errorf("bad point length: %d, expected %d", l, 32)
		curve25519.go#L91: 			return nil, fmt.Errorf("bad input point: low order point")

	golang.org/x/crypto/ssh
		certs.go#L142: 			return nil, fmt.Errorf("ssh: certificate options are not in lexical order")
		certs.go#L155: 				return nil, fmt.Errorf("ssh: unexpected trailing data after certificate option value")
		certs.go#L318: 		return fmt.Errorf("ssh: certificate presented as a host key has type %d", cert.CertType)
		certs.go#L321: 		return fmt.Errorf("ssh: no authorities for hostname: %v", addr)
		certs.go#L345: 		return nil, fmt.Errorf("ssh: cert has type %d", cert.CertType)
		certs.go#L348: 		return nil, fmt.Errorf("ssh: certificate signed by unrecognized authority")
		certs.go#L362: 		return fmt.Errorf("ssh: certificate serial %d revoked", cert.Serial)
		certs.go#L380: 			return fmt.Errorf("ssh: unsupported critical option %q in certificate", opt)
		certs.go#L394: 			return fmt.Errorf("ssh: principal %q not in the set of valid principals for given certificate: %q", principal, cert.ValidPrincipals)
		certs.go#L405: 		return fmt.Errorf("ssh: cert is not yet valid")
		certs.go#L408: 		return fmt.Errorf("ssh: cert has expired")
		certs.go#L411: 		return fmt.Errorf("ssh: certificate signature does not verify")
		channel.go#L353: 		return 0, fmt.Errorf("ssh: extended code %d unimplemented", extended)
		channel.go#L432: 			return fmt.Errorf("ssh: invalid MaxPacketSize %d from peer", msg.MaxPacketSize)
		channel.go#L440: 			return fmt.Errorf("ssh: invalid window update for %d bytes", msg.AdditionalBytes)
		channel.go#L601: 			return false, fmt.Errorf("ssh: unexpected response to channel request: %#v", m)
		cipher.go#L401: 		return nil, fmt.Errorf("ssh: illegal padding %d", padding)
		cipher.go#L405: 		return nil, fmt.Errorf("ssh: padding %d too large", padding)
		cipher.go#L717: 		return nil, fmt.Errorf("ssh: illegal padding %d", padding)
		cipher.go#L721: 		return nil, fmt.Errorf("ssh: padding %d too large", padding)
		client.go#L85: 		return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)
		client.go#L255: 		return fmt.Errorf("ssh: required host key was nil")
		client.go#L258: 		return fmt.Errorf("ssh: host key mismatch")
		client_auth.go#L77: 	return fmt.Errorf("ssh: unable to authenticate, attempted methods %v, no supported methods remain", tried)
		client_auth.go#L474: 			return authFailure, nil, fmt.Errorf("ssh: incorrect number of answers from keyboard-interactive callback %d (expected %d)", len(answers), len(prompts))
		client_auth.go#L611: 			return authFailure, nil, fmt.Errorf("GSS-API Error:\n"+
		common.go#L108: 	return fmt.Errorf("ssh: unexpected message type %d (expected %d)", got, expected)
		common.go#L113: 	return fmt.Errorf("ssh: parse error in message type %d", tag)
		common.go#L124: 	return "", fmt.Errorf("ssh: no common algorithm for %s; client offered: %v, server offered: %v", what, client, server)
		handshake.go#L159: 		return fmt.Errorf("ssh: first packet should be msgNewKeys")
		handshake.go#L396: 		return nil, fmt.Errorf("ssh: first packet should be msgKexInit")
		handshake.go#L580: 		return fmt.Errorf("ssh: unexpected key exchange algorithm %v", t.algorithms.kex)
		kex.go#L568: 		return nil, fmt.Errorf("ssh: DH parameter out of bounds")
		kex.go#L597: 		return nil, fmt.Errorf("ssh: server-generated gex p is out of range (%d bits)", kexDHGexGroup.P.BitLen())
		kex.go#L608: 		return nil, fmt.Errorf("ssh: server provided gex g is not safe")
		kex.go#L644: 		return nil, fmt.Errorf("ssh: derived k is not safe")
		keys.go#L79: 	return nil, nil, fmt.Errorf("ssh: unknown key algorithm: %v", algo)
		keys.go#L393: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, r.Type())
		keys.go#L416: 		return fmt.Errorf("ssh: unsupported DSA key size %d", l)
		keys.go#L467: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
		keys.go#L507: 		return nil, fmt.Errorf("ssh: unsupported signature algorithm %s", algorithm)
		keys.go#L566: 		return nil, nil, fmt.Errorf("invalid size %d for Ed25519 public key", l)
		keys.go#L585: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
		keys.go#L588: 		return fmt.Errorf("ssh: invalid size %d for Ed25519 public key", l)
		keys.go#L671: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
		keys.go#L775: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
		keys.go#L846: 		return nil, nil, fmt.Errorf("invalid size %d for Ed25519 public key", l)
		keys.go#L871: 		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
		keys.go#L874: 		return fmt.Errorf("invalid size %d for Ed25519 public key", l)
		keys.go#L930: 		return nil, fmt.Errorf("ssh: unsupported key type %T", key)
		keys.go#L981: 			return nil, fmt.Errorf("ssh: unsupported signature algorithm %s", algorithm)
		keys.go#L988: 			return nil, fmt.Errorf("ssh: unsupported signature algorithm %s", algorithm)
		keys.go#L998: 			return nil, fmt.Errorf("ssh: unsupported key type %T", key)
		keys.go#L1065: 			return nil, fmt.Errorf("ssh: invalid size %d for Ed25519 public key", l)
		keys.go#L1069: 		return nil, fmt.Errorf("ssh: unsupported key type %T", key)
		keys.go#L1143: 		return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type)
		keys.go#L1169: 		return nil, fmt.Errorf("ssh: cannot decode encrypted private keys: %v", err)
		keys.go#L1180: 		return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type)
		keys.go#L1232: 			return nil, fmt.Errorf("ssh: unknown KDF %q, only supports %q", kdfName, "bcrypt")
		keys.go#L1259: 				return nil, fmt.Errorf("ssh: invalid encrypted private key length, not a multiple of the block size")
		keys.go#L1264: 			return nil, fmt.Errorf("ssh: unknown cipher %q, only supports %q or %q", cipherName, "aes256-ctr", "aes256-cbc")
		keys.go#L1307: 				return nil, fmt.Errorf("ssh: failed to parse embedded public key: %v", errPub)
		messages.go#L363: 	return fmt.Errorf("ssh: unmarshal error for field %s of type %s%s", t.Field(field).Name, t.Name(), problem)
		messages.go#L397: 			return fmt.Errorf("ssh: unexpected message type %d (expected one of %v)", data[0], expectedTypes)
		mux.go#L168: 		return false, nil, fmt.Errorf("ssh: unexpected response to request: %#v", msg)
		mux.go#L328: 		return nil, fmt.Errorf("ssh: unexpected packet in response to channel open: %T", msg)
		mux.go#L349: 		return fmt.Errorf("ssh: invalid channel %d", id)
		server.go#L199: 			return nil, nil, nil, fmt.Errorf("ssh: unsupported key exchange %s for server", kex)
		server.go#L301: 		return fmt.Errorf("ssh: remote address %v is not an TCP address when checking source-address match", addr)
		server.go#L312: 				return fmt.Errorf("ssh: error parsing source-address restriction %q: %v", sourceAddr, err)
		server.go#L321: 	return fmt.Errorf("ssh: remote address %v is not allowed because of source-address restriction", addr)
		server.go#L505: 				authErr = fmt.Errorf("ssh: algorithm %q not accepted", algo)
		server.go#L562: 					authErr = fmt.Errorf("ssh: algorithm %q not accepted", sig.Format)
		server.go#L586: 				authErr = fmt.Errorf("ssh: Mechanism negotiation is not supported")
		server.go#L598: 				authErr = fmt.Errorf("ssh: GSSAPI authentication must use the Kerberos V5 mechanism")
		server.go#L622: 			authErr = fmt.Errorf("ssh: unknown method %q", userAuthReq.Method)
		session.go#L288: 		err = fmt.Errorf("ssh: command %v failed", cmd)
		tcpip.go#L35: 		return nil, fmt.Errorf("ssh: unsupported protocol: %s", n)
		tcpip.go#L84: 	return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
		tcpip.go#L185: 		return nil, fmt.Errorf("ssh: port number out of range: %d", port)
		tcpip.go#L189: 		return nil, fmt.Errorf("ssh: cannot parse IP address %q", addr)
		tcpip.go#L240: 			panic(fmt.Errorf("ssh: unknown channel type %s", channelType))
		tcpip.go#L382: 		return nil, fmt.Errorf("ssh: unsupported protocol: %s", n)

	golang.org/x/crypto/ssh/agent
		client.go#L241: 	return fmt.Errorf("agent: client error: %v", err)
		client.go#L270: 		return fmt.Errorf("agent: bad public key: %v", err)
		client.go#L481: 		return nil, fmt.Errorf("agent: unknown type tag %d", packet[0])
		client.go#L535: 			return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes))
		client.go#L590: 		return fmt.Errorf("agent: unsupported key type %T", s)
		client.go#L669: 			return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes))
		client.go#L720: 		return fmt.Errorf("agent: unsupported key type %T", s)
		keyring.go#L106: 		return fmt.Errorf("agent: incorrect passphrase")
		keyring.go#L203: 					return nil, fmt.Errorf("agent: signature does not support non-default signature algorithm: %T", k.signer)
		keyring.go#L212: 						return nil, fmt.Errorf("agent: unsupported signature flags: %d", flags)
		server.go#L199: 	return nil, fmt.Errorf("unknown opcode %d", data[0])
		server.go#L222: 			return 0, false, nil, fmt.Errorf("unknown constraint type: %d", constraints[0])
		server.go#L316: 		return nil, fmt.Errorf("agent: unknown curve %q", curveName)
		server.go#L390: 		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
		server.go#L434: 		return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
		server.go#L524: 		return fmt.Errorf("agent: not implemented: %q", record.Type)
		server.go#L545: 			return fmt.Errorf("agent: request size is 0")
		server.go#L549: 			return fmt.Errorf("agent: request too large: %d", l)
		server.go#L559: 			return fmt.Errorf("agent: reply too large: %d bytes", len(repData))

	golang.org/x/crypto/ssh/knownhosts
		knownhosts.go#L336: 		return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", remote, err)
		knownhosts.go#L344: 			return fmt.Errorf("knownhosts: SplitHostPort(%s): %v", address, err)
		knownhosts.go#L405: 			return fmt.Errorf("knownhosts: %s:%d: %v", filename, lineNum, err)
		knownhosts.go#L486: 		err = fmt.Errorf("knownhosts: got %d components, want 3", len(components))
		knownhosts.go#L532: 		return nil, fmt.Errorf("knownhosts: got hash type %s, must be '1'", typ)

	golang.org/x/mod/modfile
		print.go#L130: 		panic(fmt.Errorf("printer: unexpected type %T", x))
		read.go#L362: 				Err:      fmt.Errorf("internal error: %v", e),
		read.go#L644: 		panic(fmt.Errorf("order: unexpected type %T", x))
		rule.go#L166: 						Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
		rule.go#L177: 						Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
		rule.go#L230: 		wrapError(fmt.Errorf(format, args...))
		rule.go#L497: 		return VersionInterval{}, fmt.Errorf("expected '[' or version")
		rule.go#L510: 		return VersionInterval{}, fmt.Errorf("expected version after '['")
		rule.go#L519: 		return VersionInterval{}, fmt.Errorf("expected ',' after version")
		rule.go#L524: 		return VersionInterval{}, fmt.Errorf("expected version after ','")
		rule.go#L533: 		return VersionInterval{}, fmt.Errorf("expected ']' after version")
		rule.go#L552: 		return "", fmt.Errorf("unquoted string cannot contain quote")
		rule.go#L664: 		return "", fmt.Errorf("invalid module path")
		rule.go#L719: 		return fmt.Errorf("invalid language version string %q", version)

	golang.org/x/mod/module
		module.go#L285: 		return fmt.Errorf("malformed module path %q: %v", path, err)
		module.go#L292: 		return fmt.Errorf("malformed module path %q: leading slash", path)
		module.go#L295: 		return fmt.Errorf("malformed module path %q: missing dot in first path element", path)
		module.go#L298: 		return fmt.Errorf("malformed module path %q: leading dash in first path element", path)
		module.go#L302: 			return fmt.Errorf("malformed module path %q: invalid char %q in first path element", path, r)
		module.go#L306: 		return fmt.Errorf("malformed module path %q: invalid version", path)
		module.go#L330: 		return fmt.Errorf("malformed import path %q: %v", path, err)
		module.go#L343: 		return fmt.Errorf("invalid UTF-8")
		module.go#L346: 		return fmt.Errorf("empty string")
		module.go#L349: 		return fmt.Errorf("leading dash")
		module.go#L352: 		return fmt.Errorf("double slash")
		module.go#L355: 		return fmt.Errorf("trailing slash")
		module.go#L376: 		return fmt.Errorf("empty path element")
		module.go#L379: 		return fmt.Errorf("invalid path element %q", elem)
		module.go#L382: 		return fmt.Errorf("leading dot in path element")
		module.go#L385: 		return fmt.Errorf("trailing dot in path element")
		module.go#L393: 			return fmt.Errorf("invalid char %q", r)
		module.go#L405: 			return fmt.Errorf("%q disallowed as path element component on Windows", short)
		module.go#L427: 			return fmt.Errorf("trailing tilde and digits in path element")
		module.go#L448: 		return fmt.Errorf("malformed file path %q: %v", path, err)
		module.go#L569: 		Err:     fmt.Errorf("should be %s, not %s", pathMajor, semver.Major(v)),
		module.go#L653: 			Err:     fmt.Errorf("disallowed version string"),
		module.go#L665: 			return "", fmt.Errorf("internal error: inconsistency in EscapePath")
		module.go#L692: 		return "", fmt.Errorf("invalid escaped module path %q", escaped)
		module.go#L695: 		return "", fmt.Errorf("invalid escaped module path %q: %v", escaped, err)
		module.go#L707: 		return "", fmt.Errorf("invalid escaped version %q", escaped)
		module.go#L710: 		return "", fmt.Errorf("invalid escaped version %q: %v", v, err)

	golang.org/x/mod/zip
		zip.go#L165: 	errGoModSize       = fmt.Errorf("go.mod file too large (max size is %d bytes)", MaxGoMod)
		zip.go#L166: 	errLICENSESize     = fmt.Errorf("LICENSE file too large (max size is %d bytes)", MaxLICENSE)
		zip.go#L300: 			cf.SizeError = fmt.Errorf("module source tree too large (max size is %d bytes)", MaxZipFile)
		zip.go#L384: 		return nil, CheckedFiles{}, fmt.Errorf("version %q is not canonical (should be %q)", m.Version, vers)
		zip.go#L397: 		cf := CheckedFiles{SizeError: fmt.Errorf("module zip file is too large (%d bytes; limit is %d bytes)", zipSize, MaxZipFile)}
		zip.go#L415: 			addError(zf, fmt.Errorf("path does not have prefix %q", prefix))
		zip.go#L443: 				addError(zf, fmt.Errorf("go.mod file not in module root directory"))
		zip.go#L455: 			cf.SizeError = fmt.Errorf("total uncompressed size of module contents too large (max size is %d bytes)", MaxZipFile)
		zip.go#L458: 			addError(zf, fmt.Errorf("go.mod file too large (max size is %d bytes)", MaxGoMod))
		zip.go#L462: 			addError(zf, fmt.Errorf("LICENSE file too large (max size is %d bytes)", MaxLICENSE))
		zip.go#L490: 		return fmt.Errorf("version %q is not canonical (should be %q)", m.Version, vers)
		zip.go#L522: 			return fmt.Errorf("file %q is larger than declared size", path)
		zip.go#L618: 		return fmt.Errorf("target directory %v exists and is not empty", dir)
		zip.go#L669: 			return fmt.Errorf("uncompressed size of file %s is larger than declared size (%d bytes)", zf.Name, zf.UncompressedSize64)
		zip.go#L692: 			return fmt.Errorf("case-insensitive file name collision: %q and %q", other.path, p)
		zip.go#L695: 			return fmt.Errorf("entry %q is both a file and a directory", p)
		zip.go#L698: 			return fmt.Errorf("multiple entries for file %q", p)

	golang.org/x/net/html
		parse.go#L2380: 			return nil, fmt.Errorf("html: inconsistent Node: DataAtom=%q, Data=%q", context.DataAtom, context.Data)
		render.go#L178: 			return fmt.Errorf("html: void element <%s> has child nodes", n.Data)

	golang.org/x/net/http2
		server.go#L251: 				return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
		server.go#L255: 			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).")
		server.go#L968: 			errc <- fmt.Errorf("bogus greeting %q", buf)
		server.go#L1697: 		st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
		server.go#L1761: 		st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
		server.go#L2772: 			return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
		server.go#L2778: 			return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
		server.go#L2786: 			return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
		server.go#L2794: 			return fmt.Errorf("promised request headers cannot include %q", k)
		server.go#L2805: 		return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
		server.go#L2956: 			return fmt.Errorf("request header %q is not valid in HTTP/2", k)
		transport.go#L554: 	return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
		transport.go#L615: 		return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
		transport.go#L976: 			return "", fmt.Errorf("invalid Trailer key %q", k)
		transport.go#L1003: 		return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
		transport.go#L1006: 		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
		transport.go#L1009: 		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
		transport.go#L1490: 					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
		transport.go#L1492: 					return nil, fmt.Errorf("invalid request :path %q", orig)
		transport.go#L1503: 			return nil, fmt.Errorf("invalid HTTP header name %q", k)
		transport.go#L1507: 				return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
		transport.go#L2679: 			err = fmt.Errorf("%v", e)

	golang.org/x/oauth2/google
		default.go#L82: 			return nil, fmt.Errorf("google: error getting credentials using %v environment variable: %v", envVar, err)
		default.go#L92: 		return nil, fmt.Errorf("google: error getting credentials using well-known file (%v): %v", filename, err)
		default.go#L117: 	return nil, fmt.Errorf("google: could not find default credentials. See %v for more information.", url)
		google.go#L59: 		return nil, fmt.Errorf("oauth2/google: no credentials found")
		google.go#L86: 		return nil, fmt.Errorf("google: read JWT from JSON credentials: 'type' field is %q (expected %q)", f.Type, serviceAccountKey)
		google.go#L147: 		return nil, fmt.Errorf("unknown credential type: %q", f.Type)
		google.go#L192: 		return nil, fmt.Errorf("oauth2/google: invalid token JSON from metadata: %v", err)
		google.go#L195: 		return nil, fmt.Errorf("oauth2/google: incomplete token received from metadata")
		jwt.go#L29: 		return nil, fmt.Errorf("google: could not parse JSON key: %v", err)
		jwt.go#L33: 		return nil, fmt.Errorf("google: could not parse key: %v", err)
		jwt.go#L71: 		return nil, fmt.Errorf("google: could not encode JWT: %v", err)
		sdk.go#L57: 		return nil, fmt.Errorf("oauth2/google: error getting SDK config path: %v", err)
		sdk.go#L62: 		return nil, fmt.Errorf("oauth2/google: failed to load SDK credentials: %v", err)
		sdk.go#L68: 		return nil, fmt.Errorf("oauth2/google: failed to decode SDK credentials from %q: %v", credentialsPath, err)
		sdk.go#L71: 		return nil, fmt.Errorf("oauth2/google: no credentials found in %q, run `gcloud auth login` to create one", credentialsPath)
		sdk.go#L77: 			return nil, fmt.Errorf("oauth2/google: failed to load SDK properties: %v", err)
		sdk.go#L82: 			return nil, fmt.Errorf("oauth2/google: failed to parse SDK properties %q: %v", propertiesPath, err)
		sdk.go#L86: 			return nil, fmt.Errorf("oauth2/google: failed to find [core] section in %v", ini)
		sdk.go#L90: 			return nil, fmt.Errorf("oauth2/google: failed to find %q attribute in %v", "account", core)
		sdk.go#L98: 				return nil, fmt.Errorf("oauth2/google: no token available for account %q", account)
		sdk.go#L120: 	return nil, fmt.Errorf("oauth2/google: no such credentials for account %q", account)
		sdk.go#L173: 		return nil, fmt.Errorf("error scanning ini: %v", err)

	golang.org/x/oauth2/internal
		oauth2.go#L29: 			return nil, fmt.Errorf("private key should be a PEM or plain PKCS1 or PKCS8; parse error: %v", err)
		token.go#L239: 		return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)

	golang.org/x/oauth2/jws
		jws.go#L66: 		return "", fmt.Errorf("jws: invalid Exp = %v; must be later than Iat = %v", c.Exp, c.Iat)
		jws.go#L81: 		return "", fmt.Errorf("jws: invalid map of private claims %v", c.PrivateClaims)
		jws.go#L86: 		return "", fmt.Errorf("jws: invalid JSON %s", b)
		jws.go#L89: 		return "", fmt.Errorf("jws: invalid JSON %s", prv)

	golang.org/x/oauth2/jwt
		jwt.go#L136: 		return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
		jwt.go#L141: 		return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
		jwt.go#L157: 		return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)
		jwt.go#L174: 			return nil, fmt.Errorf("oauth2: error decoding JWT token: %v", err)
		jwt.go#L180: 			return nil, fmt.Errorf("oauth2: response doesn't have JWT token")

	golang.org/x/pkgsite/cmd/internal/cmdconfig
		cmdconfig.go#L104: 		return nil, fmt.Errorf("unable to register the ocsql driver: %v", err)

	golang.org/x/pkgsite/devtools/cmd/csphash
		main.go#L117: 		return nil, fmt.Errorf("%s: %v", filename, err)
		main.go#L143: 			return nil, fmt.Errorf("%s is missing an end tag", tag)

	golang.org/x/pkgsite/internal
		symbol.go#L127: 		return nil, fmt.Errorf("version %q could not be found: %q", v, name)
		symbol.go#L131: 		return nil, fmt.Errorf("symbol %q could not be found at version %q", name, v)
		symbol.go#L138: 	return nil, fmt.Errorf("symbol %q does not have build %v at version %q", name, build, v)

	golang.org/x/pkgsite/internal/auth
		auth.go#L46: 		return "", fmt.Errorf("TokenSource.Token(): %v", err)
		auth.go#L51: 		return "", fmt.Errorf("http.NewRequest(): %v", err)

	golang.org/x/pkgsite/internal/config
		config.go#L90: 			return fmt.Errorf("app version %q does not match time formats %q or %q: %v",
		config.go#L455: 			return nil, fmt.Errorf("could not get database password secret: %v", err)
		config.go#L575: 		return "", fmt.Errorf("http.NewRequest: %v", err)
		config.go#L580: 		return "", fmt.Errorf("ctxhttp.Do: %v", err)
		config.go#L584: 		return "", fmt.Errorf("bad status: %s", resp.Status)
		config.go#L588: 		return "", fmt.Errorf("ioutil.ReadAll: %v", err)

	golang.org/x/pkgsite/internal/cookie
		flash.go#L26: 		return "", fmt.Errorf("r.Cookie(%q): %v", name, err)

	golang.org/x/pkgsite/internal/database
		copy.go#L55: 			return fmt.Errorf("CopyFrom: %w", err)
		copy.go#L86: 			return fmt.Errorf("DB driver is not pgx or wrapper; conn type is %T", c)
		database.go#L97: 		return 0, fmt.Errorf("RowsAffected: %v", err)
		database.go#L212: 				return fmt.Errorf("error text has %q but not recognized as serialization failure: type %T, err %v",
		database.go#L221: 	return fmt.Errorf("reached max number of tries due to serialization failure (%d)", maxRetries)
		database.go#L249: 		return fmt.Errorf("conn.BeginTx(): %w", err)
		database.go#L259: 				err = fmt.Errorf("tx.Commit(): %w", txErr)
		database.go#L270: 		return fmt.Errorf("txFunc(tx): %w", err)
		database.go#L328: 		return fmt.Errorf("modulus of len(values) and len(columns) must be 0: got %d", remainder)
		database.go#L338: 		return fmt.Errorf("too many columns to insert: %d", len(columns))
		database.go#L375: 			return fmt.Errorf("running bulk insert query, values[%d:%d]): %w", leftBound, rightBound, err)
		database.go#L474: 			return fmt.Errorf("db.Exec(%q, values[%d:%d]): %w", query, left, right, err)
		reflect.go#L147: 		return fmt.Errorf("slice element type is neither struct nor struct pointer: %s", ve.Type().Elem())

	golang.org/x/pkgsite/internal/dcensus
		dcensus.go#L88: 		return fmt.Errorf("dcensus.Init(views): view.Register: %v", err)
		dcensus.go#L98: 		return nil, fmt.Errorf("dcensus.NewServer: prometheus.NewExporter: %v", err)

	golang.org/x/pkgsite/internal/derrors
		derrors.go#L173: 	return fmt.Errorf(format+": %w", append(args, innerErr)...)
		derrors.go#L220: 		*errp = fmt.Errorf("%s: %v", fmt.Sprintf(format, args...), *errp)
		derrors.go#L235: 		*errp = fmt.Errorf("%s: %w", fmt.Sprintf(format, args...), *errp)

	golang.org/x/pkgsite/internal/fetch
		fetch.go#L173: 			return nil, fmt.Errorf("%w: size=%dMi", derrors.SheddingLoad, zipSize/mib)
		fetch.go#L233: 			return fi, fmt.Errorf("%v: %w", err.Error(), derrors.BadModule)
		fetch.go#L280: 		return "", nil, fmt.Errorf("go.mod has no module path: %w", derrors.BadModule)
		fetch.go#L286: 		return goModPath, goModBytes, fmt.Errorf("module path=%s, go.mod path=%s: %w", modulePath, goModPath, derrors.AlternativeModule)
		fetch.go#L304: 		return nil, nil, fmt.Errorf("extractReadmesFromZip(%q, %q, zipReader): %v", modulePath, resolvedVersion, err)
		fetch.go#L313: 		return nil, nil, fmt.Errorf("%v: %w", err.Error(), derrors.BadModule)
		fetch.go#L316: 		return nil, nil, fmt.Errorf("extractPackagesFromZip(%q, %q, zipReader, %v): %v", modulePath, resolvedVersion, allLicenses, err)
		fetchlocal.go#L61: 		fr.Error = fmt.Errorf("%s: %w", err.Error(), derrors.NotFound)
		fetchlocal.go#L66: 		fr.Error = fmt.Errorf("%s not a directory: %w", localPath, derrors.NotFound)
		fetchlocal.go#L92: 			fr.Error = fmt.Errorf("module path=%s, go.mod path=%s: %w", modulePath, fr.GoModPath, derrors.AlternativeModule)
		fetchlocal.go#L98: 		fr.Error = fmt.Errorf("no module path: %w", derrors.BadModule)
		fetchlocal.go#L105: 		fr.Error = fmt.Errorf("couldn't create a zip: %s, %w", err.Error(), derrors.BadModule)
		latest.go#L128: 		return nil, fmt.Errorf("%v: %w", err, derrors.BadModule)
		load.go#L160: 					Err: fmt.Errorf("more than one package name (%q and %q)", pkg.name, name),
		load.go#L272: 				return "", nil, nil, fmt.Errorf("internal error: the source couldn't be read: %v", err)
		load.go#L342: 			return nil, &BadPackageError{Err: fmt.Errorf(`bctx.MatchFile(".", %q): %w`, name, err)}
		load.go#L361: 		return nil, fmt.Errorf("f.Open(): %v", err)
		load.go#L366: 		return nil, fmt.Errorf("ioutil.ReadAll(r): %v", err)
		load.go#L369: 		return nil, fmt.Errorf("closing: %v", err)
		package.go#L60: 			err = fmt.Errorf("internal panic: %v\n\n%s", e, debug.Stack())
		package.go#L117: 			return nil, nil, fmt.Errorf("expected file to have prefix %q; got = %q: %w",
		package.go#L166: 			return nil, nil, fmt.Errorf("%d packages found in %q; exceeds limit %d for maxPackagePerModule", len(dirs), modulePath, maxPackagesPerModule)
		package.go#L195: 			return nil, nil, fmt.Errorf("unexpected error loading package: %v", err)
		package.go#L212: 				return nil, nil, fmt.Errorf("bad package error for %s: %v", pkg.path, pkg.err)
		readme.go#L29: 				return nil, fmt.Errorf("file size %d exceeds max limit %d", zipFile.UncompressedSize64, MaxFileSize)

	golang.org/x/pkgsite/internal/frontend
		fetch.go#L233: 		return nil, fmt.Errorf("no results")
		fetch.go#L380: 			fr.err = fmt.Errorf("%v: %w", fr.err, context.DeadlineExceeded)
		fetch.go#L434: 			fr.err = fmt.Errorf("%q: %v", http.StatusText(fr.status), vm.Error)
		fetch.go#L527: 			err:    fmt.Errorf("isValidPath(%q): false", fullPath),
		fetch.go#L534: 			err:    fmt.Errorf("invalid path: %q", fullPath),
		overview.go#L56: 				walkErr = fmt.Errorf("couldn't transform html block(%s): %w", node.Literal, err)
		overview.go#L183: 			return nil, fmt.Errorf("top-level node is %q, expected 'html'", n.DataAtom)
		search.go#L280: 		return fmt.Errorf("fetchSearchPage(ctx, db, %q): %v", query, err)
		server.go#L81: 		return nil, fmt.Errorf("error parsing templates: %v", err)
		server.go#L103: 		return nil, fmt.Errorf("s.renderErrorPage(http.StatusInternalServerError, nil): %v", err)
		server.go#L492: 			return nil, fmt.Errorf("error parsing templates: %v", err)
		server.go#L497: 		return nil, fmt.Errorf("BUG: s.templates[%q] not found", templateName)
		server.go#L560: 			return nil, fmt.Errorf("ParseFiles: %v", err)
		server.go#L564: 			return nil, fmt.Errorf("ParseGlob(%q): %v", helperGlob, err)
		server.go#L572: 			return nil, fmt.Errorf("ParseFilesFromTrustedSources(%v): %v", files, err)
		server.go#L583: 			return nil, fmt.Errorf("ParseFilesFromTrustedSources: %v", err)
		server.go#L587: 			return nil, fmt.Errorf("ParseGlobFromTrustedSource(%q): %v", helperGlob, err)
		server.go#L592: 				return nil, fmt.Errorf("ParseGlobFromTrustedSource(%v): %v", files, err)
		tabs.go#L93: 	return nil, fmt.Errorf("BUG: unable to fetch details: unknown tab %q", tab)
		unit.go#L130: 			return fmt.Errorf("json.Marshal: %v", err)
		unit.go#L133: 			return fmt.Errorf("w.Write: %v", err)
		urlinfo.go#L110: 				err:         fmt.Errorf("invalid version: %q", info.requestedVersion),
		urlinfo.go#L127: 			err:         fmt.Errorf("isValidPath(%q) is false", info.fullPath),
		urlinfo.go#L143: 			err:         fmt.Errorf("isValidPath(%q) is false", fullPath),
		urlinfo.go#L160: 			err:         fmt.Errorf("invalid Go tag for url: %q", urlPath),

	golang.org/x/pkgsite/internal/godoc
		encode.go#L28: var ErrInvalidEncodingType = fmt.Errorf("want initial bytes to be %q but they aren't", fastEncodingType)
		encode.go#L84: 		return nil, fmt.Errorf("first decoded value is %T, wanted []byte", fsetBytes)
		encode.go#L96: 		return nil, fmt.Errorf("second decoded value is %T, wanted *encPackage", ep)
		render.go#L93: 		return nil, fmt.Errorf("doc.NewFromFiles: %v", err)
		render.go#L97: 		panic(fmt.Errorf("internal error: *doc.Package has an unexpected import path (%q != %q)", d.ImportPath, importPath))
		render.go#L110: 		return nil, fmt.Errorf("%d imports found package %q; exceeds limit %d for maxImportsPerPackage", len(d.Imports), importPath, maxImportsPerPackage)
		render.go#L203: 		return nil, fmt.Errorf("dochtml.Render: %v", err)

	golang.org/x/pkgsite/internal/godoc/codec
		codec.go#L66: 	fail(fmt.Errorf(format, args...))
		generate.go#L119: 		return fmt.Errorf("format.Source: %v", err)

	golang.org/x/pkgsite/internal/godoc/dochtml
		dochtml.go#L325: 		return safehtml.HTML{}, fmt.Errorf("dochtml.Render: %w", ErrTooLarge)
		dochtml.go#L327: 		return safehtml.HTML{}, fmt.Errorf("dochtml.Render: %v", err)
		symbol.go#L113: 			return nil, fmt.Errorf("unexpected number of t.Decl.Specs: %d (wanted len = 1)", len(typ.Decl.Specs))
		symbol.go#L117: 			return nil, fmt.Errorf("unexpected type for Spec node: %q", typ.Name)
		symbol.go#L234: 				return nil, fmt.Errorf("len(m.Names) = %d; expected 0 or 1", len(m.Names))

	golang.org/x/pkgsite/internal/godoc/dochtml/internal/render
		short_synopsis.go#L20: 		return "", fmt.Errorf("only *ast.FuncDecl nodes are supported at top level")

	golang.org/x/pkgsite/internal/godoc/internal/doc
		doc.go#L175: 		panic(fmt.Errorf("doc.NewFromFiles: no token.FileSet provided (fset == nil)"))
		doc.go#L184: 			panic(fmt.Errorf("doc.NewFromFiles: option argument type must be doc.Mode"))
		doc.go#L188: 		panic(fmt.Errorf("doc.NewFromFiles: there must not be more than 1 option argument"))
		doc.go#L199: 			return nil, fmt.Errorf("file files[%d] is not found in the provided file set", i)
		doc.go#L207: 			return nil, fmt.Errorf("file files[%d] filename %q does not have a .go extension", i, name)

	golang.org/x/pkgsite/internal/index
		index.go#L40: 		return nil, fmt.Errorf("url.Parse(%q): %v", rawurl, err)
		index.go#L43: 		return nil, fmt.Errorf("scheme must be https (got %s)", u.Scheme)
		index.go#L64: 		return nil, fmt.Errorf("ctxhttp.Get(ctx, nil, %q): %v", u, err)
		index.go#L76: 			return nil, fmt.Errorf("decoding JSON: %v", err)

	golang.org/x/pkgsite/internal/licenses
		licenses.go#L563: 		return nil, fmt.Errorf("file size %d exceeds max license size %d", f.UncompressedSize64, maxLicenseSize)

	golang.org/x/pkgsite/internal/localdatasource
		datasource.go#L60: 		return fmt.Errorf("path %s doesn't exist: %w", importPath, derrors.NotFound)
		datasource.go#L120: 		return nil, fmt.Errorf("%s not loaded: %w", modulepath, derrors.NotFound)
		datasource.go#L130: 	return nil, fmt.Errorf("%s not found: %w", path, derrors.NotFound)
		datasource.go#L148: 		return nil, fmt.Errorf("%s not loaded: %w", requestedModulePath, derrors.NotFound)
		datasource.go#L187: 	return "", fmt.Errorf("%s not loaded: %w", pkgPath, derrors.NotFound)

	golang.org/x/pkgsite/internal/middleware
		caching.go#L234: 				r.bufErr = fmt.Errorf("wrote %d to zip, but wanted %d", zn, n)
		caching.go#L237: 			r.bufErr = fmt.Errorf("ResponseWriter.Write failed: %v", err)
		errorreporting.go#L44: 				Error: fmt.Errorf("handler for %q returned status code %d", r.URL.Path, w2.status),
		experiment.go#L59: 						Error: fmt.Errorf("loading experiments: %v", err),
		iapheader.go#L41: 		return fmt.Errorf("validating IPA token: %v", err)

	golang.org/x/pkgsite/internal/postgres
		details.go#L50: 			return fmt.Errorf("rows.Scan(): %v", err)
		details.go#L84: 		return nil, fmt.Errorf("pkgPath cannot be empty: %w", derrors.InvalidArgument)
		details.go#L108: 		return 0, fmt.Errorf("pkgPath cannot be empty: %w", derrors.InvalidArgument)
		details.go#L154: 		return nil, fmt.Errorf("row.Scan(): %v", err)
		insert_module.go#L49: 		return false, fmt.Errorf("empty commit time: %w", derrors.BadModule)
		insert_module.go#L271: 				return fmt.Errorf("marshalling %+v: %v", l.OldCoverage, err)
		insert_module.go#L276: 				return fmt.Errorf("marshalling %+v: %v", l.Coverage, err)
		insert_module.go#L371: 			return fmt.Errorf("no entry in paths table for %q; should be impossible", u.Path)
		insert_module.go#L388: 				return fmt.Errorf("insertUnits: unit %q missing source files for %q, %q", u.Path, d.GOOS, d.GOARCH)
		insert_module.go#L768: 			err = fmt.Errorf("%v: %w", err, derrors.DBModuleInsertInvalid)
		insert_module.go#L776: 		return fmt.Errorf("nil module")
		insert_module.go#L797: 		return fmt.Errorf("cannot insert module %q: %s", m.Version, strings.Join(errReasons, ", "))
		insert_module.go#L818: 			return fmt.Errorf("expected license %q in module: %w", l.FilePath, derrors.DBModuleInsertInvalid)
		insert_module.go#L839: 			return fmt.Errorf("expected unit %q in module: %w", p.path, derrors.DBModuleInsertInvalid)
		insert_symbol_history.go#L130: 		return nil, fmt.Errorf("symbolID cannot be 0: %q", sm.Name)
		insert_symbol_history.go#L137: 		return nil, fmt.Errorf("parentSymbolID cannot be 0: %q", sm.ParentName)
		insert_symbol_history.go#L141: 		return nil, fmt.Errorf("packagePathID cannot be 0: %q", packagePathID)
		insert_symbol_history.go#L145: 		return nil, fmt.Errorf("modulePathID cannot be 0: %q", modulePathID)
		licenses.go#L116: 			return nil, fmt.Errorf("row.Scan(): %v", err)
		licenses.go#L164: 		return nil, fmt.Errorf("BUG: got %d license types and %d license paths", len(licenseTypes), len(licensePaths))
		package_symbol.go#L47: 				return fmt.Errorf("could not find parent for %q: %v", sm.Name, err)
		package_symbol.go#L93: 			return fmt.Errorf("row.Scan(): %v", err)
		package_symbol.go#L96: 			return fmt.Errorf("check(): %v", err)
		package_symbol.go#L180: 			return fmt.Errorf("row.Scan(): %v", err)
		path.go#L62: 			return "", 0, fmt.Errorf("bad module path %q", modPath)
		search.go#L226: 		return nil, fmt.Errorf("%q search failed: %v", resp.source, resp.err)
		search.go#L279: 			return fmt.Errorf("rows.Scan(): %v", err)
		search.go#L315: 			return fmt.Errorf("rows.Scan(): %v", err)
		search.go#L391: 			return fmt.Errorf("symbolSearch: rows.Scan(): %v", err)
		search.go#L474: 			return fmt.Errorf("rows.Scan(): %v", err)
		search.go#L478: 			return fmt.Errorf("BUG: unexpected package path: %q", path)
		search.go#L839: 		return fmt.Errorf("CREATE TABLE: %v", err)
		search.go#L924: 		return 0, fmt.Errorf("error updating imported_by_count and imported_by_count_updated_at for search documents: %v", err)
		symbol.go#L70: 					return fmt.Errorf("path could not be found: %q", path)
		symbol.go#L75: 					return fmt.Errorf("package symbol could not be found: %v", ps)
		symbol.go#L102: 			return fmt.Errorf("row.Scan(): %v", err)
		symbol.go#L185: 		return nil, fmt.Errorf("modulePathID cannot be 0: %q", modulePath)
		symbol.go#L194: 			return fmt.Errorf("row.Scan(): %v", err)
		symbol.go#L203: 			return fmt.Errorf("symbol name cannot be empty: %d", symbolID)
		symbol.go#L251: 			return nil, fmt.Errorf("pathID cannot be 0: %q", path)
		symbol.go#L263: 					return fmt.Errorf("symID cannot be 0: %q", sm.Name)
		symbol.go#L270: 					return fmt.Errorf("parentSymID cannot be 0: %q", sm.ParentName)
		symbol.go#L326: 			return fmt.Errorf("row.Scan(): %v", err)
		symbol.go#L330: 			return fmt.Errorf("id can't be 0: %q", name)
		symbol.go#L391: 			return fmt.Errorf("row.Scan(): %v", err)
		symbol.go#L413: 					return fmt.Errorf("build context %v for parent type %q could not be found for symbol %q", build, sm.ParentName, sm.Name)
		symbol.go#L417: 					return fmt.Errorf("parent type %q could not be found for symbol %q", sm.ParentName, sm.Name)
		symbol_history.go#L126: 			return fmt.Errorf("row.Scan(): %v", err)
		test_helper.go#L60: 		return false, fmt.Errorf("migrate.New(): %v", err)
		test_helper.go#L68: 		return true, fmt.Errorf("m.Up(): %v", err)
		test_helper.go#L79: 		return nil, fmt.Errorf("CreateDBIfNotExists(%q): %w", dbName, err)
		test_helper.go#L86: 				return nil, fmt.Errorf("recreateDB(%q): %v", dbName, err)
		test_helper.go#L91: 			return nil, fmt.Errorf("unfixable error migrating database: %v.\nConsider running ./devtools/drop_test_dbs.sh", err)
		unit.go#L393: 			return fmt.Errorf("row.Scan(): %v", err)
		unit.go#L616: 			return fmt.Errorf("row.Scan(): %v", err)
		version.go#L81: 		return nil, fmt.Errorf("error: must specify at least one version type")
		version.go#L90: 			return fmt.Errorf("row.Scan(): %v", err)
		version_map.go#L73: 		return nil, fmt.Errorf("modulePath must be specified: %w", derrors.InvalidArgument)
		version_map.go#L123: 		return nil, fmt.Errorf("squirrel.ToSql: %v", err)
		versionstate.go#L138: 		return fmt.Errorf("module version state update affected %d rows, expected exactly 1", affected)
		versionstate.go#L159: 		return fmt.Errorf("module status update affected %d rows, expected at most 1", affected)
		versionstate.go#L288: 			return nil, fmt.Errorf("rows.Scan(): %v", err)
		versionstate.go#L344: 		return nil, fmt.Errorf("row.Scan(): %v", err)
		versionstate.go#L371: 			return fmt.Errorf("rows.Scan(): %v", err)
		versionstate.go#L411: 		return nil, fmt.Errorf("row.Scan(): %v", err)
		versionstate.go#L447: 			return fmt.Errorf("row.Scan(): %v", err)

	golang.org/x/pkgsite/internal/proxy
		client.go#L144: 		return nil, fmt.Errorf("zip.NewReader: %v: %w", err, derrors.BadModule)
		client.go#L165: 		return 0, fmt.Errorf("ctxhttp.Head(ctx, client, %q): %v", url, err)
		client.go#L185: 		return "", fmt.Errorf("path: %v: %w", err, derrors.InvalidArgument)
		client.go#L189: 			return "", fmt.Errorf("cannot ask for latest with suffix %q", suffix)
		client.go#L195: 		return "", fmt.Errorf("version: %v: %w", err, derrors.InvalidArgument)
		client.go#L224: 		return nil, fmt.Errorf("module.EscapePath(%q): %w", modulePath, derrors.InvalidArgument)
		client.go#L246: 			err = fmt.Errorf("%v: %w", err, derrors.ProxyTimedOut)
		client.go#L260: 		return fmt.Errorf("ctxhttp.Do(ctx, client, %q): %v", u, err)
		client.go#L288: 			return fmt.Errorf("ioutil.readall: %v", err)
		client.go#L299: 		return fmt.Errorf("%q: %w", d, err)
		client.go#L301: 		return fmt.Errorf("unexpected status %d %s", r.StatusCode, r.Status)
		test_helper.go#L79: 		return nil, fmt.Errorf("%s: filename missing '@'", modver)
		test_helper.go#L84: 		return nil, fmt.Errorf("%s: empty module path or version", filename)

	golang.org/x/pkgsite/internal/proxydatasource
		datasource.go#L178: 	return "", nil, fmt.Errorf("unable to find module: %w", derrors.NotFound)
		datasource.go#L193: 	return nil, fmt.Errorf("%q missing from module %s: %w", fullPath, m.ModulePath, derrors.NotFound)

	golang.org/x/pkgsite/internal/queue
		queue.go#L138: 			return false, fmt.Errorf("q.client.CreateTask(ctx, req): %v", err)

	golang.org/x/pkgsite/internal/source
		meta-tags.go#L149: 		return nil, fmt.Errorf("%s: %w", errorMessage, derrors.NotFound)
		source.go#L238: 		return nil, fmt.Errorf("c.httpClient cannot be nil")
		source.go#L250: 		return nil, fmt.Errorf("status %s", resp.Status)

	golang.org/x/pkgsite/internal/static
		static.go#L62: 		return nil, fmt.Errorf("error building static files: %v", result.Errors)
		static.go#L65: 		return nil, fmt.Errorf("error building static files: %v", result.Warnings)

	golang.org/x/pkgsite/internal/stdlib
		stdlib.go#L103: 		return "", fmt.Errorf("%w: requested version is not a valid semantic version: %q ", derrors.InvalidArgument, version)
		stdlib.go#L120: 				return "", fmt.Errorf("%w: final digits in a prerelease must follow a period", derrors.InvalidArgument)
		stdlib.go#L144: 		return "", fmt.Errorf("no '.' in go tag %q", tag)
		stdlib.go#L250: 			return nil, fmt.Errorf("re.List: %v", err)
		stdlib.go#L412: 	return "", fmt.Errorf("%w: requested version unknown: %q", derrors.InvalidArgument, requestedVersion)

	golang.org/x/pkgsite/internal/symbol
		apigodoc.go#L60: 		return nil, fmt.Errorf("apiVersions should not be empty")
		apigodoc.go#L79: 		return nil, fmt.Errorf("no files matching %q", apiGlob)

	golang.org/x/pkgsite/internal/testing/dbtest
		dbtest.go#L72: 		return fmt.Errorf("%w: %v", derrors.NotFound, err)
		dbtest.go#L90: 			return fmt.Errorf("error creating %q: %v", dbName, err)
		dbtest.go#L101: 			return fmt.Errorf("error dropping %q: %v", dbName, err)

	golang.org/x/pkgsite/internal/testing/htmlcheck
		htmlcheck.go#L51: 			return fmt.Errorf("no element matches selector %q", selector)
		htmlcheck.go#L57: 			return fmt.Errorf("%s: %v", selector, err)
		htmlcheck.go#L70: 				return fmt.Errorf("%s, #%d: %v", selector, i, err)
		htmlcheck.go#L90: 			return fmt.Errorf("%q matched one or more elements", selector)
		htmlcheck.go#L135: 			return fmt.Errorf("\n`%s` does not match\n%q", wantRegexp, text)
		htmlcheck.go#L180: 					return fmt.Errorf("[%q]:\n`%s` does not match\n%q", name, wantValRegexp, a.Val)
		htmlcheck.go#L185: 		return fmt.Errorf("[%q]: no such attribute", name)

	golang.org/x/pkgsite/internal/testing/testhelper
		testhelper.go#L78: 			err = fmt.Errorf("error: %v, close error: %v", err, cerr)
		testhelper.go#L85: 			return fmt.Errorf("ZipWriter::Create(): %v", err)
		testhelper.go#L89: 			return fmt.Errorf("io.WriteString(...): %v", err)
		testhelper.go#L99: 		return nil, fmt.Errorf("testhelper.ZipContents(%v): %v", contents, err)

	golang.org/x/pkgsite/internal/version
		version.go#L52: 		return "", fmt.Errorf("ParseType(%q): invalid semver", version)

	golang.org/x/pkgsite/internal/worker
		fetch.go#L154: 			ft.Error = fmt.Errorf("db.UpsertModuleVersionState: %v, original error: %v", err, ft.Error)
		fetch.go#L303: 		return fmt.Errorf("%d errors, first is %w", len(errs), errs[0])
		memory.go#L46: 			err = fmt.Errorf("got %+v, want 3 words, third is 'kB'", words)
		memory.go#L174: 			return nil, fmt.Errorf("memory.stat: %q: not two fields", scan.Text())
		server.go#L351: 			return "", "", fmt.Errorf("invalid module path: %q", modulePath)
		server.go#L357: 		return "", "", fmt.Errorf("invalid path: %q", requestPath)
		server.go#L360: 		return "", "", fmt.Errorf("invalid path: %q", requestPath)
		server.go#L480: 			return fmt.Errorf("error scheduling fetch for %s: %w", "master", err)
		server.go#L490: 		return fmt.Errorf("handlePopulateStdLib: %v", err)
		server.go#L504: 			return "", fmt.Errorf("error scheduling fetch for %s: %w", v, err)
		server.go#L516: 		return &serverError{http.StatusBadRequest, fmt.Errorf("config.ValidateAppVersion(%q): %v", appVersion, err)}
		server.go#L535: 			return &serverError{http.StatusBadRequest, fmt.Errorf("status is invalid: %q", status)}

	golang.org/x/text/unicode/norm
		iter.go#L76: 		return 0, fmt.Errorf("norm: invalid whence")
		iter.go#L79: 		return 0, fmt.Errorf("norm: negative position")

	google.golang.org/api/idtoken
		cache.go#L56: 		return nil, fmt.Errorf("idtoken: unable to retrieve cert, got status code %d", resp.StatusCode)
		compute.go#L22: 		return nil, fmt.Errorf("idtoken: WithCustomClaims can't be used with the metadata service, please provide a service account if you would like to use this feature")
		compute.go#L48: 		return nil, fmt.Errorf("idtoken: invalid response from metadata service")
		idtoken.go#L41: 		return nil, fmt.Errorf("idtoken: option.WithoutAuthentication not supported")
		idtoken.go#L44: 		return nil, fmt.Errorf("idtoken: option.WithAPIKey not supported")
		idtoken.go#L47: 		return nil, fmt.Errorf("idtoken: option.WithTokenSource not supported")
		idtoken.go#L69: 		return nil, fmt.Errorf("idtoken: must supply a non-empty audience")
		idtoken.go#L79: 		return nil, fmt.Errorf("idtoken: option.WithTokenSource not supported")
		idtoken.go#L82: 		return nil, fmt.Errorf("idtoken: option.WithImpersonatedCredentials not supported")
		idtoken.go#L100: 	return nil, fmt.Errorf("idtoken: couldn't find any credentials")
		idtoken.go#L131: 		return fmt.Errorf("idtoken: credential provided is 0 bytes")
		idtoken.go#L140: 		return fmt.Errorf("idtoken: credential must be service_account, found %q", f.Type)
		validate.go#L134: 		return nil, fmt.Errorf("idtoken: audience provided does not match aud claim in the JWT")
		validate.go#L138: 		return nil, fmt.Errorf("idtoken: token expired")
		validate.go#L151: 		return nil, fmt.Errorf("idtoken: expected JWT signed with RS256 or ES256 but found %q", header.Algorithm)
		validate.go#L208: 		return fmt.Errorf("idtoken: ES256 signature not valid")
		validate.go#L215: 		return nil, fmt.Errorf("idtoken: cert response is nil")
		validate.go#L222: 	return nil, fmt.Errorf("idtoken: could not find matching cert keyId for the token provided")
		validate.go#L228: 		return nil, fmt.Errorf("idtoken: invalid token, token must have three segments; found %d", len(segments))
		validate.go#L241: 		return nil, fmt.Errorf("idtoken: unable to decode JWT header: %v", err)
		validate.go#L250: 		return nil, fmt.Errorf("idtoken: unable to decode JWT payload: %v", err)
		validate.go#L259: 		return nil, fmt.Errorf("idtoken: unable to decode JWT signature: %v", err)
		validate.go#L273: 		return h, fmt.Errorf("idtoken: unable to unmarshal JWT header: %v", err)
		validate.go#L286: 		return nil, fmt.Errorf("idtoken: unable to unmarshal JWT payload: %v", err)
		validate.go#L289: 		return nil, fmt.Errorf("idtoken: unable to unmarshal JWT payload claims: %v", err)

	google.golang.org/api/internal
		creds.go#L42: 			return nil, fmt.Errorf("cannot read credentials file: %v", err)
		creds.go#L99: 			return nil, fmt.Errorf("multiple audiences support is not implemented")

	google.golang.org/api/internal/gensupport
		json.go#L74: 				return nil, fmt.Errorf("field %q in NullFields has non-empty value", f.Name)
		json.go#L88: 				return nil, fmt.Errorf("field %q has keys in NullFields but is not a map[string]string", f.Name)
		json.go#L151: 		return tag, fmt.Errorf("malformed json tag: %s", val)
		json.go#L163: 		return tag, fmt.Errorf("malformed json tag: %s", val)
		jsonfloat.go#L41: 			return fmt.Errorf("google.golang.org/api/internal: bad float string %q", s)
		media.go#L134: 				pw.CloseWithError(fmt.Errorf("googleapi: CreatePart failed: %v", err))
		media.go#L140: 				pw.CloseWithError(fmt.Errorf("googleapi: Copy failed: %v", err))

	google.golang.org/api/internal/impersonate
		impersonate.go#L37: 		return nil, fmt.Errorf("impersonate: scopes must be provided")
		impersonate.go#L93: 		return nil, fmt.Errorf("impersonate: unable to marshal request: %v", err)
		impersonate.go#L98: 		return nil, fmt.Errorf("impersonate: unable to create request: %v", err)
		impersonate.go#L105: 		return nil, fmt.Errorf("impersonate: unable to generate access token: %v", err)
		impersonate.go#L110: 		return nil, fmt.Errorf("impersonate: unable to read body: %v", err)
		impersonate.go#L113: 		return nil, fmt.Errorf("impersonate: status code %d: %s", c, body)
		impersonate.go#L118: 		return nil, fmt.Errorf("impersonate: unable to parse response: %v", err)
		impersonate.go#L122: 		return nil, fmt.Errorf("impersonate: unable to parse expiry: %v", err)

	google.golang.org/api/iterator
		iterator.go#L213: 		return "", fmt.Errorf("slicep should be of type %s, got %T", wantSliceType, slicep)

	google.golang.org/api/transport/cert
		default_cert.go#L80: 		return nil, fmt.Errorf("cert: could not parse JSON in %q: %v", filename, err)
		default_cert.go#L83: 		return nil, fmt.Errorf("cert: invalid config in %q: %v", filename, err)

	google.golang.org/grpc
		balancer_conn_wrappers.go#L133: 		return nil, fmt.Errorf("grpc: cannot create SubConn with empty address list")
		balancer_conn_wrappers.go#L138: 		return nil, fmt.Errorf("grpc: ClientConn balancer wrapper was closed")
		clientconn.go#L188: 			return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
		clientconn.go#L224: 				conn, err = nil, fmt.Errorf("%v: %v", ctx.Err(), err)
		clientconn.go#L262: 			return nil, fmt.Errorf("could not get resolver for default scheme: %q", cc.parsedTarget.Scheme)
		clientconn.go#L309: 		return nil, fmt.Errorf("failed to build resolver: %v", err)
		pickfirst.go#L57: 			Picker: &picker{err: fmt.Errorf("name resolver error: %v", err)},
		pickfirst.go#L79: 				Picker: &picker{err: fmt.Errorf("error creating connection: %v", err)},
		proxy.go#L98: 		return nil, fmt.Errorf("failed to write the HTTP request: %v", err)
		proxy.go#L104: 		return nil, fmt.Errorf("reading server HTTP response: %v", err)
		proxy.go#L110: 			return nil, fmt.Errorf("failed to do connect handshake, status code: %s", resp.Status)
		proxy.go#L112: 		return nil, fmt.Errorf("failed to do connect handshake, response: %q", dump)
		proxy.go#L149: 		return fmt.Errorf("failed to write the HTTP request: %v", err)
		rpc_util.go#L76: 		return nil, fmt.Errorf("grpc: invalid compression level: %d", level)
		service_config.go#L188: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L192: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L201: 			return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
		service_config.go#L208: 			return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L212: 			return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
		service_config.go#L221: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L275: 		return &serviceconfig.ParseResult{Err: fmt.Errorf("no JSON service config provided")}
		service_config.go#L353: 			return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: maxTokens (%v) out of range (0, 1000]", mt)}
		service_config.go#L356: 			return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: tokenRatio (%v) may not be negative", tr)}

	google.golang.org/grpc/balancer/base
		balancer.go#L143: 		return fmt.Errorf("last resolver error: %v", b.resolverErr)
		balancer.go#L146: 		return fmt.Errorf("last connection error: %v", b.connErr)
		balancer.go#L148: 	return fmt.Errorf("last connection error: %v; last resolver error: %v", b.connErr, b.resolverErr)

	google.golang.org/grpc/balancer/grpclb
		grpclb_remote_balancer.go#L275: 			return fmt.Errorf("grpclb: failed to recv server list: %v", err)
		grpclb_remote_balancer.go#L327: 		return true, fmt.Errorf("grpclb: failed to perform RPC to the remote balancer %v", err)
		grpclb_remote_balancer.go#L342: 		return true, fmt.Errorf("grpclb: failed to send init request: %v", err)
		grpclb_remote_balancer.go#L346: 		return true, fmt.Errorf("grpclb: failed to recv init response: %v", err)
		grpclb_remote_balancer.go#L350: 		return true, fmt.Errorf("grpclb: reply from remote balancer did not include initial response")
		grpclb_util.go#L125: 		return nil, fmt.Errorf("grpclb calling NewSubConn with addrs of length %v", len(addrs))

	google.golang.org/grpc/balancer/grpclb/grpc_lb_v1
		load_balancer.pb.go#L20: var _ = fmt.Errorf

	google.golang.org/grpc/binarylog/grpc_binarylog_v1
		binarylog.pb.go#L16: var _ = fmt.Errorf

	google.golang.org/grpc/codes
		codes.go#L227: 		return fmt.Errorf("nil receiver passed to UnmarshalJSON")
		codes.go#L232: 			return fmt.Errorf("invalid code: %q", ci)
		codes.go#L243: 	return fmt.Errorf("invalid code: %q", string(b))

	google.golang.org/grpc/credentials
		credentials.go#L246: 			return fmt.Errorf("requires SecurityLevel %v; connection has %v", level, ci.GetCommonAuthInfo().SecurityLevel)
		tls.go#L175: 		return nil, fmt.Errorf("credentials: failed to append certificates")

	google.golang.org/grpc/credentials/alts
		alts.go#L219: 		return nil, nil, fmt.Errorf("server-side RPC versions are not compatible with this client, local versions: %v, peer versions: %v", opts.RPCVersions, altsAuthInfo.PeerRPCVersions())
		alts.go#L262: 		return nil, nil, fmt.Errorf("client-side RPC versions is not compatible with this server, local versions: %v, peer versions: %v", opts.RPCVersions, altsAuthInfo.PeerRPCVersions())
		utils.go#L120: 		return nil, fmt.Errorf("failed reading %v: %v", linuxProductNameFile, err)

	google.golang.org/grpc/credentials/alts/internal/conn
		common.go#L63: 		return nil, nil, fmt.Errorf("received the frame length %d larger than the limit %d", length, maxLen)
		record.go#L75: 		return fmt.Errorf("protocol %v is already registered", protocol)
		record.go#L106: 		return nil, fmt.Errorf("negotiated unknown next_protocol %q", recordProtocol)
		record.go#L110: 		return nil, fmt.Errorf("protocol %q: %v", recordProtocol, err)
		record.go#L183: 			return 0, fmt.Errorf("received frame with incorrect message type %v, expected lower byte %v",

	google.golang.org/grpc/credentials/alts/internal/handshaker
		handshaker.go#L284: 			return nil, nil, fmt.Errorf("%v", resp.GetStatus().Details)
		handshaker.go#L303: 		return nil, nil, fmt.Errorf("unknown resulted record protocol %v", result.RecordProtocol)

	google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp
		altscontext.pb.go#L14: var _ = fmt.Errorf
		handshaker.pb.go#L18: var _ = fmt.Errorf
		transport_security_common.pb.go#L14: var _ = fmt.Errorf

	google.golang.org/grpc/credentials/google
		google.go#L119: 		return nil, fmt.Errorf("unsupported mode: %v", mode)

	google.golang.org/grpc/credentials/oauth
		oauth.go#L46: 		return nil, fmt.Errorf("unable to transfer TokenSource PerRPCCredentials: %v", err)
		oauth.go#L66: 		return nil, fmt.Errorf("credentials: failed to read the service account key file: %v", err)
		oauth.go#L88: 		return nil, fmt.Errorf("unable to transfer jwtAccess PerRPCCredentials: %v", err)
		oauth.go#L111: 		return nil, fmt.Errorf("unable to transfer oauthAccess PerRPCCredentials: %v", err)
		oauth.go#L148: 		return nil, fmt.Errorf("unable to transfer serviceAccount PerRPCCredentials: %v", err)
		oauth.go#L174: 		return nil, fmt.Errorf("credentials: failed to read the service account key file: %v", err)

	google.golang.org/grpc/internal/binarylog
		binarylog.go#L93: 		return fmt.Errorf("conflicting global rules found")
		binarylog.go#L104: 		return fmt.Errorf("conflicting service rules for service %v found", service)
		binarylog.go#L118: 		return fmt.Errorf("conflicting blacklist rules for method %v found", method)
		binarylog.go#L121: 		return fmt.Errorf("conflicting method rules for method %v found", method)
		binarylog.go#L133: 		return fmt.Errorf("conflicting blacklist rules for method %v found", method)
		binarylog.go#L136: 		return fmt.Errorf("conflicting method rules for method %v found", method)
		env_config.go#L72: 			return fmt.Errorf("invalid config: %q, %v", config, err)
		env_config.go#L75: 			return fmt.Errorf("invalid config: %q, %v", config, "* not allowed in blacklist config")
		env_config.go#L78: 			return fmt.Errorf("invalid config: %q, %v", config, "header/message limit not allowed in blacklist config")
		env_config.go#L81: 			return fmt.Errorf("invalid config: %v", err)
		env_config.go#L90: 			return fmt.Errorf("invalid config: %q, %v", config, err)
		env_config.go#L93: 			return fmt.Errorf("invalid config: %v", err)
		env_config.go#L100: 		return fmt.Errorf("invalid config: %q, %v", config, err)
		env_config.go#L104: 		return fmt.Errorf("invalid header/message length config: %q, %v", suffix, err)
		env_config.go#L108: 			return fmt.Errorf("invalid config: %v", err)
		env_config.go#L112: 			return fmt.Errorf("invalid config: %v", err)
		env_config.go#L149: 		return "", "", "", fmt.Errorf("%q contains invalid substring", c)
		env_config.go#L169: 				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
		env_config.go#L181: 				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
		env_config.go#L196: 				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
		env_config.go#L202: 				return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
		env_config.go#L207: 	return 0, 0, fmt.Errorf("%q contains invalid substring", c)
		sink.go#L158: 		return nil, fmt.Errorf("failed to create temp file: %v", err)

	google.golang.org/grpc/internal/channelz
		funcs.go#L134: 		err = fmt.Errorf("after 10s the channelz map has not been cleaned up yet, topchannels: %d, servers: %d, channels: %d, subchannels: %d, listen sockets: %d, normal sockets: %d", len(cm.topLevelChannels), len(cm.servers), len(cm.channels), len(cm.subChannels), len(cm.listenSockets), len(cm.normalSockets))

	google.golang.org/grpc/internal/resolver/dns
		dns_resolver.go#L254: 				return nil, fmt.Errorf("dns: error parsing A record IP address %v", a)
		dns_resolver.go#L276: 		err = fmt.Errorf("dns: %v record lookup error: %v", lookupType, err)
		dns_resolver.go#L318: 			return nil, fmt.Errorf("dns: error parsing A record IP address %v", a)
		dns_resolver.go#L390: 	return "", "", fmt.Errorf("invalid target address %v, error info: %v", target, err)

	google.golang.org/grpc/internal/serviceconfig
		serviceconfig.go#L65: 			return fmt.Errorf("invalid loadBalancingConfig: entry %v does not contain exactly 1 policy/config pair: %q", i, lbcfg)
		serviceconfig.go#L96: 			return fmt.Errorf("error parsing loadBalancingConfig for policy %q: %v", name, err)
		serviceconfig.go#L105: 	return fmt.Errorf("invalid loadBalancingConfig: no supported policies found")

	google.golang.org/grpc/internal/transport
		controlbuf.go#L801: 		return fmt.Errorf("transport: unknown control message type %T", i)
		flowcontrol.go#L186: 		return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", rcvd, limit)
		http2_server.go#L1180: 			return false, fmt.Errorf("transport: Connection closing")
		http_util.go#L420: 		return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
		http_util.go#L424: 		return 0, fmt.Errorf("transport: timeout string is too long: %q", s)
		http_util.go#L429: 		return 0, fmt.Errorf("transport: timeout unit is not recognized: %q", s)

	google.golang.org/protobuf/encoding/protojson
		well_known_types.go#L239: var errEmptyObject = fmt.Errorf(`empty object`)
		well_known_types.go#L240: var errMissingType = fmt.Errorf(`missing "@type" field`)

	gopkg.in/yaml.v2
		yaml.go#L263: 	panic(yamlError{fmt.Errorf("yaml: "+format, args...)})

	html/template
		template.go#L34: var escapeOK = fmt.Errorf("template escaped correctly")
		template.go#L90: 		return fmt.Errorf("html/template: cannot Parse after Execute")
		template.go#L102: 			return fmt.Errorf("template: %q is an incomplete or empty template", t.Name())
		template.go#L151: 		return nil, fmt.Errorf("html/template: %q is undefined", name)
		template.go#L157: 		return nil, fmt.Errorf("html/template: %q is an incomplete template", name)
		template.go#L250: 		return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
		template.go#L269: 			return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
		template.go#L413: 		return nil, fmt.Errorf("html/template: no files named in call to ParseFiles")
		template.go#L481: 		return nil, fmt.Errorf("html/template: pattern matches no files: %#q", pattern)
		template.go#L517: 			return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)

	internal/execabs
		execabs.go#L31: 	return fmt.Errorf("%s resolves to executable relative to current directory (.%c%s)", file, filepath.Separator, path)

	math/big
		floatconv.go#L129: 		err = fmt.Errorf("exponent overflow")
		floatconv.go#L279: 		err = fmt.Errorf("expected end of string, found %q", ch)
		floatmarsh.go#L72: 		return fmt.Errorf("Float.GobDecode: encoding version %d not supported", buf[0])
		floatmarsh.go#L117: 		err = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", text, err)
		intconv.go#L224: 		err = fmt.Errorf("invalid rune %#U", ch)
		intmarsh.go#L41: 		return fmt.Errorf("Int.GobDecode: encoding version %d not supported", b>>1)
		intmarsh.go#L59: 		return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", text)
		ratmarsh.go#L50: 		return fmt.Errorf("Rat.GobDecode: encoding version %d not supported", b>>1)
		ratmarsh.go#L72: 		return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", text)

	mime
		encodedword.go#L343: 			return fmt.Errorf("mime: unhandled charset %q", charset)
		encodedword.go#L423: 	return 0, fmt.Errorf("mime: invalid hex byte %#02x", b)
		mediatype.go#L368: 			return "", fmt.Errorf("mime: bogus characters after %%: %q", s)
		type.go#L166: 		return fmt.Errorf("mime: extension %q missing leading dot", ext)

	mime/multipart
		multipart.go#L323: 		return nil, fmt.Errorf("multipart: boundary is empty")
		multipart.go#L338: 			return nil, fmt.Errorf("multipart: NextPart: %v", err)
		multipart.go#L357: 			return nil, fmt.Errorf("multipart: expecting a new Part; got line %q", string(line))
		multipart.go#L374: 		return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)

	mime/quotedprintable
		reader.go#L40: 	return 0, fmt.Errorf("quotedprintable: invalid hex byte 0x%02x", b)
		reader.go#L99: 					r.rerr = fmt.Errorf("quotedprintable: invalid bytes after =: %q", rightStripped)
		reader.go#L131: 			return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in body", b)

	net/http
		client.go#L268: 		return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
		client.go#L282: 			return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a *Response with content length %d but a nil Body", rt, resp.ContentLength)
		client.go#L637: 				return nil, uerr(fmt.Errorf("%d response missing Location header", resp.StatusCode))
		client.go#L642: 				return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
		h2_bundle.go#L3817: 				return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
		h2_bundle.go#L3821: 			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).")
		h2_bundle.go#L4539: 			errc <- fmt.Errorf("bogus greeting %q", buf)
		h2_bundle.go#L5252: 		st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
		h2_bundle.go#L5316: 		st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
		h2_bundle.go#L6327: 			return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
		h2_bundle.go#L6333: 			return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
		h2_bundle.go#L6341: 			return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
		h2_bundle.go#L6349: 			return fmt.Errorf("promised request headers cannot include %q", k)
		h2_bundle.go#L6360: 		return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
		h2_bundle.go#L6511: 			return fmt.Errorf("request header %q is not valid in HTTP/2", k)
		h2_bundle.go#L7057: 	return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
		h2_bundle.go#L7118: 		return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
		h2_bundle.go#L7479: 			return "", fmt.Errorf("invalid Trailer key %q", k)
		h2_bundle.go#L7506: 		return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
		h2_bundle.go#L7509: 		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
		h2_bundle.go#L7512: 		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
		h2_bundle.go#L7993: 					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
		h2_bundle.go#L7995: 					return nil, fmt.Errorf("invalid request :path %q", orig)
		h2_bundle.go#L8006: 			return nil, fmt.Errorf("invalid HTTP header name %q", k)
		h2_bundle.go#L8010: 				return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
		h2_bundle.go#L9183: 			err = fmt.Errorf("%v", e)
		request.go#L85: func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }
		request.go#L861: 		return nil, fmt.Errorf("net/http: invalid method %q", method)
		server.go#L324: 			return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
		transfer.go#L83: 			return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
		transfer.go#L387: 		return fmt.Errorf("http: ContentLength=%d with Body length %d",
		transfer.go#L678: 				return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
		transfer.go#L696: 			return 0, fmt.Errorf("http: method cannot contain a Content-Length; got %q", contentLens)
		transport.go#L521: 				return nil, fmt.Errorf("net/http: invalid header field name %q", k)
		transport.go#L526: 					return nil, fmt.Errorf("net/http: invalid header field value %q for key %v", v, k)
		transport.go#L552: 		return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
		transport.go#L1917: 		return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
		transport.go#L2038: 		return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %v", err)
		transport.go#L2106: 				err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
		transport.go#L2245: 		pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %v", peekErr))
		transport.go#L2616: 				pc.close(fmt.Errorf("write error: %v", err))

	net/http/httputil
		reverseproxy.go#L548: 		p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch protocol %q when %q was requested", resUpType, reqUpType))
		reverseproxy.go#L554: 		p.getErrorHandler()(rw, req, fmt.Errorf("can't switch protocols using non-Hijacker ResponseWriter type %T", rw))
		reverseproxy.go#L559: 		p.getErrorHandler()(rw, req, fmt.Errorf("internal error: 101 switching protocols response with non-writable body"))
		reverseproxy.go#L578: 		p.getErrorHandler()(rw, req, fmt.Errorf("Hijack failed on protocol switch: %v", err))
		reverseproxy.go#L588: 		p.getErrorHandler()(rw, req, fmt.Errorf("response write: %v", err))
		reverseproxy.go#L592: 		p.getErrorHandler()(rw, req, fmt.Errorf("response flush: %v", err))

	net/textproto
		reader.go#L129: 		return nil, fmt.Errorf("missing validateFirstLine func")

	net/url
		url.go#L629: 			return "", fmt.Errorf("invalid port %q after host", colonPort)
		url.go#L657: 			return "", fmt.Errorf("invalid port %q after host", colonPort)

	os/user
		cgo_lookup_unix.go#L72: 		return nil, fmt.Errorf("user: lookup username %s: %v", username, err)
		cgo_lookup_unix.go#L101: 		return nil, fmt.Errorf("user: lookup userid %d: %v", uid, err)
		cgo_lookup_unix.go#L140: 		return nil, fmt.Errorf("user: lookup groupname %s: %v", groupname, err)
		cgo_lookup_unix.go#L169: 		return nil, fmt.Errorf("user: lookup groupid %d: %v", gid, err)
		cgo_lookup_unix.go#L242: 			return fmt.Errorf("internal buffer exceeds %d bytes", maxBufferSize)
		getgrouplist_darwin.go#L52: 			return fmt.Errorf("user: %q is a member of more than %d groups", username, maxGroups)
		listgroups_unix.go#L30: 		return nil, fmt.Errorf("user: list groups for %s: invalid gid %q", u.Username, u.Gid)

	runtime/pprof
		pprof.go#L780: 		return fmt.Errorf("cpu profiling already in use")
		proto.go#L278: 			return fmt.Errorf("truncated profile")
		proto.go#L281: 			return fmt.Errorf("malformed profile")
		proto.go#L307: 			return fmt.Errorf("truncated profile")
		proto.go#L310: 			return fmt.Errorf("malformed profile")

	testing
		benchmark.go#L54: 			return fmt.Errorf("invalid count")
		benchmark.go#L61: 		return fmt.Errorf("invalid duration")

	text/template
		exec.go#L138: 		Err:  fmt.Errorf(format, args...),
		exec.go#L187: 		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
		funcs.go#L88: 			panic(fmt.Errorf("function name %q is not a valid identifier", name))
		funcs.go#L95: 			panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
		funcs.go#L158: 			return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
		funcs.go#L169: 	return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
		funcs.go#L191: 		return 0, fmt.Errorf("cannot index slice/array with nil")
		funcs.go#L193: 		return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
		funcs.go#L196: 		return 0, fmt.Errorf("index out of range: %d", x)
		funcs.go#L209: 		return reflect.Value{}, fmt.Errorf("index of untyped nil")
		funcs.go#L215: 			return reflect.Value{}, fmt.Errorf("index of nil pointer")
		funcs.go#L238: 			return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
		funcs.go#L253: 		return reflect.Value{}, fmt.Errorf("slice of untyped nil")
		funcs.go#L256: 		return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
		funcs.go#L262: 			return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
		funcs.go#L268: 		return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
		funcs.go#L281: 		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
		funcs.go#L288: 		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
		funcs.go#L299: 		return 0, fmt.Errorf("len of nil pointer")
		funcs.go#L305: 	return 0, fmt.Errorf("len of type %s", item.Type())
		funcs.go#L315: 		return reflect.Value{}, fmt.Errorf("call of nil")
		funcs.go#L319: 		return reflect.Value{}, fmt.Errorf("non-function of type %s", typ)
		funcs.go#L322: 		return reflect.Value{}, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
		funcs.go#L328: 			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
		funcs.go#L333: 			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
		funcs.go#L347: 			return reflect.Value{}, fmt.Errorf("arg %d: %s", i, err)
		funcs.go#L361: 				err = fmt.Errorf("%v", r)
		funcs.go#L459: 			return false, fmt.Errorf("uncomparable type %s: %v", t1, arg1)
		funcs.go#L499: 						return false, fmt.Errorf("uncomparable type %s: %v", t2, arg)
		helper.go#L64: 		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
		helper.go#L128: 		return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
		helper.go#L158: 			return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)

	text/template/parse
		node.go#L637: 			return nil, fmt.Errorf("malformed character constant: %s", text)
		node.go#L693: 				return nil, fmt.Errorf("integer overflow: %q", text)
		node.go#L709: 		return nil, fmt.Errorf("illegal number syntax: %q", text)
		parse.go#L163: 	panic(fmt.Errorf(format, args...))

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L112: 		b.err = fmt.Errorf("cryptobyte: cannot represent %v as a GeneralizedTime", t)
		asn1.go#L171: 			b.err = fmt.Errorf("cryptobyte: invalid OID: %v", oid)
		asn1.go#L224: 		b.err = fmt.Errorf("cryptobyte: high-tag number identifier octects not supported: 0x%x", tag)
		builder.go#L273: 		b.err = fmt.Errorf("cryptobyte: pending child length %d exceeds %d-byte length prefix", length, child.pendingLenLen)

	vendor/golang.org/x/crypto/curve25519
		curve25519.go#L77: 		return nil, fmt.Errorf("bad scalar length: %d, expected %d", l, 32)
		curve25519.go#L80: 		return nil, fmt.Errorf("bad point length: %d, expected %d", l, 32)
		curve25519.go#L91: 			return nil, fmt.Errorf("bad input point: low order point")

	vendor/golang.org/x/net/http/httpproxy
		proxy.go#L165: 		return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)

	vendor/golang.org/x/text/unicode/norm
		iter.go#L76: 		return 0, fmt.Errorf("norm: invalid whence")
		iter.go#L79: 		return 0, fmt.Errorf("norm: negative position")

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.