func errors.New

1609 uses

	errors (current package)
		errors.go#L58: func New(text string) error {

	archive/zip
		reader.go#L24: 	ErrFormat    = errors.New("zip: not a valid zip file")
		reader.go#L25: 	ErrAlgorithm = errors.New("zip: unsupported compression algorithm")
		reader.go#L26: 	ErrChecksum  = errors.New("zip: checksum error")
		reader.go#L87: 		return nil, errors.New("zip: size cannot be negative")
		reader.go#L513: 		return nil, errors.New("zip: invalid comment length")
		reader.go#L778: 	return 0, &fs.PathError{Op: "read", Path: d.e.name, Err: errors.New("is a directory")}
		register.go#L49: 		return 0, errors.New("Write after Close")
		register.go#L87: 		return 0, errors.New("Read after Close")
		writer.go#L19: 	errLongName  = errors.New("zip: FileHeader.Name too long")
		writer.go#L20: 	errLongExtra = errors.New("zip: FileHeader.Extra too long")
		writer.go#L68: 		return errors.New("zip: Writer.Comment too long")
		writer.go#L84: 		return errors.New("zip: writer closed twice")
		writer.go#L263: 		return nil, errors.New("archive/zip: invalid duplicate FileHeader")
		writer.go#L432: 	return 0, errors.New("zip: write to directory")
		writer.go#L447: 		return 0, errors.New("zip: write to closed file")
		writer.go#L455: 		return errors.New("zip: file closed twice")

	bufio
		bufio.go#L23: 	ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
		bufio.go#L24: 	ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
		bufio.go#L25: 	ErrBufferFull        = errors.New("bufio: buffer full")
		bufio.go#L26: 	ErrNegativeCount     = errors.New("bufio: negative count")
		bufio.go#L84: var errNegativeRead = errors.New("bufio: reader returned negative count from Read")
		bufio.go#L538: var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")
		scan.go#L69: 	ErrTooLong         = errors.New("bufio.Scanner: token too long")
		scan.go#L70: 	ErrNegativeAdvance = errors.New("bufio.Scanner: SplitFunc returns negative advance count")
		scan.go#L71: 	ErrAdvanceTooFar   = errors.New("bufio.Scanner: SplitFunc returns advance count beyond input")
		scan.go#L72: 	ErrBadReadCount    = errors.New("bufio.Scanner: Read returned impossible count")
		scan.go#L124: var ErrFinalToken = errors.New("final token")

	bytes
		buffer.go#L44: var ErrTooLarge = errors.New("bytes.Buffer: too large")
		buffer.go#L45: var errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read")
		buffer.go#L376: 		return errors.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune")
		buffer.go#L385: var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read")
		reader.go#L54: 		return 0, errors.New("bytes.Reader.ReadAt: negative offset")
		reader.go#L80: 		return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
		reader.go#L106: 		return errors.New("bytes.Reader.UnreadRune: at beginning of slice")
		reader.go#L109: 		return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune")
		reader.go#L128: 		return 0, errors.New("bytes.Reader.Seek: invalid whence")
		reader.go#L131: 		return 0, errors.New("bytes.Reader.Seek: negative position")

	cloud.google.com/go/logging
		logging.go#L868: 		return nil, errors.New("logging: Entry.LogName should be not be set when writing")

	cloud.google.com/go/profiler
		profiler.go#L282: 		return 0, errors.New("no retry info")
		profiler.go#L292: 			return 0, errors.New("negative retry duration")
		profiler.go#L432: 		return errors.New("mutex profiling is not enabled")
		profiler.go#L456: 		return nil, errors.New("mutex profiling is not supported")
		profiler.go#L542: 		return errors.New("service name must be configured")

	cloud.google.com/go/storage
		copy.go#L87: 		return nil, errors.New("storage: cannot use DestinationKMSKeyName with a customer-supplied encryption key")
		copy.go#L189: 		return nil, errors.New("storage: at least one source object must be specified")
		hmac.go#L167: 		return nil, errors.New("field Metadata cannot be nil")
		hmac.go#L199: 		return nil, errors.New("storage: expecting a non-blank projectID")
		hmac.go#L202: 		return nil, errors.New("storage: expecting a non-blank service account email")
		notifications.go#L127: 		return nil, errors.New("storage: AddNotification: ID must not be set")
		notifications.go#L130: 		return nil, errors.New("storage: AddNotification: missing TopicProjectID")
		notifications.go#L133: 		return nil, errors.New("storage: AddNotification: missing TopicID")
		post_policy_v4.go#L211: 		return nil, errors.New("storage: bucket must be non-empty")
		post_policy_v4.go#L214: 		return nil, errors.New("storage: object must be non-empty")
		post_policy_v4.go#L236: 		return nil, errors.New("storage: exactly one of PrivateKey or SignedBytes must be set")
		post_policy_v4.go#L346: 		return errors.New("storage: missing required GoogleAccessID")
		post_policy_v4.go#L349: 		return errors.New("storage: exactly one of PrivateKey or SignedBytes must be set")
		post_policy_v4.go#L352: 		return errors.New("storage: expecting Expires to be in the future")
		post_policy_v4.go#L374: 		err = errors.New("storage: expected metadata to begin with x-goog-meta-, got " + strings.Join(badKeys, ", "))
		reader.go#L176: 				return errors.New("storage: partial request not satisfied")
		storage.go#L55: 	ErrBucketNotExist = errors.New("storage: bucket doesn't exist")
		storage.go#L57: 	ErrObjectNotExist = errors.New("storage: object doesn't exist")
		storage.go#L477: 		return errors.New("storage: missing required SignedURLOptions")
		storage.go#L480: 		return errors.New("storage: missing required GoogleAccessID")
		storage.go#L483: 		return errors.New("storage: exactly one of PrivateKey or SignedBytes must be set")
		storage.go#L490: 		return errors.New("storage: missing required expires option")
		storage.go#L495: 			return errors.New("storage: invalid MD5 checksum")
		storage.go#L502: 		return errors.New("storage: only path-style URLs are permitted with SigningSchemeV2")
		storage.go#L507: 			return errors.New("storage: expires must be within seven days from now")
		storage.go#L1011: 		return errors.New("storage: bucket name is empty")
		storage.go#L1014: 		return errors.New("storage: object name is empty")
		storage.go#L1039: 		return nil, errors.New("oauth2: private key is invalid")
		storage.go#L1585: 		return errors.New("storage: not a 32-byte AES-256 key")
		writer.go#L100: 		return errors.New("storage: cannot use KMSKeyName with a customer-supplied encryption key")
		writer.go#L109: 		return errors.New("storage: Writer.ChunkSize must be non-negative")

	compress/gzip
		gunzip.go#L32: 	ErrChecksum = errors.New("gzip: invalid checksum")
		gunzip.go#L34: 	ErrHeader = errors.New("gzip: invalid header")
		gzip.go#L95: 		return errors.New("gzip.Write: Extra data is too large")
		gzip.go#L113: 			return errors.New("gzip.Write: non-Latin-1 header string")

	compress/zlib
		reader.go#L39: 	ErrChecksum = errors.New("zlib: invalid checksum")
		reader.go#L41: 	ErrDictionary = errors.New("zlib: invalid dictionary")
		reader.go#L43: 	ErrHeader = errors.New("zlib: invalid header")

	context
		context.go#L157: var Canceled = errors.New("context canceled")

	contrib.go.opencensus.io/exporter/stackdriver
		metrics_proto.go#L42: var errNilMetricOrMetricDescriptor = errors.New("non-nil metric or metric descriptor")
		stackdriver.go#L318: 			return nil, errors.New("stackdriver: no project found with application default credentials")
		stackdriver.go#L348: 			return nil, errors.New("stackdriver: ResourceDetector must not be used in combination with deprecated resource fields")
		stats.go#L78: 	errBlankProjectID = errors.New("expecting a non-blank ProjectID")
		stats.go#L174: 		e.o.handleError(errors.New("failed to upload: buffer full"))

	contrib.go.opencensus.io/integrations/ocsql
		driver.go#L86: 	return "", errors.New("unable to register driver, all slots have been taken")

	crypto/aes
		aes_gcm.go#L40: var errOpen = errors.New("cipher: message authentication failed")

	crypto/cipher
		gcm.go#L113: 		return nil, errors.New("cipher: incorrect tag size given to GCM")
		gcm.go#L117: 		return nil, errors.New("cipher: the nonce can't have zero length, or the security of the key will be immediately compromised")
		gcm.go#L125: 		return nil, errors.New("cipher: NewGCM requires 128-bit block cipher")
		gcm.go#L195: var errOpen = errors.New("cipher: message authentication failed")

	crypto/dsa
		dsa.go#L46: var ErrInvalidPublicKey = errors.New("crypto/dsa: invalid public key")
		dsa.go#L86: 		return errors.New("crypto/dsa: invalid ParameterSizes")
		dsa.go#L161: 		return errors.New("crypto/dsa: parameters not set up before generating key")

	crypto/ecdsa
		ecdsa.go#L193: var errZeroParam = errors.New("zero parameter")

	crypto/ed25519
		ed25519.go#L90: 		return nil, errors.New("ed25519: cannot sign hashed message")

	crypto/md5
		md5.go#L74: 		return errors.New("crypto/md5: invalid hash state identifier")
		md5.go#L77: 		return errors.New("crypto/md5: invalid hash state size")

	crypto/rand
		util.go#L33: 		err = errors.New("crypto/rand: prime size must be at least 2-bit")

	crypto/rsa
		pkcs1v15.go#L316: 		return 0, nil, errors.New("crypto/rsa: input must be hashed message")
		pkcs1v15.go#L320: 		return 0, nil, errors.New("crypto/rsa: unsupported hash function")
		pss.go#L45: 		return nil, errors.New("crypto/rsa: input must be hashed with given hash")
		pss.go#L51: 		return nil, errors.New("crypto/rsa: key size too small for PSS signature")
		pss.go#L115: 		return errors.New("rsa: internal error: inconsistent length")
		rsa.go#L76: 	errPublicModulus       = errors.New("crypto/rsa: missing public modulus")
		rsa.go#L77: 	errPublicExponentSmall = errors.New("crypto/rsa: public exponent too small")
		rsa.go#L78: 	errPublicExponentLarge = errors.New("crypto/rsa: public exponent too large")
		rsa.go#L179: 		return nil, errors.New("crypto/rsa: invalid options for Decrypt")
		rsa.go#L213: 			return errors.New("crypto/rsa: invalid prime value")
		rsa.go#L218: 		return errors.New("crypto/rsa: invalid modulus")
		rsa.go#L233: 			return errors.New("crypto/rsa: invalid exponents")
		rsa.go#L263: 		return nil, errors.New("crypto/rsa: GenerateMultiPrimeKey: nprimes must be >= 2")
		rsa.go#L277: 			return nil, errors.New("crypto/rsa: too few primes of given length to generate an RSA key")
		rsa.go#L385: var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA public key size")
		rsa.go#L450: var ErrDecryption = errors.New("crypto/rsa: decryption error")
		rsa.go#L454: var ErrVerification = errors.New("crypto/rsa: verification error")
		rsa.go#L579: 		return nil, errors.New("rsa: internal error")

	crypto/sha1
		sha1.go#L66: 		return errors.New("crypto/sha1: invalid hash state identifier")
		sha1.go#L69: 		return errors.New("crypto/sha1: invalid hash state size")

	crypto/sha256
		sha256.go#L88: 		return errors.New("crypto/sha256: invalid hash state identifier")
		sha256.go#L91: 		return errors.New("crypto/sha256: invalid hash state size")

	crypto/sha512
		sha512.go#L153: 		return nil, errors.New("crypto/sha512: invalid hash function")
		sha512.go#L171: 		return errors.New("crypto/sha512: invalid hash state identifier")
		sha512.go#L179: 		return errors.New("crypto/sha512: invalid hash state identifier")
		sha512.go#L182: 		return errors.New("crypto/sha512: invalid hash state size")

	crypto/tls
		auth.go#L30: 			return errors.New("ECDSA verification failure")
		auth.go#L38: 			return errors.New("Ed25519 verification failure")
		auth.go#L58: 		return errors.New("internal error: unknown signature type")
		auth.go#L248: 	return 0, errors.New("tls: peer doesn't support any of the certificate's signature algorithms")
		common.go#L1010: var errNoCertificates = errors.New("tls: no certificates configured")
		common.go#L1080: 		return errors.New("no mutually supported protocol versions")
		common.go#L1148: 		return supportsRSAFallback(errors.New("client doesn't support ECDHE, can only use legacy RSA key exchange"))
		common.go#L1174: 				return errors.New("client doesn't support certificate curve")
		common.go#L1179: 				return errors.New("connection doesn't support Ed25519")
		common.go#L1212: 		return supportsRSAFallback(errors.New("client doesn't support any cipher suites compatible with the certificate"))
		common.go#L1247: 	return errors.New("chain is not signed by an acceptable CA")
		conn.go#L600: 		return c.in.setErrorLocked(errors.New("tls: internal error: attempted to read record with pending application data"))
		conn.go#L759: 		return c.in.setErrorLocked(errors.New("tls: too many ignored records"))
		conn.go#L1089: 	errShutdown = errors.New("tls: protocol is shutdown")
		conn.go#L1157: 		return errors.New("tls: internal error: unexpected renegotiation")
		conn.go#L1186: 		return errors.New("tls: unknown Renegotiation value")
		conn.go#L1214: 		return c.in.setErrorLocked(errors.New("tls: too many non-advancing records"))
		conn.go#L1341: var errEarlyCloseWrite = errors.New("tls: CloseWrite called before handshake complete")
		conn.go#L1401: 		c.handshakeErr = errors.New("tls: internal error: handshake should have had a result")
		conn.go#L1458: 		return errors.New("tls: VerifyHostname called on TLS server connection")
		conn.go#L1461: 		return errors.New("tls: handshake has not yet been performed")
		conn.go#L1464: 		return errors.New("tls: handshake did not verify certificate chain")
		handshake_client.go#L38: 		return nil, nil, errors.New("tls: either ServerName or InsecureSkipVerify must be specified in the tls.Config")
		handshake_client.go#L44: 			return nil, nil, errors.New("tls: invalid NextProtos value")
		handshake_client.go#L50: 		return nil, nil, errors.New("tls: NextProtos values too large")
		handshake_client.go#L55: 		return nil, nil, errors.New("tls: no supported versions satisfy MinVersion and MaxVersion")
		handshake_client.go#L105: 		return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
		handshake_client.go#L112: 		return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
		handshake_client.go#L125: 			return nil, nil, errors.New("tls: CurvePreferences includes unsupported curve")
		handshake_client.go#L195: 		return errors.New("tls: downgrade attempt detected, possibly due to a MitM attack or a broken middlebox")
		handshake_client.go#L451: 		return errors.New("tls: server chose an unconfigured cipher suite")
		handshake_client.go#L488: 			return errors.New("tls: received unexpected CertificateStatus message")
		handshake_client.go#L515: 			return errors.New("tls: server's identity changed during renegotiation")
		handshake_client.go#L637: 		return errors.New("tls: failed to write to key log: " + err.Error())
		handshake_client.go#L683: 		return false, errors.New("tls: server selected unsupported compression format")
		handshake_client.go#L690: 			return false, errors.New("tls: initial handshake had non-empty renegotiation extension")
		handshake_client.go#L700: 			return false, errors.New("tls: incorrect renegotiation extension contents")
		handshake_client.go#L707: 			return false, errors.New("tls: server advertised unrequested ALPN extension")
		handshake_client.go#L711: 			return false, errors.New("tls: server selected unadvertised ALPN protocol")
		handshake_client.go#L724: 		return false, errors.New("tls: server resumed a session with a different version")
		handshake_client.go#L729: 		return false, errors.New("tls: server resumed a session with a different cipher suite")
		handshake_client.go#L767: 		return errors.New("tls: server's Finished message was incorrect")
		handshake_client.go#L831: 			return errors.New("tls: failed to parse certificate from server: " + err.Error())
		handshake_client_tls13.go#L46: 		return errors.New("tls: server selected TLS 1.3 in a renegotiation")
		handshake_client_tls13.go#L113: 		return errors.New("tls: server selected TLS 1.3 using the legacy version field")
		handshake_client_tls13.go#L118: 		return errors.New("tls: server selected an invalid version after a HelloRetryRequest")
		handshake_client_tls13.go#L123: 		return errors.New("tls: server sent an incorrect legacy version")
		handshake_client_tls13.go#L133: 		return errors.New("tls: server sent a ServerHello extension forbidden in TLS 1.3")
		handshake_client_tls13.go#L138: 		return errors.New("tls: server did not echo the legacy session ID")
		handshake_client_tls13.go#L143: 		return errors.New("tls: server selected unsupported compression format")
		handshake_client_tls13.go#L149: 		return errors.New("tls: server changed cipher suite after a HelloRetryRequest")
		handshake_client_tls13.go#L153: 		return errors.New("tls: server chose an unconfigured cipher suite")
		handshake_client_tls13.go#L192: 		return errors.New("tls: server sent an unnecessary HelloRetryRequest message")
		handshake_client_tls13.go#L201: 		return errors.New("tls: received malformed key_share extension")
		handshake_client_tls13.go#L217: 			return errors.New("tls: server selected unsupported group")
		handshake_client_tls13.go#L221: 			return errors.New("tls: server sent an unnecessary HelloRetryRequest key_share")
		handshake_client_tls13.go#L225: 			return errors.New("tls: CurvePreferences includes unsupported curve")
		handshake_client_tls13.go#L290: 		return errors.New("tls: server sent two HelloRetryRequest messages")
		handshake_client_tls13.go#L295: 		return errors.New("tls: server sent a cookie in a normal ServerHello")
		handshake_client_tls13.go#L300: 		return errors.New("tls: malformed key_share extension")
		handshake_client_tls13.go#L305: 		return errors.New("tls: server did not send a key share")
		handshake_client_tls13.go#L309: 		return errors.New("tls: server selected unsupported group")
		handshake_client_tls13.go#L318: 		return errors.New("tls: server selected an invalid PSK")
		handshake_client_tls13.go#L330: 		return errors.New("tls: server selected an invalid PSK and cipher suite pair")
		handshake_client_tls13.go#L348: 		return errors.New("tls: invalid server key share")
		handshake_client_tls13.go#L400: 			return errors.New("tls: server advertised unrequested ALPN extension")
		handshake_client_tls13.go#L404: 			return errors.New("tls: server selected unadvertised ALPN protocol")
		handshake_client_tls13.go#L454: 		return errors.New("tls: received empty certificates message")
		handshake_client_tls13.go#L479: 		return errors.New("tls: certificate used with invalid signature algorithm")
		handshake_client_tls13.go#L487: 		return errors.New("tls: certificate used with invalid signature algorithm")
		handshake_client_tls13.go#L493: 		return errors.New("tls: invalid signature by the server certificate: " + err.Error())
		handshake_client_tls13.go#L518: 		return errors.New("tls: invalid server finished hash")
		handshake_client_tls13.go#L603: 		return errors.New("tls: failed to sign handshake: " + err.Error())
		handshake_client_tls13.go#L640: 		return errors.New("tls: received new session ticket from a client")
		handshake_client_tls13.go#L654: 		return errors.New("tls: received a session ticket with invalid lifetime")
		handshake_server.go#L184: 		return errors.New("tls: client does not support uncompressed connections")
		handshake_server.go#L207: 		return errors.New("tls: initial handshake had non-empty renegotiation extension")
		handshake_server.go#L324: 		return errors.New("tls: no cipher suite supported by both client and server")
		handshake_server.go#L333: 				return errors.New("tls: client using inappropriate protocol fallback")
		handshake_server.go#L624: 				return errors.New("tls: client certificate used with invalid signature algorithm")
		handshake_server.go#L641: 			return errors.New("tls: invalid signature by the client certificate: " + err.Error())
		handshake_server.go#L698: 		return errors.New("tls: client's Finished message is incorrect")
		handshake_server.go#L778: 			return errors.New("tls: failed to parse client certificate: " + err.Error())
		handshake_server.go#L784: 		return errors.New("tls: client didn't provide a certificate")
		handshake_server.go#L802: 			return errors.New("tls: failed to verify client certificate: " + err.Error())
		handshake_server_tls13.go#L95: 		return errors.New("tls: client used the legacy version field to negotiate TLS 1.3")
		handshake_server_tls13.go#L113: 				return errors.New("tls: client using inappropriate protocol fallback")
		handshake_server_tls13.go#L122: 		return errors.New("tls: TLS 1.3 client supports illegal compression methods")
		handshake_server_tls13.go#L133: 		return errors.New("tls: initial handshake had non-empty renegotiation extension")
		handshake_server_tls13.go#L144: 		return errors.New("tls: client sent unexpected early data")
		handshake_server_tls13.go#L179: 		return errors.New("tls: no cipher suite supported by both client and server")
		handshake_server_tls13.go#L210: 		return errors.New("tls: no ECDHE curve supported by both client and server")
		handshake_server_tls13.go#L221: 		return errors.New("tls: CurvePreferences includes unsupported curve")
		handshake_server_tls13.go#L232: 		return errors.New("tls: invalid client key share")
		handshake_server_tls13.go#L259: 		return errors.New("tls: invalid or missing PSK binders")
		handshake_server_tls13.go#L313: 			return errors.New("tls: internal error: failed to clone hash")
		handshake_server_tls13.go#L319: 			return errors.New("tls: invalid PSK binder")
		handshake_server_tls13.go#L453: 		return errors.New("tls: client sent invalid key share in second ClientHello")
		handshake_server_tls13.go#L458: 		return errors.New("tls: client indicated early data in second ClientHello")
		handshake_server_tls13.go#L463: 		return errors.New("tls: client illegally modified second ClientHello")
		handshake_server_tls13.go#L645: 		return errors.New("tls: failed to sign handshake: " + err.Error())
		handshake_server_tls13.go#L821: 			return errors.New("tls: client certificate used with invalid signature algorithm")
		handshake_server_tls13.go#L829: 			return errors.New("tls: client certificate used with invalid signature algorithm")
		handshake_server_tls13.go#L835: 			return errors.New("tls: invalid signature by the client certificate: " + err.Error())
		handshake_server_tls13.go#L866: 		return errors.New("tls: invalid client finished hash")
		key_agreement.go#L18: var errClientKeyExchange = errors.New("tls: invalid ClientKeyExchange message")
		key_agreement.go#L19: var errServerKeyExchange = errors.New("tls: invalid ServerKeyExchange message")
		key_agreement.go#L41: 		return nil, errors.New("tls: certificate private key does not implement crypto.Decrypter")
		key_agreement.go#L58: 	return errors.New("tls: unexpected ServerKeyExchange")
		key_agreement.go#L155: 		return nil, errors.New("tls: no supported elliptic curves offered")
		key_agreement.go#L158: 		return nil, errors.New("tls: CurvePreferences includes unsupported curve")
		key_agreement.go#L200: 		return nil, errors.New("tls: certificate cannot be used with the selected cipher suite")
		key_agreement.go#L211: 		return nil, errors.New("tls: failed to sign ECDHE parameters: " + err.Error())
		key_agreement.go#L252: 		return errors.New("tls: server selected unsupported curve")
		key_agreement.go#L269: 		return errors.New("tls: server selected unsupported curve")
		key_agreement.go#L299: 			return errors.New("tls: certificate used with invalid signature algorithm")
		key_agreement.go#L323: 		return errors.New("tls: invalid signature by the server certificate: " + err.Error())
		key_agreement.go#L330: 		return nil, nil, errors.New("tls: missing ServerKeyExchange message")
		key_schedule.go#L127: 		return nil, errors.New("tls: internal error: unsupported curve")
		prf.go#L250: 	return nil, errors.New("crypto/tls: ExportKeyingMaterial is unavailable when renegotiation is enabled")
		ticket.go#L121: 		return nil, errors.New("tls: internal error: session ticket keys unavailable")
		ticket.go#L136: 		return nil, errors.New("tls: failed to create cipher while encrypting ticket: " + err.Error())
		tls.go#L92: 		return nil, errors.New("tls: neither Certificates, GetCertificate, nor GetConfigForClient set in Config")
		tls.go#L296: 			return fail(errors.New("tls: failed to find any PEM data in certificate input"))
		tls.go#L299: 			return fail(errors.New("tls: failed to find certificate PEM data in certificate input, but did find a private key; PEM inputs may have been switched"))
		tls.go#L310: 				return fail(errors.New("tls: failed to find any PEM data in key input"))
		tls.go#L313: 				return fail(errors.New("tls: found a certificate rather than a key in the PEM for the private key"))
		tls.go#L339: 			return fail(errors.New("tls: private key type does not match public key type"))
		tls.go#L342: 			return fail(errors.New("tls: private key does not match public key"))
		tls.go#L347: 			return fail(errors.New("tls: private key type does not match public key type"))
		tls.go#L350: 			return fail(errors.New("tls: private key does not match public key"))
		tls.go#L355: 			return fail(errors.New("tls: private key type does not match public key type"))
		tls.go#L358: 			return fail(errors.New("tls: private key does not match public key"))
		tls.go#L361: 		return fail(errors.New("tls: unknown public key algorithm"))
		tls.go#L379: 			return nil, errors.New("tls: found unknown private key type in PKCS#8 wrapping")
		tls.go#L386: 	return nil, errors.New("tls: failed to parse private key")

	crypto/x509
		cert_pool.go#L108: 		return nil, errors.New("crypto/x509: system root pool is not available on Windows")
		pem_decrypt.go#L110: var IncorrectPasswordError = errors.New("x509: decryption password incorrect")
		pem_decrypt.go#L127: 		return nil, errors.New("x509: no DEK-Info header in block")
		pem_decrypt.go#L132: 		return nil, errors.New("x509: malformed DEK-Info header")
		pem_decrypt.go#L138: 		return nil, errors.New("x509: unknown encryption mode")
		pem_decrypt.go#L145: 		return nil, errors.New("x509: incorrect IV size")
		pem_decrypt.go#L157: 		return nil, errors.New("x509: encrypted PEM data is not a multiple of the block size")
		pem_decrypt.go#L172: 		return nil, errors.New("x509: invalid padding")
		pem_decrypt.go#L199: 		return nil, errors.New("x509: unknown encryption mode")
		pem_decrypt.go#L203: 		return nil, errors.New("x509: cannot generate IV: " + err.Error())
		pkcs1.go#L55: 			return nil, errors.New("x509: failed to parse private key (use ParseECPrivateKey instead for this key format)")
		pkcs1.go#L58: 			return nil, errors.New("x509: failed to parse private key (use ParsePKCS8PrivateKey instead for this key format)")
		pkcs1.go#L64: 		return nil, errors.New("x509: unsupported private key version")
		pkcs1.go#L68: 		return nil, errors.New("x509: private key contains zero or negative value")
		pkcs1.go#L83: 			return nil, errors.New("x509: private key contains zero or negative prime")
		pkcs1.go#L143: 			return nil, errors.New("x509: failed to parse public key (use ParsePKIXPublicKey instead for this key format)")
		pkcs1.go#L152: 		return nil, errors.New("x509: public key contains zero or negative value")
		pkcs1.go#L155: 		return nil, errors.New("x509: public key contains large public exponent")
		pkcs8.go#L37: 			return nil, errors.New("x509: failed to parse private key (use ParseECPrivateKey instead for this key format)")
		pkcs8.go#L40: 			return nil, errors.New("x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)")
		pkcs8.go#L48: 			return nil, errors.New("x509: failed to parse RSA private key embedded in PKCS#8: " + err.Error())
		pkcs8.go#L60: 			return nil, errors.New("x509: failed to parse EC private key embedded in PKCS#8: " + err.Error())
		pkcs8.go#L66: 			return nil, errors.New("x509: invalid Ed25519 private key parameters")
		pkcs8.go#L102: 			return nil, errors.New("x509: unknown curve while marshaling to PKCS#8")
		pkcs8.go#L107: 			return nil, errors.New("x509: failed to marshal curve OID: " + err.Error())
		pkcs8.go#L118: 			return nil, errors.New("x509: failed to marshal EC private key while building PKCS#8: " + err.Error())
		sec1.go#L46: 		return nil, errors.New("x509: unknown elliptic curve")
		sec1.go#L72: 			return nil, errors.New("x509: failed to parse private key (use ParsePKCS8PrivateKey instead for this key format)")
		sec1.go#L75: 			return nil, errors.New("x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)")
		sec1.go#L77: 		return nil, errors.New("x509: failed to parse EC private key: " + err.Error())
		sec1.go#L90: 		return nil, errors.New("x509: unknown elliptic curve")
		sec1.go#L96: 		return nil, errors.New("x509: invalid elliptic curve private key value")
		sec1.go#L108: 			return nil, errors.New("x509: invalid private key length")
		verify.go#L194: var errNotParsed = errors.New("x509: missing ASN.1 contents; use ParseCertificate")
		verify.go#L618: 			return errors.New("x509: internal error: empty chain when appending CA cert")
		verify.go#L863: 			err = errors.New("x509: signature check attempts limit reached while verifying certificate chain")
		x509.go#L60: 			return nil, errors.New("x509: failed to parse public key (use ParsePKCS1PublicKey instead for this key format)")
		x509.go#L64: 		return nil, errors.New("x509: trailing data after ASN.1 of public-key")
		x509.go#L68: 		return nil, errors.New("x509: unknown public key algorithm")
		x509.go#L91: 			return nil, pkix.AlgorithmIdentifier{}, errors.New("x509: unsupported elliptic curve")
		x509.go#L732: var ErrUnsupportedAlgorithm = errors.New("x509: cannot verify signature: algorithm unimplemented")
		x509.go#L854: 			return errors.New("x509: ECDSA verification failure")
		x509.go#L862: 			return errors.New("x509: Ed25519 verification failure")
		x509.go#L924: 			return nil, errors.New("x509: RSA key missing NULL parameters")
		x509.go#L933: 			return nil, errors.New("x509: trailing data after RSA public key")
		x509.go#L937: 			return nil, errors.New("x509: RSA modulus is not a positive number")
		x509.go#L940: 			return nil, errors.New("x509: RSA public exponent is not a positive number")
		x509.go#L955: 			return nil, errors.New("x509: trailing data after DSA public key")
		x509.go#L964: 			return nil, errors.New("x509: trailing data after DSA parameters")
		x509.go#L967: 			return nil, errors.New("x509: zero or negative DSA parameter")
		x509.go#L983: 			return nil, errors.New("x509: failed to parse ECDSA parameters as named curve")
		x509.go#L986: 			return nil, errors.New("x509: trailing data after ECDSA parameters")
		x509.go#L990: 			return nil, errors.New("x509: unsupported elliptic curve")
		x509.go#L994: 			return nil, errors.New("x509: failed to unmarshal elliptic curve point")
		x509.go#L1006: 			return nil, errors.New("x509: Ed25519 key encoded with illegal parameters")
		x509.go#L1009: 			return nil, errors.New("x509: wrong Ed25519 public key size")
		x509.go#L1041: 		return errors.New("x509: trailing data after X.509 extension")
		x509.go#L1069: 				return errors.New("x509: SAN rfc822Name is malformed")
		x509.go#L1075: 				return errors.New("x509: SAN dNSName is malformed")
		x509.go#L1081: 				return errors.New("x509: SAN uniformResourceIdentifier is malformed")
		x509.go#L1098: 				return errors.New("x509: cannot parse IP address of length " + strconv.Itoa(len(data)))
		x509.go#L1157: 		return false, errors.New("x509: invalid NameConstraints extension")
		x509.go#L1165: 		return false, errors.New("x509: empty name constraints extension")
		x509.go#L1188: 					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
		x509.go#L1230: 					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
		x509.go#L1254: 					return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
		x509.go#L1320: 		return nil, errors.New("x509: trailing data after X.509 subject")
		x509.go#L1325: 		return nil, errors.New("x509: trailing data after X.509 issuer")
		x509.go#L1387: 					return nil, errors.New("x509: trailing data after X.509 CRL distribution point")
		x509.go#L1409: 					return nil, errors.New("x509: trailing data after X.509 authority key-id")
		x509.go#L1438: 				return nil, errors.New("x509: trailing data after X.509 authority information")
		x509.go#L1472: 		return 0, errors.New("x509: trailing data after X.509 KeyUsage")
		x509.go#L1491: 		return false, 0, errors.New("x509: trailing data after X.509 BasicConstraints")
		x509.go#L1505: 		return nil, nil, errors.New("x509: trailing data after X.509 ExtendedKeyUsage")
		x509.go#L1527: 		return nil, errors.New("x509: trailing data after X.509 key-id")
		x509.go#L1537: 		return nil, errors.New("x509: trailing data after X.509 certificate policies")
		x509.go#L1940: 			return ext, errors.New("x509: unknown extended key usage")
		x509.go#L2038: 			err = errors.New("x509: unknown elliptic curve")
		x509.go#L2046: 		err = errors.New("x509: only RSA, ECDSA and Ed25519 keys supported")
		x509.go#L2061: 				err = errors.New("x509: requested SignatureAlgorithm does not match private key type")
		x509.go#L2066: 				err = errors.New("x509: cannot sign with hash function requested")
		x509.go#L2078: 		err = errors.New("x509: unknown SignatureAlgorithm")
		x509.go#L2143: 		return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
		x509.go#L2147: 		return nil, errors.New("x509: no SerialNumber given")
		x509.go#L2151: 		return nil, errors.New("x509: only CAs are allowed to specify MaxPathLen")
		x509.go#L2282: 		return nil, errors.New("x509: trailing data after CRL")
		x509.go#L2295: 		return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
		x509.go#L2434: 		return nil, errors.New("x509: failed to unmarshal raw CSR Attributes")
		x509.go#L2507: 		return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
		x509.go#L2600: 			return nil, errors.New("x509: failed to serialise extensions attribute: " + err.Error())
		x509.go#L2702: 		return nil, errors.New("x509: trailing data after X.509 Subject")
		x509.go#L2772: 		return nil, errors.New("x509: template can not be nil")
		x509.go#L2775: 		return nil, errors.New("x509: issuer can not be nil")
		x509.go#L2778: 		return nil, errors.New("x509: issuer must have the crlSign key usage bit set")
		x509.go#L2781: 		return nil, errors.New("x509: issuer certificate doesn't contain a subject key identifier")
		x509.go#L2784: 		return nil, errors.New("x509: template.ThisUpdate is after template.NextUpdate")
		x509.go#L2787: 		return nil, errors.New("x509: template contains nil Number field")

	crypto/x509/internal/macos
		corefoundation.go#L78: 		return 0, errors.New("CFNumberGetValue call failed")
		security.go#L62: var ErrNoTrustSettings = errors.New("no trust settings found")

	database/sql
		convert.go#L20: var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
		convert.go#L325: 				return errors.New("invalid context to convert cursor rows, missing parent *Rows")
		convert.go#L390: 		return errors.New("destination not a pointer")
		ctxutil.go#L111: 			return nil, errors.New("sql: driver does not support non-default isolation level")
		ctxutil.go#L117: 			return nil, errors.New("sql: driver does not support read-only transactions")
		ctxutil.go#L141: 			return nil, errors.New("sql: driver does not support the use of Named Parameters")
		sql.go#L388: var ErrNoRows = errors.New("sql: no rows in result set")
		sql.go#L551: 		return func() error { return errors.New("sql: duplicate driverConn close") }
		sql.go#L561: 		return errors.New("sql: duplicate driverConn close")
		sql.go#L1185: var errDBClosed = errors.New("sql: database is closed")
		sql.go#L1797: var ErrConnDone = errors.New("sql: connection is already closed")
		sql.go#L2088: var ErrTxDone = errors.New("sql: transaction has already been committed or rolled back")
		sql.go#L2279: 		return &Stmt{stickyErr: errors.New("sql: Tx.Stmt: statement from different database used")}
		sql.go#L2569: 		err = errors.New("sql: statement is closed")
		sql.go#L2936: var errRowsClosed = errors.New("sql: Rows are closed")
		sql.go#L2937: var errNoRows = errors.New("sql: no Rows available")
		sql.go#L3138: 		return errors.New("sql: Scan called without calling Next")
		sql.go#L3227: 			return errors.New("sql: RawBytes isn't allowed on Row.Scan")

	database/sql/driver
		driver.go#L145: var ErrSkip = errors.New("driver: skip fast-path; continue as if unimplemented")
		driver.go#L156: var ErrBadConn = errors.New("driver: bad connection")
		driver.go#L379: var ErrRemoveArgument = errors.New("driver: remove argument from query")
		driver.go#L522: 	return 0, errors.New("LastInsertId is not supported by this driver")
		driver.go#L539: 	return 0, errors.New("no LastInsertId available after DDL statement")
		driver.go#L543: 	return 0, errors.New("no RowsAffected available after DDL statement")

	encoding/asn1
		asn1.go#L480: 		return "", errors.New("asn1: invalid UTF-8 string")
		asn1.go#L491: 		return "", errors.New("pkcs12: odd-length BMP string")
		asn1.go#L532: 		err = errors.New("asn1: internal error in parseTagAndLength")
		marshal.go#L646: 						return nil, errors.New("asn1: string not valid UTF-8")

	encoding/binary
		binary.go#L253: 		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
		binary.go#L383: 		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
		varint.go#L103: var overflow = errors.New("binary: varint overflows a 64-bit integer")

	encoding/gob
		decode.go#L19: 	errBadUint = errors.New("gob: encoded unsigned integer out of range")
		decode.go#L20: 	errBadType = errors.New("gob: unknown type id or corrupted data")
		decode.go#L21: 	errRange   = errors.New("gob: bad data: field numbers out of bounds")
		decode.go#L113: 	return errors.New(`value for "` + name + `" out of range`)
		decode.go#L583: 	instr := &decInstr{elemOp, 0, nil, errors.New("no error")}
		decode.go#L603: 	keyInstr := &decInstr{keyOp, 0, nil, errors.New("no error")}
		decode.go#L604: 	elemInstr := &decInstr{elemOp, 0, nil, errors.New("no error")}
		decode.go#L1061: 			return nil, errors.New("gob: local interface type " + name + " can only be decoded from remote interface type; received concrete type " + remoteType)
		decode.go#L1063: 		return nil, errors.New("gob: decoding into local type " + name + ", received remote type " + remoteType)
		decode.go#L1066: 	ovfl := errors.New(`value for "` + name + `" out of range`)
		decoder.go#L61: 		dec.err = errors.New("gob: duplicate type received")
		decoder.go#L75: var errBadCount = errors.New("invalid message length")
		decoder.go#L161: 				dec.err = errors.New("extra data in buffer")
		decoder.go#L185: 		dec.err = errors.New("gob: attempt to decode into a non-pointer")
		decoder.go#L202: 			return errors.New("gob: DecodeValue of unassignable value")
		encoder.go#L72: 		enc.setError(errors.New("gob: encoder: message too big"))
		encoder.go#L220: 		return errors.New("gob: cannot encode nil value")
		type.go#L70: 			return nil, errors.New("can't represent recursive pointer type " + ut.base.String())
		type.go#L552: 		return nil, errors.New("gob NewTypeObject can't handle type: " + rt.String())

	encoding/hex
		hex.go#L38: var ErrLength = errors.New("encoding/hex: odd length hex string")
		hex.go#L237: 		return 0, errors.New("encoding/hex: dumper closed")

	encoding/json
		stream.go#L273: 		return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")

	encoding/pem
		pem.go#L268: 			return errors.New("pem: cannot encode a header key that contains a colon")

	encoding/xml
		read.go#L149: 		return errors.New("non-pointer passed to Unmarshal")
		read.go#L379: 		return errors.New("unknown type " + v.Type().String())
		read.go#L617: 		return errors.New("cannot unmarshal into " + dst0.Type().String())
		xml.go#L540: var errRawToken = errors.New("xml: cannot use RawToken from UnmarshalXML method")

	flag
		flag.go#L84: var ErrHelp = errors.New("flag: help requested")
		flag.go#L88: var errParse = errors.New("parse error")
		flag.go#L92: var errRange = errors.New("value out of range")

	fmt
		errors.go#L24: 		err = errors.New(s)
		scan.go#L180: 	return 0, errors.New("ScanState's Read should not be called. Use ReadRune")
		scan.go#L244: 	panic(scanError{errors.New(err)})
		scan.go#L371: 		return errors.New("fmt: scanning called UnreadRune with no rune available")
		scan.go#L465: var complexError = errors.New("syntax error scanning complex number")
		scan.go#L466: var boolError = errors.New("syntax error scanning boolean")

	github.com/andybalholm/cascadia
		parser.go#L21: 		return "", errors.New("invalid escape sequence")
		parser.go#L28: 		return "", errors.New("escaped line ending outside string")
		parser.go#L103: 		return "", errors.New("expected identifier, found EOF instead")
		parser.go#L145: 		return "", errors.New("expected name, found EOF instead")
		parser.go#L156: 		return "", errors.New("expected string, found EOF instead")
		parser.go#L189: 			return "", errors.New("unexpected end of line in string")
		parser.go#L203: 		return "", errors.New("EOF in string")
		parser.go#L218: 		return nil, errors.New("expected regular expression, found EOF instead")
		parser.go#L240: 		return nil, errors.New("EOF in regular expression")
		parser.go#L364: 		return attrSelector{}, errors.New("unexpected EOF in attribute selector")
		parser.go#L373: 		return attrSelector{}, errors.New("unexpected EOF in attribute selector")
		parser.go#L386: 		return attrSelector{}, errors.New("unexpected EOF in attribute selector")
		parser.go#L406: 		return attrSelector{}, errors.New("unexpected EOF in attribute selector")
		parser.go#L421: var errExpectedParenthesis = errors.New("expected '(' but didn't find it")
		parser.go#L422: var errExpectedClosingParenthesis = errors.New("expected ')' but didn't find it")
		parser.go#L423: var errUnmatchedParenthesis = errors.New("unmatched '('")
		parser.go#L479: 			return out, errors.New("unexpected EOF in pseudo selector")
		parser.go#L496: 			return out, errors.New("unexpected EOF in pseudo selector")
		parser.go#L538: 		return out, errors.New("pseudo-elements are not yet supported")
		parser.go#L553: 		return 0, errors.New("expected integer, but didn't find it")
		parser.go#L680: 	return 0, 0, errors.New("unexpected EOF while attempting to parse expression of form an+b")
		parser.go#L683: 	return 0, 0, errors.New("unexpected character while attempting to parse expression of form an+b")
		parser.go#L692: 		return nil, errors.New("expected selector, found EOF instead")

	github.com/aws/aws-sdk-go/aws/ec2metadata
		service.go#L237: 	r.Error = awserr.NewRequestFailure(awserr.New("EC2MetadataError", "failed to make EC2Metadata request", errors.New(b.String())),

	github.com/cespare/xxhash/v2
		xxhash.go#L184: 		return errors.New("xxhash: invalid hash state identifier")
		xxhash.go#L187: 		return errors.New("xxhash: invalid hash state size")

	github.com/evanw/esbuild/internal/fs
		filepath.go#L244: 			return "", errors.New("EvalSymlinks: too many links")
		filepath.go#L593: 		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
		filepath.go#L619: 		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
		fs.go#L142: var modKeyUnusable = errors.New("The modification key is unusable")
		fs_mock.go#L67: 	return ModKey{}, errors.New("This is not available during tests")

	github.com/evanw/esbuild/internal/resolver
		resolver.go#L668: var parseErrorImportCycle = errors.New("(import cycle)")
		resolver.go#L669: var parseErrorAlreadyLogged = errors.New("(error already logged)")

	github.com/go-git/go-billy/v5
		fs.go#L11: 	ErrReadOnly        = errors.New("read-only filesystem")
		fs.go#L12: 	ErrNotSupported    = errors.New("feature not supported")
		fs.go#L13: 	ErrCrossedBoundary = errors.New("chroot boundary crossed")

	github.com/go-git/go-git/v5
		blame.go#L133: 			return nil, errors.New("contents and commits have different length")
		options.go#L32: 	ErrMissingURL = errors.New("URL field is required")
		options.go#L235: 	ErrBranchHashExclusive  = errors.New("Branch and Hash are mutually exclusive")
		options.go#L236: 	ErrCreateRequiresBranch = errors.New("Branch is mandatory when Create is used")
		options.go#L373: 	ErrMissingAuthor = errors.New("author field is required")
		options.go#L460: 	ErrMissingName    = errors.New("name field is required")
		options.go#L461: 	ErrMissingTagger  = errors.New("tagger field is required")
		options.go#L462: 	ErrMissingMessage = errors.New("message field is required")
		options.go#L520: 	ErrHashOrReference = errors.New("ambiguous options, only one of CommitHash or ReferenceName can be passed")
		prune.go#L20: var ErrLooseObjectsNotSupported = errors.New("Loose objects not supported")
		remote.go#L29: 	NoErrAlreadyUpToDate     = errors.New("already up-to-date")
		remote.go#L30: 	ErrDeleteRefNotSupported = errors.New("server does not support delete-refs")
		remote.go#L31: 	ErrForceNeeded           = errors.New("some refs were not updated")
		remote.go#L32: 	ErrExactSHA1NotSupported = errors.New("server does not support exact SHA1 refspec")
		repository.go#L38: 	ErrBranchExists = errors.New("branch already exists")
		repository.go#L40: 	ErrBranchNotFound = errors.New("branch not found")
		repository.go#L42: 	ErrTagExists = errors.New("tag already exists")
		repository.go#L44: 	ErrTagNotFound = errors.New("tag not found")
		repository.go#L46: 	ErrFetching = errors.New("unable to fetch packfile")
		repository.go#L48: 	ErrInvalidReference          = errors.New("invalid reference, should be a tag or a branch")
		repository.go#L49: 	ErrRepositoryNotExists       = errors.New("repository does not exist")
		repository.go#L50: 	ErrRepositoryAlreadyExists   = errors.New("repository already exists")
		repository.go#L51: 	ErrRemoteNotFound            = errors.New("remote not found")
		repository.go#L52: 	ErrRemoteExists              = errors.New("remote already exists")
		repository.go#L53: 	ErrAnonymousRemoteName       = errors.New("anonymous remote name must be 'anonymous'")
		repository.go#L54: 	ErrWorktreeNotProvided       = errors.New("worktree should be provided")
		repository.go#L55: 	ErrIsBareRepository          = errors.New("worktree not available in a bare repository")
		repository.go#L56: 	ErrUnableToResolveCommit     = errors.New("unable to resolve commit")
		repository.go#L57: 	ErrPackedObjectsNotSupported = errors.New("Packed objects not supported")
		submodule.go#L16: 	ErrSubmoduleAlreadyInitialized = errors.New("submodule already initialized")
		submodule.go#L17: 	ErrSubmoduleNotInitialized     = errors.New("submodule not initialized")
		worktree.go#L29: 	ErrWorktreeNotClean     = errors.New("worktree is not clean")
		worktree.go#L30: 	ErrSubmoduleNotFound    = errors.New("submodule not found")
		worktree.go#L31: 	ErrUnstagedChanges      = errors.New("worktree contains unstaged changes")
		worktree.go#L32: 	ErrGitModulesSymlink    = errors.New(gitmodulesFile + " is a symlink")
		worktree.go#L33: 	ErrNonFastForwardUpdate = errors.New("non-fast-forward update")
		worktree_status.go#L27: 	ErrDestinationExists = errors.New("destination exists")
		worktree_status.go#L30: 	ErrGlobNoMatches = errors.New("glob pattern did not match any files")

	github.com/go-git/go-git/v5/config
		branch.go#L11: 	errBranchEmptyName     = errors.New("branch config: empty name")
		branch.go#L12: 	errBranchInvalidMerge  = errors.New("branch config: invalid merge")
		branch.go#L13: 	errBranchInvalidRebase = errors.New("branch config: rebase must be one of 'true' or 'interactive'")
		config.go#L34: 	ErrInvalid               = errors.New("config invalid key in remote or branch")
		config.go#L35: 	ErrRemoteConfigNotFound  = errors.New("remote config not found")
		config.go#L36: 	ErrRemoteConfigEmptyURL  = errors.New("remote config: empty URL")
		config.go#L37: 	ErrRemoteConfigEmptyName = errors.New("remote config: empty name")
		modules.go#L12: 	ErrModuleEmptyURL  = errors.New("module config: empty URL")
		modules.go#L13: 	ErrModuleEmptyPath = errors.New("module config: empty path")
		modules.go#L14: 	ErrModuleBadPath   = errors.New("submodule has an invalid path")
		refspec.go#L17: 	ErrRefSpecMalformedSeparator = errors.New("malformed refspec, separators are wrong")
		refspec.go#L18: 	ErrRefSpecMalformedWildcard  = errors.New("malformed refspec, mismatched number of wildcards")

	github.com/go-git/go-git/v5/plumbing
		object.go#L10: 	ErrObjectNotFound = errors.New("object not found")
		object.go#L12: 	ErrInvalidType = errors.New("invalid object type")
		reference.go#L30: 	ErrReferenceNotFound = errors.New("reference not found")

	github.com/go-git/go-git/v5/plumbing/format/idxfile
		decoder.go#L15: 	ErrUnsupportedVersion = errors.New("Unsupported version")
		decoder.go#L17: 	ErrMalformedIdxFile = errors.New("Malformed IDX file")

	github.com/go-git/go-git/v5/plumbing/format/index
		decoder.go#L24: 	ErrMalformedSignature = errors.New("malformed index signature file")
		decoder.go#L27: 	ErrInvalidChecksum = errors.New("invalid checksum")
		decoder.go#L29: 	errUnknownExtension = errors.New("unknown extension")
		encoder.go#L21: 	ErrInvalidTimestamp = errors.New("negative timestamps are not allowed")
		index.go#L17: 	ErrUnsupportedVersion = errors.New("unsupported version")
		index.go#L19: 	ErrEntryNotFound = errors.New("entry not found")

	github.com/go-git/go-git/v5/plumbing/format/objfile
		reader.go#L14: 	ErrClosed       = errors.New("objfile: already closed")
		reader.go#L15: 	ErrHeader       = errors.New("objfile: invalid header")
		reader.go#L16: 	ErrNegativeSize = errors.New("objfile: negative object size")
		writer.go#L13: 	ErrOverflow = errors.New("objfile: declared data length exceeded (overflow)")

	github.com/go-git/go-git/v5/plumbing/format/packfile
		parser.go#L18: 	ErrReferenceDeltaNotFound = errors.New("reference delta not found")
		parser.go#L22: 	ErrNotSeekableSource = errors.New("parser source is not seekable and storage was not provided")
		parser.go#L25: 	ErrDeltaNotCached = errors.New("delta could not be found in cache")
		patch_delta.go#L62: 	ErrInvalidDelta = errors.New("invalid delta")
		patch_delta.go#L63: 	ErrDeltaCmd     = errors.New("wrong delta command")

	github.com/go-git/go-git/v5/plumbing/format/pktline
		encoder.go#L34: 	ErrPayloadTooLong = errors.New("payload is too long")
		scanner.go#L13: var ErrInvalidPktLen = errors.New("invalid pkt-len found")

	github.com/go-git/go-git/v5/plumbing/object
		change_adaptor.go#L36: 		return ChangeEntry{}, errors.New("cannot transform non-TreeNoders")
		commit.go#L121: var ErrParentNotFound = errors.New("commit parent not found")
		object.go#L18: var ErrUnsupportedObject = errors.New("unsupported object type")
		patch.go#L21: 	ErrCanceled = errors.New("operation canceled")
		rename.go#L532: var errIndexFull = errors.New("index is full")
		tree.go#L26: 	ErrMaxTreeDepth      = errors.New("maximum tree depth exceeded")
		tree.go#L27: 	ErrFileNotFound      = errors.New("file not found")
		tree.go#L28: 	ErrDirectoryNotFound = errors.New("directory not found")
		tree.go#L29: 	ErrEntryNotFound     = errors.New("entry not found")

	github.com/go-git/go-git/v5/plumbing/protocol/packp
		advrefs_decode.go#L33: 	ErrEmptyAdvRefs = errors.New("empty advertised-ref message")
		advrefs_decode.go#L35: 	ErrEmptyInput = errors.New("empty input")
		srvresp.go#L26: 		return errors.New("multi_ack and multi_ack_detailed are not supported")
		srvresp.go#L118: 		return errors.New("multi_ack and multi_ack_detailed are not supported")
		updreq.go#L13: 	ErrEmptyCommands    = errors.New("commands cannot be empty")
		updreq.go#L14: 	ErrMalformedCommand = errors.New("malformed command")
		updreq_decode.go#L22: 	ErrEmpty                        = errors.New("empty update-request message")
		updreq_decode.go#L23: 	errNoCommands                   = errors.New("unexpected EOF before any command")
		updreq_decode.go#L24: 	errMissingCapabilitiesDelimiter = errors.New("capabilities delimiter not found")
		uppackresp.go#L15: var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be decoded")

	github.com/go-git/go-git/v5/plumbing/protocol/packp/capability
		list.go#L13: 	ErrArgumentsRequired = errors.New("arguments required")
		list.go#L16: 	ErrArguments = errors.New("arguments not allowed")
		list.go#L18: 	ErrEmptyArgument = errors.New("empty argument")
		list.go#L21: 	ErrMultipleArguments = errors.New("multiple arguments not allowed")

	github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband
		demux.go#L12: var ErrMaxPackedExceeded = errors.New("max. packed size exceeded")

	github.com/go-git/go-git/v5/plumbing/storer
		object.go#L13: 	ErrStop = errors.New("stop iter")
		reference.go#L14: var ErrMaxResolveRecursion = errors.New("max. recursion level reached")

	github.com/go-git/go-git/v5/plumbing/transport
		common.go#L32: 	ErrRepositoryNotFound     = errors.New("repository not found")
		common.go#L33: 	ErrEmptyRemoteRepository  = errors.New("remote repository is empty")
		common.go#L34: 	ErrAuthenticationRequired = errors.New("authentication required")
		common.go#L35: 	ErrAuthorizationFailed    = errors.New("authorization failed")
		common.go#L36: 	ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given")
		common.go#L37: 	ErrInvalidAuthMethod      = errors.New("invalid auth method")
		common.go#L38: 	ErrAlreadyConnected       = errors.New("session already established")

	github.com/go-git/go-git/v5/plumbing/transport/file
		client.go#L57: 		return "", errors.New("Couldn't read exec-path line all at once")

	github.com/go-git/go-git/v5/plumbing/transport/internal/common
		common.go#L31: 	ErrTimeoutExceeded = errors.New("timeout exceeded")

	github.com/go-git/go-git/v5/plumbing/transport/server
		server.go#L227: 	ErrUpdateReference = errors.New("failed to update ref")

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		auth_method.go#L128: 		return nil, errors.New("invalid PEM data")
		auth_method.go#L184: 		return "", errors.New("failed to get username")

	github.com/go-git/go-git/v5/storage
		storer.go#L10: var ErrReferenceHasChanged = errors.New("reference has changed concurrently")

	github.com/go-git/go-git/v5/storage/filesystem/dotgit
		dotgit.go#L43: 	ErrNotFound = errors.New("path not found")
		dotgit.go#L45: 	ErrIdxNotFound = errors.New("idx file not found")
		dotgit.go#L47: 	ErrPackfileNotFound = errors.New("packfile not found")
		dotgit.go#L49: 	ErrConfigNotFound = errors.New("config file not found")
		dotgit.go#L53: 	ErrPackedRefsDuplicatedRef = errors.New("duplicated ref found in packed-ref file")
		dotgit.go#L55: 	ErrPackedRefsBadFormat = errors.New("malformed packed-ref")
		dotgit.go#L59: 	ErrSymRefTargetNotFound = errors.New("symbolic reference target not found")
		dotgit.go#L62: 	ErrIsDir = errors.New("reference path is a directory")

	github.com/go-git/go-git/v5/utils/ioutil
		common.go#L19: 	ErrEmptyReader = errors.New("reader is empty")

	github.com/go-git/go-git/v5/utils/merkletrie
		difftree.go#L260: 	ErrCanceled = errors.New("operation canceled")

	github.com/go-redis/redis/v8
		commands.go#L2285: 		cmd.err = errors.New(cmd.val)
		commands.go#L2609: 		cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
		commands.go#L2623: 		cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
		commands.go#L2636: 		cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
		commands.go#L2650: 		cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
		options.go#L198: 		return nil, errors.New("invalid redis URL scheme: " + u.Scheme)
		options.go#L209: 		return nil, errors.New("no options supported")
		options.go#L235: 		return nil, errors.New("invalid redis URL path: " + u.Path)
		pubsub.go#L21: var errPingTimeout = errors.New("redis: ping timeout")
		ring.go#L23: var errRingShardsDown = errors.New("redis: all ring shards are down")
		sentinel.go#L484: 	return "", errors.New("redis: all sentinels are unreachable")
		sentinel.go#L529: 	return []string{}, errors.New("redis: all sentinels are unreachable")

	github.com/go-redis/redis/v8/internal/pool
		pool.go#L15: 	ErrClosed      = errors.New("redis: client is closed")
		pool.go#L16: 	ErrPoolTimeout = errors.New("redis: connection pool timeout")
		pool_sticky.go#L146: 	return errors.New("redis: StickyConnPool.Close: infinite loop")
		pool_sticky.go#L162: 		return errors.New("redis: StickyConnPool does not have a Conn")

	github.com/golang-migrate/migrate/v4
		migrate.go#L32: 	ErrNoChange       = errors.New("no change")
		migrate.go#L33: 	ErrNilVersion     = errors.New("no migration")
		migrate.go#L34: 	ErrInvalidVersion = errors.New("version must be >= -1")
		migrate.go#L35: 	ErrLocked         = errors.New("database locked")
		migrate.go#L36: 	ErrLockTimeout    = errors.New("timeout: can't acquire database lock")

	github.com/golang-migrate/migrate/v4/internal/url
		url.go#L8: var errNoScheme = errors.New("no scheme")
		url.go#L9: var errEmptyURL = errors.New("URL cannot be empty")

	github.com/golang/protobuf/proto
		buffer.go#L313: 			return nil, 0, errors.New("proto: cannot parse reserved wire type")
		deprecated.go#L18: 	ErrNil = errors.New("proto: Marshal called with nil")
		deprecated.go#L21: 	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
		deprecated.go#L24: 	ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
		deprecated.go#L35: 	return nil, errors.New("proto: not implemented")
		deprecated.go#L40: 	return errors.New("proto: not implemented")
		deprecated.go#L45: 	return nil, errors.New("proto: not implemented")
		deprecated.go#L50: 	return errors.New("proto: not implemented")
		extensions.go#L39: var ErrMissingExtension = errors.New("proto: missing extension")
		extensions.go#L41: var errNotExtendable = errors.New("proto: not an extendable proto.Message")
		text_decode.go#L662: var errBadUTF8 = errors.New("proto: bad UTF-8")

	github.com/golang/protobuf/ptypes
		duration.go#L59: 		return errors.New("duration: nil Duration")
		timestamp.go#L91: 		return errors.New("timestamp: nil Timestamp")

	github.com/google/licensecheck
		scan.go#L89: 		return errors.New("missing lre")

	github.com/google/licensecheck/internal/match
		resyntax.go#L274: 				return nil, reSyntaxError(s, i, errors.New("invalid wildcard count "+s[i:j+2]))
		resyntax.go#L284: 				return nil, reSyntaxError(s, i, errors.New("opening //** without closing **//"))

	github.com/google/pprof/profile
		encode.go#L208: 			return errors.New("string_table[0] must be ''")
		proto.go#L193: 			return 0, nil, errors.New("bad varint")
		proto.go#L219: 			return nil, errors.New("not enough data")
		proto.go#L230: 			return nil, errors.New("too much data")
		proto.go#L236: 			return nil, errors.New("not enough data")
		proto.go#L249: 		return errors.New("type mismatch")

	github.com/hashicorp/errwrap
		errwrap.go#L53: 	outer := errors.New(strings.Replace(

	github.com/imdario/mergo
		mergo.go#L18: 	ErrNilArguments                = errors.New("src and dst must not be nil")
		mergo.go#L19: 	ErrDifferentArgumentsTypes     = errors.New("src and dst must be of same type")
		mergo.go#L20: 	ErrNotSupported                = errors.New("only structs and maps are supported")
		mergo.go#L21: 	ErrExpectedMapAsDestination    = errors.New("dst was expected to be a map")
		mergo.go#L22: 	ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")

	github.com/jackc/pgconn
		auth_scram.go#L86: 	return nil, errors.New("expected AuthenticationSASLContinue message but received unexpected message")
		auth_scram.go#L99: 	return nil, errors.New("expected AuthenticationSASLFinal message but received unexpected message")
		auth_scram.go#L132: 		return nil, errors.New("server does not support SCRAM-SHA-256")
		auth_scram.go#L163: 		return errors.New("invalid SCRAM server-first-message received from server: did not include r=")
		auth_scram.go#L169: 		return errors.New("invalid SCRAM server-first-message received from server: did not include s=")
		auth_scram.go#L175: 		return errors.New("invalid SCRAM server-first-message received from server: did not include s=")
		auth_scram.go#L181: 		return errors.New("invalid SCRAM server-first-message received from server: did not include i=")
		auth_scram.go#L187: 		return errors.New("invalid SCRAM server-first-message received from server: did not include i=")
		auth_scram.go#L204: 		return errors.New("invalid SCRAM nonce: did not start with client nonce")
		auth_scram.go#L208: 		return errors.New("invalid SCRAM nonce: did not include server nonce")
		auth_scram.go#L227: 		return errors.New("invalid SCRAM server-final-message received from server")
		auth_scram.go#L233: 		return errors.New("invalid SCRAM ServerSignature received from server")
		config.go#L453: 			return nil, errors.New("invalid dsn")
		config.go#L468: 						return nil, errors.New("invalid backslash")
		config.go#L490: 				return nil, errors.New("unterminated quoted string in connection info string")
		config.go#L505: 			return nil, errors.New("invalid dsn")
		config.go#L590: 					return errors.New("failed to parse certificate from server: " + err.Error())
		config.go#L611: 		return nil, errors.New("sslmode is invalid")
		config.go#L624: 			return nil, errors.New("unable to add CA to cert pool")
		config.go#L632: 		return nil, errors.New(`both "sslcert" and "sslkey" are required`)
		config.go#L662: 		return 0, errors.New("outside range")
		config.go#L693: 		return 0, errors.New("negative timeout")
		config.go#L713: 		return errors.New("read only connection")
		pgconn.go#L146: 		return nil, &connectError{config: config, msg: "hostname resolving error", err: errors.New("ip addr wasn't found")}
		pgconn.go#L340: 		return errors.New("server refused TLS connection")
		pgconn.go#L1637: 		return "", errors.New("EscapeString must be run with standard_conforming_strings=on")
		pgconn.go#L1641: 		return "", errors.New("EscapeString must be run with client_encoding=UTF8")

	github.com/jackc/pgproto3/v2
		authentication_cleartext_password.go#L21: 		return errors.New("bad authentication message size")
		authentication_cleartext_password.go#L27: 		return errors.New("bad auth type")
		authentication_md5_password.go#L22: 		return errors.New("bad authentication message size")
		authentication_md5_password.go#L28: 		return errors.New("bad auth type")
		authentication_ok.go#L21: 		return errors.New("bad authentication message size")
		authentication_ok.go#L27: 		return errors.New("bad auth type")
		authentication_sasl.go#L23: 		return errors.New("authentication message too short")
		authentication_sasl.go#L29: 		return errors.New("bad auth type")
		authentication_sasl_continue.go#L22: 		return errors.New("authentication message too short")
		authentication_sasl_continue.go#L28: 		return errors.New("bad auth type")
		authentication_sasl_final.go#L22: 		return errors.New("authentication message too short")
		authentication_sasl_final.go#L28: 		return errors.New("bad auth type")
		cancel_request.go#L23: 		return errors.New("bad cancel request size")
		cancel_request.go#L29: 		return errors.New("bad cancel request code")
		frontend.go#L160: 		return nil, errors.New("authentication message too short")
		gss_enc_request.go#L21: 		return errors.New("gss encoding request too short")
		gss_enc_request.go#L27: 		return errors.New("bad gss encoding request code")
		sasl_initial_response.go#L29: 		return errors.New("invalid SASLInitialResponse")
		ssl_request.go#L21: 		return errors.New("ssl request too short")
		ssl_request.go#L27: 		return errors.New("bad ssl request code")
		startup_message.go#L27: 		return errors.New("startup message too short")

	github.com/jackc/pgservicefile
		pgservicefile.go#L27: 		return nil, errors.New("not found")

	github.com/jackc/pgtype
		composite_type.go#L54: 		return nil, errors.New("fields and valueTranscoders must have same length")
		composite_type.go#L337: 		cfs.err = errors.New("read past end of composite")
		composite_type.go#L350: 		cfs.err = errors.New("read past end of composite")
		composite_type.go#L447: 		cfs.err = errors.New("read past end of composite")
		composite_type.go#L460: 		cfs.err = errors.New("read past end of composite")
		database_sql.go#L29: 	return nil, errors.New("cannot convert to database/sql compatible value")
		hstore.go#L303: 				err = errors.New("String does not begin with \"")
		hstore.go#L315: 					err = errors.New("Found EOS in key, expecting character or \"")
		hstore.go#L330: 					err = errors.New("Found EOS after '=', expecting '>'")
		hstore.go#L335: 						err = errors.New("Found EOS after '=>', expecting '\"' or 'NULL'")
		hstore.go#L359: 					err = errors.New("Found EOS in key, expecting character or \"")
		hstore.go#L375: 					err = errors.New("Found EOS in NULL value")
		hstore.go#L391: 					err = errors.New("Found EOS after ',', expcting space")
		hstore.go#L409: 		err = errors.New("Improperly formatted hstore")
		json.go#L47: 		return errors.New("use pointer to pgtype.JSON instead of value")
		json.go#L50: 		return errors.New("use pointer to pgtype.JSONB instead of value")
		pgtype.go#L211: var errUndefined = errors.New("cannot encode status undefined")
		pgtype.go#L212: var errBadStatus = errors.New("invalid status")

	github.com/jackc/pgx/v4
		batch.go#L70: 			err = errors.New("no result")
		batch.go#L119: 			rows.err = errors.New("no result")
		conn.go#L95: var ErrNoRows = errors.New("no rows in result set")
		conn.go#L98: var ErrInvalidLogLevel = errors.New("invalid log level")
		conn.go#L833: 		return "", errors.New("simple protocol queries must be run with standard_conforming_strings=on")
		conn.go#L837: 		return "", errors.New("simple protocol queries must be run with client_encoding=UTF8")
		large_objects.go#L50: 		return errors.New("failed to remove large object")
		large_objects.go#L78: 		return 0, errors.New("failed to write to large object")
		logger.go#L74: 		return 0, errors.New("invalid log level")
		rows.go#L234: 		return nil, errors.New("rows is closed")
		rows.go#L273: 				rows.fatal(errors.New("Unknown format code"))
		rows.go#L292: 				rows.fatal(errors.New("Unknown format code"))
		tx.go#L61: var ErrTxClosed = errors.New("tx is closed")
		tx.go#L66: var ErrTxCommitRollback = errors.New("commit unexpectedly resulted in rollback")
		tx.go#L81: 		c.die(errors.New("failed to begin transaction"))

	github.com/jackc/pgx/v4/stdlib
		sql.go#L79: var ErrNotPgx = errors.New("not pgx *sql.DB")
		sql.go#L411: 	return nil, errors.New("Stmt.Exec deprecated and not implemented")
		sql.go#L419: 	return nil, errors.New("Stmt.Query deprecated and not implemented")

	github.com/jmespath/go-jmespath
		functions.go#L332: 			return nil, errors.New("incorrect number of args")
		functions.go#L344: 		return nil, errors.New("Invalid arity.")
		functions.go#L390: 		return nil, errors.New("unknown function: " + name)
		functions.go#L419: 	return nil, errors.New("could not compute length()")
		functions.go#L552: 				return nil, errors.New("invalid type, must be number")
		functions.go#L570: 				return nil, errors.New("invalid type, must be string")
		functions.go#L579: 		return nil, errors.New("invalid type, must be number of string")
		functions.go#L647: 				return nil, errors.New("invalid type, must be number")
		functions.go#L665: 				return nil, errors.New("invalid type, must be string")
		functions.go#L674: 		return nil, errors.New("invalid type, must be number of string")
		functions.go#L697: 	return nil, errors.New("unknown type")
		functions.go#L753: 			return nil, errors.New("error in sort_by comparison")
		functions.go#L760: 			return nil, errors.New("error in sort_by comparison")
		functions.go#L764: 		return nil, errors.New("invalid type, must be number of string")
		functions.go#L833: 	return nil, errors.New("unknown type")
		interpreter.go#L314: 	return nil, errors.New("Unknown AST node: " + node.nodeType.String())
		util.go#L87: 		return nil, errors.New("Invalid slice, step cannot be 0")

	github.com/kevinburke/ssh_config
		config.go#L231: 			err = errors.New(r.(string))
		config.go#L338: 		return nil, errors.New("ssh_config: empty pattern")
		config.go#L527: var ErrDepthExceeded = errors.New("ssh_config: max recurse depth exceeded")

	github.com/lib/pq
		conn.go#L30: 	ErrNotSupported              = errors.New("pq: Unsupported command")
		conn.go#L31: 	ErrInFailedTransaction       = errors.New("pq: Could not complete operation in a failed transaction")
		conn.go#L32: 	ErrSSLNotSupported           = errors.New("pq: SSL is not enabled on the server")
		conn.go#L33: 	ErrSSLKeyHasWorldPermissions = errors.New("pq: Private key file has group or world access. Permissions should be u=rw (0600) or less")
		conn.go#L34: 	ErrCouldNotDetectUsername    = errors.New("pq: Could not detect default username. Please provide one explicitly")
		conn.go#L36: 	errUnexpectedReady = errors.New("unexpected ReadyForQuery")
		conn.go#L37: 	errNoRowsAffected  = errors.New("no RowsAffected available after the empty statement")
		conn.go#L38: 	errNoLastInsertID  = errors.New("no LastInsertId available after the empty statement")
		connector.go#L86: 		return nil, errors.New("client_encoding must be absent or 'UTF8'")
		copy.go#L12: 	errCopyInClosed               = errors.New("pq: copyin statement has already been closed")
		copy.go#L13: 	errBinaryCopyNotSupported     = errors.New("pq: only text format supported for COPY")
		copy.go#L14: 	errCopyToNotSupported         = errors.New("pq: COPY TO is not supported")
		copy.go#L15: 	errCopyNotSupportedOutsideTxn = errors.New("pq: COPY is only allowed inside a transaction")
		copy.go#L16: 	errCopyInProgress             = errors.New("pq: COPY in progress")
		encode.go#L212: var errInvalidTimestamp = errors.New("invalid timestamp")
		notify.go#L43: var errListenerConnClosed = errors.New("pq: ListenerConn has been closed")
		notify.go#L356: var errListenerClosed = errors.New("pq: Listener has been closed")
		notify.go#L360: var ErrChannelAlreadyOpen = errors.New("pq: channel is already open")
		notify.go#L363: var ErrChannelNotOpen = errors.New("pq: channel is not open")
		notify.go#L608: 		return errors.New("no connection")

	github.com/Masterminds/squirrel
		case.go#L65: 		err = errors.New("case expression must contain at lease one WHEN clause")
		insert.go#L55: 		err = errors.New("insert statements must specify a table")
		insert.go#L59: 		err = errors.New("insert statements must have at least one set of values or select clause")
		insert.go#L119: 		return args, errors.New("values for insert statements are not set")
		insert.go#L150: 		return args, errors.New("select clause for insert statements are not set")
		squirrel_ctx.go#L12: var NoContextSupport = errors.New("DB does not support Context")

	github.com/matttproud/golang_protobuf_extensions/pbutil
		decode.go#L25: var errInvalidVarint = errors.New("invalid varint32 encountered")

	github.com/mitchellh/go-homedir
		homedir.go#L68: 		return "", errors.New("cannot expand user-specific home dir")
		homedir.go#L142: 		return "", errors.New("blank output when reading home directory")
		homedir.go#L163: 		return "", errors.New("HOMEDRIVE, HOMEPATH, or USERPROFILE are blank")

	github.com/prometheus/client_golang/prometheus
		counter.go#L89: 		panic(errors.New("counter cannot decrease in value"))
		desc.go#L126: 		d.err = errors.New("duplicate label names")
		labels.go#L38: var errInconsistentCardinality = errors.New("inconsistent label cardinality")
		process_collector.go#L120: 			c.reportError(ch, nil, errors.New("process metrics not supported on this platform"))

	github.com/prometheus/client_golang/prometheus/promhttp
		instrument_server.go#L230: 	for err := errors.New("dummy"); err != nil; lvs = append(lvs, magicString) {

	github.com/prometheus/procfs
		ipvs.go#L94: 		return IPVSStats{}, errors.New("ip_vs_stats corrupt: too short")
		ipvs.go#L99: 		return IPVSStats{}, errors.New("ip_vs_stats corrupt: unexpected number of fields")
		net_dev.go#L92: 		return nil, errors.New("invalid net/dev line, missing colon")
		net_dev.go#L102: 		return nil, errors.New("invalid net/dev line, empty interface name")
		net_sockstat.go#L122: 		return nil, errors.New("odd number of fields in key/value pairs")
		net_unix.go#L56: var errInvalidKernelPtrFmt = errors.New("Invalid Num(the kernel table slot number) format")
		schedstat.go#L116: 	err = errors.New("could not parse schedstat")

	github.com/sergi/go-diff/diffmatchpatch
		diff.go#L1318: 				return nil, errors.New("Negative number in DiffFromDelta: " + param)
		diff.go#L1336: 			return nil, errors.New("Invalid diff operation in DiffFromDelta: " + string(token[0]))
		patch.go#L493: 			return patches, errors.New("Invalid patch string: " + text[textPointer])
		patch.go#L548: 				return patches, errors.New("Invalid patch mode '" + string(sign) + "' in: " + string(line))

	github.com/xanzy/ssh-agent
		sshagent.go#L33: 		return nil, nil, errors.New("SSH agent requested but SSH_AUTH_SOCK not-specified")

	go.opencensus.io/stats/view
		view.go#L74: var ErrNegativeBucketBounds = errors.New("negative bucket bounds not supported")
		worker_commands.go#L76: 		cmd.err <- errors.New(strings.Join(errstr, "\n"))

	go.opencensus.io/tag
		validate.go#L28: 	errInvalidKeyName = errors.New("invalid key name: only ASCII characters accepted; max length must be 255 characters")
		validate.go#L29: 	errInvalidValue   = errors.New("invalid value: only ASCII characters accepted; max length must be 255 characters")

	go.opentelemetry.io/otel/api/metric
		sync.go#L25: var ErrSDKReturnedNilImpl = errors.New("SDK returned a nil implementation")

	go.opentelemetry.io/otel/api/trace
		b3_propagator.go#L48: 	errInvalidSampledByte        = errors.New("invalid B3 Sampled found")
		b3_propagator.go#L49: 	errInvalidSampledHeader      = errors.New("invalid B3 Sampled header found")
		b3_propagator.go#L50: 	errInvalidTraceIDHeader      = errors.New("invalid B3 TraceID header found")
		b3_propagator.go#L51: 	errInvalidSpanIDHeader       = errors.New("invalid B3 SpanID header found")
		b3_propagator.go#L52: 	errInvalidParentSpanIDHeader = errors.New("invalid B3 ParentSpanID header found")
		b3_propagator.go#L53: 	errInvalidScope              = errors.New("require either both TraceID and SpanID or none")
		b3_propagator.go#L54: 	errInvalidScopeParent        = errors.New("ParentSpanID requires both TraceID and SpanID to be available")
		b3_propagator.go#L55: 	errInvalidScopeParentSingle  = errors.New("ParentSpanID requires TraceID, SpanID and Sampled to be available")
		b3_propagator.go#L56: 	errEmptyContext              = errors.New("empty request context")
		b3_propagator.go#L57: 	errInvalidTraceIDValue       = errors.New("invalid B3 TraceID value found")
		b3_propagator.go#L58: 	errInvalidSpanIDValue        = errors.New("invalid B3 SpanID value found")
		b3_propagator.go#L59: 	errInvalidParentSpanIDValue  = errors.New("invalid B3 ParentSpanID value found")

	go/build
		build.go#L1040: var errNoModules = errors.New("not using modules")
		build.go#L1179: 		return errors.New(errStr)
		build.go#L1465: 	errGoBuildWithoutBuild = errors.New("//go:build comment without // +build comment")
		build.go#L1466: 	errMultipleGoBuild     = errors.New("multiple //go:build comments") // unused in Go 1.(N-1)
		build.go#L1827: 		err = errors.New("unclosed quote")
		build.go#L1829: 		err = errors.New("unfinished escaping")
		build.go#L1985: 	return "?", errors.New("architecture letter no longer used")
		read.go#L47: 	errSyntax = errors.New("syntax error")
		read.go#L48: 	errNUL    = errors.New("unexpected NUL in input")

	go/parser
		interface.go#L40: 		return nil, errors.New("invalid source")

	golang.org/x/crypto/cast5
		cast5.go#L28: 		return nil, errors.New("CAST5: keys must be 16 bytes")

	golang.org/x/crypto/chacha20
		chacha_generic.go#L82: 		return nil, errors.New("chacha20: wrong key size")
		chacha_generic.go#L93: 		return nil, errors.New("chacha20: wrong nonce size")
		chacha_generic.go#L354: 		return nil, errors.New("chacha20: wrong HChaCha20 key size")
		chacha_generic.go#L357: 		return nil, errors.New("chacha20: wrong HChaCha20 nonce size")

	golang.org/x/crypto/openpgp/elgamal
		elgamal.go#L40: 		err = errors.New("elgamal: message too long")
		elgamal.go#L80: 		return nil, errors.New("elgamal: invalid private key")
		elgamal.go#L102: 		return nil, errors.New("elgamal: decryption error")

	golang.org/x/crypto/ssh
		certs.go#L217: 		return nil, errors.New("ssh: signature parse error")
		certs.go#L238: 		return nil, errors.New("ssh: signer and cert have different public key")
		certs.go#L315: 		return errors.New("ssh: non-certificate host key")
		certs.go#L341: 		return nil, errors.New("ssh: normal key pairs not accepted")
		channel.go#L308: 		return errors.New("ssh: incoming packet exceeds maximum payload size")
		channel.go#L313: 		return errors.New("ssh: wrong packet length")
		channel.go#L320: 		return errors.New("ssh: remote side wrote too much")
		channel.go#L389: 		return errors.New("ssh: channel response message received on inbound channel")
		channel.go#L392: 		return errors.New("ssh: duplicate response received for channel")
		channel.go#L475: var errUndecided = errors.New("ssh: must Accept or Reject channel")
		channel.go#L476: var errDecidedAlready = errors.New("ssh: can call Accept or Reject only once")
		cipher.go#L183: 		return nil, errors.New("ssh: invalid packet length, packet too small")
		cipher.go#L187: 		return nil, errors.New("ssh: invalid packet length, packet too large")
		cipher.go#L216: 			return nil, errors.New("ssh: MAC failure")
		cipher.go#L226: 		return errors.New("ssh: packet too large")
		cipher.go#L378: 		return nil, errors.New("ssh: max packet length exceeded")
		cipher.go#L688: 		return nil, errors.New("ssh: invalid packet length, packet too large")
		cipher.go#L707: 		return nil, errors.New("ssh: MAC failure")
		client.go#L76: 		return nil, nil, nil, errors.New("ssh: must specify HostKeyCallback")
		client.go#L121: 		return errors.New("ssh: signature parse error")
		client_auth.go#L457: 				return authFailure, nil, errors.New("ssh: prompt format error")
		client_auth.go#L465: 			return authFailure, nil, errors.New("ssh: extra data following keyboard-interactive pairs")
		handshake.go#L485: 		return errors.New("ssh: only handshakeTransport can send kexInit")
		handshake.go#L487: 		return errors.New("ssh: only handshakeTransport can send newKeys")
		kex.go#L93: 		return nil, errors.New("ssh: DH parameter out of bounds")
		kex.go#L279: 		return nil, nil, errors.New("ssh: elliptic.Unmarshal failure")
		kex.go#L282: 		return nil, nil, errors.New("ssh: public key not on curve")
		kex.go#L459: 		return nil, errors.New("ssh: peer's curve25519 public value has wrong length")
		kex.go#L466: 		return nil, errors.New("ssh: peer's curve25519 public value has wrong order")
		kex.go#L500: 		return nil, errors.New("ssh: peer's curve25519 public value has wrong length")
		kex.go#L512: 		return nil, errors.New("ssh: peer's curve25519 public value has wrong order")
		keys.go#L154: 			return "", nil, nil, "", nil, errors.New("ssh: invalid entry in known_hosts data")
		keys.go#L260: 	return nil, "", nil, nil, errors.New("ssh: no key found")
		keys.go#L273: 		return nil, errors.New("ssh: trailing junk in public key")
		keys.go#L354: 		return nil, nil, errors.New("ssh: exponent too large")
		keys.go#L358: 		return nil, nil, errors.New("ssh: incorrect exponent")
		keys.go#L479: 		return errors.New("ssh: DSA signature parse error")
		keys.go#L486: 	return errors.New("ssh: signature did not verify")
		keys.go#L592: 		return errors.New("ssh: signature did not verify")
		keys.go#L641: 		return nil, nil, errors.New("ssh: unsupported curve")
		keys.go#L646: 		return nil, nil, errors.New("ssh: invalid curve point")
		keys.go#L694: 	return errors.New("ssh: signature did not verify")
		keys.go#L743: 		return nil, nil, errors.New("ssh: unsupported curve")
		keys.go#L749: 		return nil, nil, errors.New("ssh: invalid curve point")
		keys.go#L820: 	return errors.New("ssh: signature did not verify")
		keys.go#L913: 		return errors.New("ssh: signature did not verify")
		keys.go#L1058: 			return nil, errors.New("ssh: only P-256, P-384 and P-521 EC keys are supported")
		keys.go#L1123: 		return nil, errors.New("ssh: no key found")
		keys.go#L1153: 		return nil, errors.New("ssh: no key found")
		keys.go#L1161: 		return nil, errors.New("ssh: not an encrypted key")
		keys.go#L1197: 		return nil, errors.New("ssh: failed to parse DSA key: " + err.Error())
		keys.go#L1200: 		return nil, errors.New("ssh: garbage after DSA key")
		keys.go#L1221: 		return nil, errors.New("ssh: invalid openssh private key")
		keys.go#L1229: 			return nil, errors.New("ssh: key is not password protected")
		keys.go#L1280: 		return nil, errors.New("ssh: invalid openssh private key format")
		keys.go#L1299: 		return nil, errors.New("ssh: multi-key files are not supported")
		keys.go#L1325: 		return nil, errors.New("ssh: malformed OpenSSH key")
		keys.go#L1379: 			return nil, errors.New("ssh: private key unexpected length")
		keys.go#L1415: 			return nil, errors.New("ssh: unhandled elliptic curve: " + key.Curve)
		keys.go#L1420: 			return nil, errors.New("ssh: failed to unmarshal public key")
		keys.go#L1424: 			return nil, errors.New("ssh: scalar is out of range")
		keys.go#L1429: 			return nil, errors.New("ssh: public key does not match private key")
		keys.go#L1441: 		return nil, errors.New("ssh: unhandled key type")
		keys.go#L1448: 			return errors.New("ssh: padding not as expected")
		messages.go#L366: var errShortRead = errors.New("ssh: short read")
		server.go#L228: 		return nil, errors.New("ssh: server has no host keys")
		server.go#L234: 		return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false")
		server.go#L268: 		return nil, errors.New("ssh: requested service '" + serviceRequest.Service + "' before authenticating")
		server.go#L296: 		return errors.New("ssh: no address known for client, but source-address match required")
		server.go#L396: var ErrNoAuth = errors.New("ssh: no auth passed yet")
		server.go#L433: 			return nil, errors.New("ssh: client attempted to negotiate for unknown service: " + userAuthReq.Service)
		server.go#L466: 				authErr = errors.New("ssh: password auth not configured")
		server.go#L482: 				authErr = errors.New("ssh: keyboard-interactive auth not configured")
		server.go#L490: 				authErr = errors.New("ssh: publickey auth not configured")
		server.go#L576: 				authErr = errors.New("ssh: gssapi-with-mic auth not configured")
		server.go#L653: 			return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false")
		server.go#L675: 		return nil, errors.New("ssh: echos and questions must have equal length")
		server.go#L716: 		return nil, errors.New("ssh: junk at end of message")
		session.go#L174: 		err = errors.New("ssh: setenv failed")
		session.go#L211: 		err = errors.New("ssh: pty-req failed")
		session.go#L229: 		err = errors.New("ssh: subsystem request failed")
		session.go#L280: 		return errors.New("ssh: session already started")
		session.go#L320: 		return nil, errors.New("ssh: Stdout already set")
		session.go#L343: 		return nil, errors.New("ssh: Stdout already set")
		session.go#L346: 		return nil, errors.New("ssh: Stderr already set")
		session.go#L359: 		return errors.New("ssh: session already started")
		session.go#L364: 		return errors.New("ssh: could not start shell")
		session.go#L401: 		return errors.New("ssh: session not started")
		session.go#L543: 		return nil, errors.New("ssh: Stdin already set")
		session.go#L546: 		return nil, errors.New("ssh: StdinPipe after process started")
		session.go#L560: 		return nil, errors.New("ssh: Stdout already set")
		session.go#L563: 		return nil, errors.New("ssh: StdoutPipe after process started")
		session.go#L577: 		return nil, errors.New("ssh: Stderr already set")
		session.go#L580: 		return nil, errors.New("ssh: StderrPipe after process started")
		ssh_gss.go#L107: 		return nil, errors.New("parse uint32 failed")
		ssh_gss.go#L120: 			return nil, errors.New("parse string failed")
		streamlocal.go#L45: 		return nil, errors.New("ssh: streamlocal-forward@openssh.com request denied by peer")
		streamlocal.go#L105: 		err = errors.New("ssh: cancel-streamlocal-forward@openssh.com failed")
		tcpip.go#L120: 		return nil, errors.New("ssh: tcpip-forward request denied by peer")
		tcpip.go#L325: 		err = errors.New("ssh: cancel-tcpip-forward failed")
		tcpip.go#L467: 	return errors.New("ssh: tcpChan: deadline not supported")
		tcpip.go#L473: 	return errors.New("ssh: tcpChan: deadline not supported")
		transport.go#L133: 		err = errors.New("ssh: zero length packet")
		transport.go#L143: 				return nil, errors.New("ssh: got bogus newkeys message")
		transport.go#L294: 			return nil, errors.New("ssh: junk character in version line")
		transport.go#L345: 		return nil, errors.New("ssh: overflow reading version string")

	golang.org/x/crypto/ssh/agent
		client.go#L225: var ErrExtensionUnsupported = errors.New("agent: extension unsupported")
		client.go#L352: 		return nil, clientErr(errors.New("response too large"))
		client.go#L370: 	return errors.New("agent: failure")
		client.go#L411: 			return nil, errors.New("agent: too many keys in agent reply")
		client.go#L425: 		return nil, errors.New("agent: failed to list keys")
		client.go#L457: 		return nil, errors.New("agent: failed to sign challenge")
		client.go#L466: 		return nil, errors.New("agent: empty packet")
		client.go#L605: 	return errors.New("agent: failure")
		client.go#L733: 		return errors.New("agent: signer and cert have different public key")
		client.go#L743: 	return errors.New("agent: failure")
		client.go#L801: 		return nil, errors.New("agent: failure; empty response")
		client.go#L809: 		return nil, errors.New("agent: generic extension failure")
		forward.go#L25: 		return errors.New("forwarding request denied")
		forward.go#L34: 		return errors.New("agent: already have handler for " + channelType)
		forward.go#L60: 		return errors.New("agent: already have handler for " + channelType)
		keyring.go#L33: var errLocked = errors.New("agent: locked")
		keyring.go#L69: 		return errors.New("agent: key not found")
		keyring.go#L103: 		return errors.New("agent: not locked")
		keyring.go#L219: 	return nil, errors.New("not found")
		server.go#L246: 		return nil, errors.New("agent: RSA public exponent too large")
		server.go#L321: 		return nil, errors.New("agent: point not on curve")
		server.go#L339: 		return nil, errors.New("agent: bad ED25519 certificate")
		server.go#L380: 		return nil, errors.New("agent: bad RSA certificate")
		server.go#L394: 		return nil, errors.New("agent: RSA public exponent too large")
		server.go#L425: 		return nil, errors.New("agent: bad DSA certificate")
		server.go#L468: 		return nil, errors.New("agent: bad ECDSA certificate")

	golang.org/x/crypto/ssh/internal/bcrypt_pbkdf
		bcrypt_pbkdf.go#L23: 		return nil, errors.New("bcrypt_pbkdf: number of rounds is too small")
		bcrypt_pbkdf.go#L26: 		return nil, errors.New("bcrypt_pbkdf: empty password")
		bcrypt_pbkdf.go#L29: 		return nil, errors.New("bcrypt_pbkdf: bad salt length")
		bcrypt_pbkdf.go#L32: 		return nil, errors.New("bcrypt_pbkdf: keyLen is too large")

	golang.org/x/crypto/ssh/knownhosts
		knownhosts.go#L187: 		return "", "", nil, errors.New("knownhosts: missing host pattern")
		knownhosts.go#L193: 		return "", "", nil, errors.New("knownhosts: missing key type pattern")
		knownhosts.go#L264: 			return nil, errors.New("knownhosts: negation without following hostname")
		knownhosts.go#L481: 		err = errors.New("knownhosts: hashed host must start with '|'")

	golang.org/x/mod/modfile
		read.go#L393: 		Err:      errors.New(s),
		rule.go#L656: 			Err:     errors.New("must be of the form v1.2.3"),

	golang.org/x/mod/zip
		zip.go#L162: 	errPathNotClean    = errors.New("file path is not clean")
		zip.go#L163: 	errPathNotRelative = errors.New("file path is not relative")
		zip.go#L164: 	errGoModCase       = errors.New("go.mod files must have lowercase names")
		zip.go#L169: 	errVCS           = errors.New("directory is a version control repository")
		zip.go#L170: 	errVendored      = errors.New("file is in vendor directory")
		zip.go#L171: 	errSubmoduleFile = errors.New("file is in another module")
		zip.go#L172: 	errSubmoduleDir  = errors.New("directory is in another module")
		zip.go#L173: 	errHgArchivalTxt = errors.New("file is inserted by 'hg archive' and is always omitted")
		zip.go#L174: 	errSymlink       = errors.New("file is a symbolic link")
		zip.go#L175: 	errNotRegular    = errors.New("not a regular file")

	golang.org/x/net/html
		parse.go#L2374: 			return nil, errors.New("html: ParseFragment of non-element Node")
		render.go#L58: var plaintextAbort = errors.New("html: internal error (plaintext abort)")
		render.go#L72: 		return errors.New("html: cannot render an ErrorNode node")
		render.go#L141: 		return errors.New("html: unknown node type")
		token.go#L38: var ErrBufferExceeded = errors.New("max buffer exceeded")

	golang.org/x/net/http2
		databuffer.go#L73: var errReadEmpty = errors.New("read from empty dataBuffer")
		errors.go#L131: 	errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
		errors.go#L132: 	errPseudoAfterRegular   = errors.New("pseudo header field after regular")
		frame.go#L469: var ErrFrameTooLarge = errors.New("http2: frame too large")
		frame.go#L527: 	fr.errDetail = errors.New(reason)
		frame.go#L623: 	errStreamID    = errors.New("invalid stream ID")
		frame.go#L624: 	errDepStreamID = errors.New("invalid dependent stream ID")
		frame.go#L625: 	errPadLength   = errors.New("pad length too large")
		frame.go#L626: 	errPadBytes    = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
		frame.go#L956: 		return errors.New("illegal window increment value")
		frame.go#L1484: 		return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
		gotrack.go#L111: 		err = errors.New("invalid base " + strconv.Itoa(base))
		pipe.go#L69: var errClosedPipeWrite = errors.New("write on closed buffer")
		server.go#L63: 	errClientDisconnected = errors.New("client disconnected")
		server.go#L64: 	errClosedBody         = errors.New("body closed by handler")
		server.go#L65: 	errHandlerComplete    = errors.New("http2: request body closed due to handler exiting")
		server.go#L66: 	errStreamClosed       = errors.New("http2: stream closed")
		server.go#L955: var errPrefaceTimeout = errors.New("timeout waiting for client preface")
		server.go#L1175: var errHandlerPanicked = errors.New("http2: handler panicked")
		server.go#L2703: 		return 0, errors.New("http2: handler wrote more than declared Content-Length")
		server.go#L2732: 	ErrRecursivePush    = errors.New("http2: recursive push not allowed")
		server.go#L2733: 	ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
		server.go#L2781: 			return errors.New("URL must have a host")
		server.go#L2961: 		return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
		transport.go#L466: 		return nil, errors.New("http2: unsupported scheme")
		transport.go#L513: 	errClientConnClosed    = errors.New("http2: client conn is closed")
		transport.go#L514: 	errClientConnUnusable  = errors.New("http2: client conn not usable")
		transport.go#L515: 	errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
		transport.go#L618: 		return nil, errors.New("http2: could not negotiate protocol mutually")
		transport.go#L916: 	err := errors.New("http2: client connection force closed via ClientConn.Close")
		transport.go#L922: 	err := errors.New("http2: client connection lost")
		transport.go#L968: var errRequestCanceled = errors.New("net/http: request canceled")
		transport.go#L1300: 	errStopReqBodyWrite = errors.New("http2: aborting request body write")
		transport.go#L1303: 	errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
		transport.go#L1305: 	errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
		transport.go#L1964: 		return nil, errors.New("malformed response from server: missing status pseudo header")
		transport.go#L1968: 		return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
		transport.go#L2012: 			return nil, errors.New("http2: too many 1xx informational responses")
		transport.go#L2113: 				err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
		transport.go#L2164: var errClosedResponseBody = errors.New("http2: response body closed")
		transport.go#L2518: 	errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
		transport.go#L2519: 	errRequestHeaderListSize  = errors.New("http2: request header list larger than peer's advertised limit")

	golang.org/x/net/http2/hpack
		hpack.go#L116: var ErrStringLength = errors.New("hpack: string too long")
		hpack.go#L238: 		return DecodingError{errors.New("truncated headers")}
		hpack.go#L287: var errNeedMore = errors.New("need more data")
		hpack.go#L334: 	return DecodingError{errors.New("invalid encoding")}
		hpack.go#L403: 		return DecodingError{errors.New("dynamic table size update MUST occur at the beginning of a header block")}
		hpack.go#L412: 		return DecodingError{errors.New("dynamic table size update too large")}
		hpack.go#L419: var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
		huffman.go#L44: var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")

	golang.org/x/net/internal/socks
		client.go#L57: 			return nil, errors.New("too many authentication methods")
		client.go#L72: 		return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
		client.go#L76: 		return nil, errors.New("no acceptable authentication methods")
		client.go#L94: 			return nil, errors.New("unknown address type")
		client.go#L98: 			return nil, errors.New("FQDN too long")
		client.go#L113: 		return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
		client.go#L116: 		return nil, errors.New("unknown error " + cmdErr.String())
		client.go#L119: 		return nil, errors.New("non-zero reserved field")
		client.go#L136: 		return nil, errors.New("unknown address type " + strconv.Itoa(int(b[3])))
		client.go#L165: 		return "", 0, errors.New("port number out of range " + port)
		socks.go#L158: 		return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
		socks.go#L194: 		return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
		socks.go#L237: 		return errors.New("network not implemented")
		socks.go#L242: 		return errors.New("command not implemented")
		socks.go#L293: 			return errors.New("invalid username/password")
		socks.go#L309: 			return errors.New("invalid username/password version")
		socks.go#L312: 			return errors.New("username/password authentication failed")
		socks.go#L316: 	return errors.New("unsupported authentication method " + strconv.Itoa(int(auth)))

	golang.org/x/net/proxy
		proxy.go#L109: 	return nil, errors.New("proxy: unknown scheme: " + u.Scheme)

	golang.org/x/oauth2
		oauth2.go#L267: 		return nil, errors.New("oauth2: token expired and refresh token is not set")
		transport.go#L43: 		return nil, errors.New("oauth2: Transport's Source is nil")

	golang.org/x/oauth2/google
		google.go#L62: 		return nil, errors.New("oauth2/google: missing redirect URL in the client_credentials.json")
		google.go#L145: 		return nil, errors.New("missing 'type' field in credentials")
		google.go#L169: 		return nil, errors.New("oauth2/google: can't get a token from the metadata service; not running on GCE")
		sdk.go#L186: 		return "", errors.New("unable to get current user home directory: os/user lookup failed; $HOME is empty")

	golang.org/x/oauth2/internal
		oauth2.go#L34: 		return nil, errors.New("private key is invalid")
		token.go#L282: 		return nil, errors.New("oauth2: server response missing access_token")

	golang.org/x/oauth2/jws
		jws.go#L122: 		return nil, errors.New("jws: invalid token received")
		jws.go#L170: 		return errors.New("jws: invalid token received, token must have 3 parts")

	golang.org/x/pkgsite/internal/config
		config.go#L395: 			return nil, errors.New("GO_DISCOVERY_CONFIG_DYNAMIC must be set if GO_DISCOVERY_CONFIG_BUCKET is")
		config.go#L440: 			return nil, errors.New("on GCP but using an unknown product")
		config.go#L468: 			return nil, errors.New("HMAC secret must be at least 16 bytes")

	golang.org/x/pkgsite/internal/config/dynconfig
		dynconfig.go#L45: 			return nil, errors.New("bad GCS URL")

	golang.org/x/pkgsite/internal/database
		copy.go#L36: 		return errors.New("not in a transaction")
		copy.go#L78: 		return errors.New("not in a transaction")
		database.go#L239: 		return errors.New("a DB Transact function was called on a DB already in a transaction")
		database.go#L306: 		return errors.New("need returningColumns and scan function")
		database.go#L452: 		return errors.New("need at least two columns")
		database.go#L455: 		return errors.New("len(values) != len(columns)")
		database.go#L460: 			return errors.New("all values slices must be the same length")
		driver.go#L71: func (c *wrapConn) Begin() (driver.Tx, error)                 { return nil, errors.New("unimplmented") }
		reflect.go#L134: 		return errors.New("collectStructs: arg is not a pointer")
		reflect.go#L138: 		return errors.New("collectStructs: arg is not a pointer to a slice")

	golang.org/x/pkgsite/internal/derrors
		derrors.go#L23: 	HasIncompletePackages = errors.New("has incomplete packages")
		derrors.go#L26: 	NotFound = errors.New("not found")
		derrors.go#L31: 	NotFetched = errors.New("not fetched by proxy")
		derrors.go#L35: 	InvalidArgument = errors.New("invalid argument")
		derrors.go#L37: 	BadModule = errors.New("bad module")
		derrors.go#L39: 	Excluded = errors.New("excluded")
		derrors.go#L43: 	AlternativeModule = errors.New("alternative module")
		derrors.go#L48: 	ModuleTooLarge = errors.New("module too large")
		derrors.go#L52: 	SheddingLoad = errors.New("shedding load")
		derrors.go#L56: 	Cleaned = errors.New("cleaned")
		derrors.go#L59: 	Unknown = errors.New("unknown")
		derrors.go#L62: 	ProxyTimedOut = errors.New("proxy timed out")
		derrors.go#L65: 	ProxyError = errors.New("proxy error")
		derrors.go#L69: 	PackageBuildContextNotSupported = errors.New("package build context not supported")
		derrors.go#L72: 	PackageMaxImportsLimitExceeded = errors.New("package max imports limit exceeded")
		derrors.go#L75: 	PackageMaxFileSizeLimitExceeded = errors.New("package max file size limit exceeded")
		derrors.go#L78: 	PackageDocumentationHTMLTooLarge = errors.New("package documentation HTML is too large")
		derrors.go#L84: 	PackageBadImportPath = errors.New("package bad import path")
		derrors.go#L89: 	PackageInvalidContents = errors.New("package invalid contents")
		derrors.go#L94: 	DBModuleInsertInvalid = errors.New("db module insert invalid")
		derrors.go#L98: 	ReprocessStatusOK = errors.New("reprocess status ok")
		derrors.go#L101: 	ReprocessHasIncompletePackages = errors.New("reprocess has incomplete packages")
		derrors.go#L104: 	ReprocessBadModule = errors.New("reprocess bad module")
		derrors.go#L107: 	ReprocessAlternative = errors.New("reprocess alternative module")
		derrors.go#L111: 	ReprocessDBModuleInsertInvalid = errors.New("reprocess db module insert invalid")

	golang.org/x/pkgsite/internal/fetch
		fetch.go#L38: 	ErrModuleContainsNoPackages = errors.New("module contains 0 packages")
		fetch.go#L39: 	errMalformedZip             = errors.New("module zip is malformed")
		latest.go#L63: 			return nil, errors.New("no versions for stdlib")

	golang.org/x/pkgsite/internal/frontend
		404.go#L210: 				err:        errors.New(vm.Error),
		404.go#L260: 		err = errors.New(vm.Error)
		fetch.go#L36: 	errModuleDoesNotExist = errors.New("module does not exist")
		fetch.go#L39: 	errPathDoesNotExistInModule = errors.New("path does not exist in module")

	golang.org/x/pkgsite/internal/godoc/dochtml
		dochtml.go#L38: 	ErrTooLarge = errors.New("rendered documentation HTML size exceeded the specified limit")

	golang.org/x/pkgsite/internal/godoc/dochtml/internal/render
		linkify.go#L179: 		return "", errors.New("Please include an example with code")

	golang.org/x/pkgsite/internal/log
		log.go#L167: 		return nil, errors.New("already called once")

	golang.org/x/pkgsite/internal/middleware
		iapheader.go#L38: 		return errors.New("missing IAP token")

	golang.org/x/pkgsite/internal/postgres
		details.go#L179: 		return errors.New("not a []byte")
		insert_module.go#L510: 						ch <- database.RowItem{Err: errors.New("empty GOOS or GOARCH")}
		insert_module.go#L733: 		return errors.New("not in a transaction")
		path.go#L98: 			return 0, errors.New("got no rows; shouldn't happen")
		path.go#L105: 		return 0, errors.New("zero ID")
		version.go#L604: 		return errors.New("more than one row affected")

	golang.org/x/pkgsite/internal/proxy
		client.go#L172: 		return 0, errors.New("unknown content length")
		client.go#L181: 		return "", errors.New(`suffix must be "info", "mod" or "zip"`)

	golang.org/x/pkgsite/internal/queue
		queue.go#L85: 		return nil, errors.New("empty queueID")
		queue.go#L88: 		return nil, errors.New("empty ProjectID")
		queue.go#L91: 		return nil, errors.New("empty LocationID")
		queue.go#L94: 		return nil, errors.New("empty QueueURL")
		queue.go#L97: 		return nil, errors.New("empty ServiceAccount")
		queue.go#L100: 		return nil, errors.New("empty QueueAudience")
		queue.go#L129: 		return false, errors.New("given unknown module path")

	golang.org/x/pkgsite/internal/secrets
		secrets.go#L25: 		return "", errors.New("need GOOGLE_CLOUD_PROJECT environment variable")

	golang.org/x/pkgsite/internal/worker
		fetch.go#L63: 		return http.StatusInternalServerError, "", errors.New("called with internal.UnknownModulePath")
		server.go#L245: 			errors.New("must provide 'before' query param as an RFC3339 datetime"),
		server.go#L513: 		return &serverError{http.StatusBadRequest, errors.New("app_version was not specified")}
		server.go#L564: 		return errors.New("redis cache client is not configured")
		server.go#L606: 		return errors.New("need 'limit' or 'module' query param")
		server.go#L609: 		return errors.New("need exactly one of 'limit' or 'module' query param")

	golang.org/x/text/internal/language
		language.go#L314: 	errPrivateUse       = errors.New("cannot set a key on a private use tag")
		language.go#L315: 	errInvalidArguments = errors.New("invalid key or type")
		language.go#L546: var errNoTLD = errors.New("language: region is not a valid ccTLD")
		match.go#L37: var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
		parse.go#L35: var ErrSyntax = errors.New("language: tag is not well-formed")
		parse.go#L39: var ErrDuplicateKey = errors.New("language: different values for same key in -u extension")

	golang.org/x/text/language
		match.go#L134: var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
		parse.go#L90: var errInvalidArgument = errors.New("invalid Extension or Variant")
		parse.go#L135: var errInvalidWeight = errors.New("ParseAcceptLanguage: invalid weight")

	golang.org/x/text/secure/bidirule
		bidirule.go#L46: var ErrInvalid = errors.New("bidirule: failed Bidi Rule")

	golang.org/x/text/secure/precis
		context.go#L37: var errContext = errors.New("precis: contextual rule violated")
		profile.go#L21: 	errDisallowedRune = errors.New("precis: disallowed rune encountered")
		profile.go#L116: var errEmptyString = errors.New("precis: transformation resulted in empty string")

	golang.org/x/text/transform
		transform.go#L21: 	ErrShortDst = errors.New("transform: short destination buffer")
		transform.go#L25: 	ErrShortSrc = errors.New("transform: short source buffer")
		transform.go#L29: 	ErrEndOfSpan = errors.New("transform: input and output are not identical")
		transform.go#L33: 	errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
		transform.go#L37: 	errShortInternal = errors.New("transform: short internal buffer")

	google.golang.org/api/googleapi
		types.go#L166: 		return errors.New("googleapi.RawMessage: UnmarshalJSON on nil pointer")

	google.golang.org/api/googleapi/transport
		apikey.go#L36: 			return nil, errors.New("googleapi/transport: no Transport specified or available")

	google.golang.org/api/internal
		settings.go#L58: 		return errors.New("options.WithoutAuthentication is incompatible with any option that provides credentials")
		settings.go#L80: 		return errors.New("WithScopes is incompatible with WithAudience")
		settings.go#L84: 		return errors.New("multiple credential options provided")
		settings.go#L87: 		return errors.New("WithGRPCConn is incompatible with WithConnPool")
		settings.go#L90: 		return errors.New("WithHTTPClient is incompatible with WithConnPool")
		settings.go#L93: 		return errors.New("WithHTTPClient is incompatible with WithGRPCConn")
		settings.go#L96: 		return errors.New("WithHTTPClient is incompatible with gRPC dial options")
		settings.go#L99: 		return errors.New("WithHTTPClient is incompatible with QuotaProject")
		settings.go#L102: 		return errors.New("WithHTTPClient is incompatible with RequestReason")
		settings.go#L105: 		return errors.New("WithHTTPClient is incompatible with WithClientCertSource")
		settings.go#L108: 		return errors.New("WithClientCertSource is currently only supported for HTTP. gRPC settings are incompatible")
		settings.go#L111: 		return errors.New("WithImpersonatedCredentials requires scopes being provided")

	google.golang.org/api/internal/gensupport
		jsonfloat.go#L46: 	return errors.New("google.golang.org/api/internal: data not float or string")
		resumable.go#L143: 		return nil, errors.New("unexpected 308 response status code")
		send.go#L40: 		return nil, errors.New("google api: custom Accept-Encoding headers not allowed")
		send.go#L90: 		return nil, errors.New("google api: custom Accept-Encoding headers not allowed")

	google.golang.org/api/internal/third_party/uritemplates
		uritemplates.go#L83: 				return nil, errors.New("unexpected }")
		uritemplates.go#L90: 			return nil, errors.New("malformed template")
		uritemplates.go#L188: 		err = errors.New("multiple colons in same term")
		uritemplates.go#L191: 		err = errors.New("not a valid name: " + result.name)
		uritemplates.go#L194: 		err = errors.New("both explode and prefix modifiers on same term")

	google.golang.org/api/iterator
		iterator.go#L17: var Done = errors.New("no more items in iterator")
		iterator.go#L21: var errMixed = errors.New("iterator: Next and NextPage called on same iterator")
		iterator.go#L173: 		p.pageInfo.err = errors.New("iterator: page size must be positive")
		iterator.go#L203: 		return "", errors.New("must call NextPage with an empty buffer")
		iterator.go#L209: 		return "", errors.New("nil passed to Pager.NextPage")

	google.golang.org/api/storage/v1
		storage-gen.go#L75: var _ = errors.New
		storage-gen.go#L136: 		return nil, errors.New("client is nil")

	google.golang.org/api/support/bundler
		bundler.go#L41: 	ErrOverflow = errors.New("bundler reached buffered byte limit")
		bundler.go#L44: 	ErrOversizedItem = errors.New("item size exceeds bundle byte limit")
		bundler.go#L48: 	errMixedMethods = errors.New("calls to Add and AddWait cannot be mixed")

	google.golang.org/api/transport/cert
		default_cert.go#L92: 		return errors.New("empty cert_provider_command")

	google.golang.org/api/transport/grpc
		dial.go#L110: 		return nil, errors.New("unsupported HTTP client specified")

	google.golang.org/api/transport/http
		dial.go#L71: 		return nil, errors.New("transport/http: WithHTTPClient passed to NewTransport")
		dial.go#L123: 		return nil, errors.New("unsupported gRPC connection specified")
		dial.go#L139: 		return nil, errors.New("transport: no Transport specified")
		dial.go#L281: 		return "", errors.New("WithEndpoint requires a full URL path")

	google.golang.org/grpc
		clientconn.go#L68: 	errConnDrain = errors.New("grpc: the connection is drained")
		clientconn.go#L70: 	errConnClosing = errors.New("grpc: the connection is closing")
		clientconn.go#L81: 	errNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithInsecure() explicitly or set credentials)")
		clientconn.go#L84: 	errTransportCredsAndBundle = errors.New("grpc: credentials.Bundle may not be used with individual TransportCredentials")
		clientconn.go#L88: 	errTransportCredentialsMissing = errors.New("grpc: the credentials require transport level security (use grpc.WithTransportCredentials() to set)")
		clientconn.go#L91: 	errCredentialsConflict = errors.New("grpc: transport credentials are set for an insecure connection (grpc.WithTransportCredentials() and grpc.WithInsecure() are both called)")
		clientconn.go#L1294: 		return nil, nil, errors.New("timed out waiting for server handshake")
		clientconn.go#L1299: 		return nil, nil, errors.New("connection closed")
		clientconn.go#L1535: var ErrClientConnTimeout = errors.New("grpc: timed out when dialing")
		pickfirst.go#L67: 		b.ResolverError(errors.New("produced zero addresses"))
		proxy.go#L38: 	errDisabled = errors.New("proxy is disabled for the address")
		server.go#L645: var ErrServerStopped = errors.New("grpc: the server has been stopped")
		service_config.go#L233: 	errDuplicatedName             = errors.New("duplicated name")
		service_config.go#L234: 	errEmptyServiceNonEmptyMethod = errors.New("cannot combine empty 'service' and non-empty 'method'")
		stream.go#L947: 		return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
		stream.go#L1022: 		return nil, errors.New("transport provided is nil")
		stream.go#L1264: 		return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))

	google.golang.org/grpc/balancer
		balancer.go#L230: 	ErrNoSubConnAvailable = errors.New("no SubConn is available")
		balancer.go#L237: 	ErrTransientFailure = errors.New("all SubConns are in TransientFailure")
		balancer.go#L335: var ErrBadResolverState = errors.New("bad resolver state")

	google.golang.org/grpc/balancer/base
		balancer.go#L131: 		b.ResolverError(errors.New("produced zero addresses"))

	google.golang.org/grpc/balancer/grpclb
		grpclb.go#L52: var errServerTerminatedConnection = errors.New("grpclb: failed to recv server list: server terminated connection")

	google.golang.org/grpc/credentials
		credentials.go#L125: var ErrConnDispatched = errors.New("credentials: rawConn is dispatched out of gRPC")
		credentials.go#L238: 		return errors.New("unable to obtain SecurityLevel from context")

	google.golang.org/grpc/credentials/alts
		alts.go#L69: 	ErrUntrustedPlatform = errors.New("ALTS: untrusted platform. ALTS is only supported on GCP")
		alts.go#L215: 		return nil, nil, errors.New("client-side auth info is not of type alts.AuthInfo")
		alts.go#L258: 		return nil, nil, errors.New("server-side auth info is not of type alts.AuthInfo")
		utils.go#L76: 			return nil, errors.New("cannot determine the machine's manufacturer")
		utils.go#L116: 		return nil, errors.New("got nil reader")
		utils.go#L132: 		return nil, errors.New("no Peer found in Context")
		utils.go#L143: 		return nil, errors.New("no alts.AuthInfo found in Peer")

	google.golang.org/grpc/credentials/alts/internal/conn
		common.go#L35: var ErrAuth = errors.New("message authentication failed")
		counter.go#L28: 	errInvalidCounter = errors.New("invalid counter")

	google.golang.org/grpc/credentials/alts/internal/handshaker
		handshaker.go#L66: 	errDropped = errors.New("maximum number of concurrent ALTS handshakes is reached")
		handshaker.go#L69: 	errOutOfBound = errors.New("handshaker service consumed bytes value is out-of-bound")
		handshaker.go#L198: 		return nil, nil, errors.New("only handshakers created using NewClientHandshaker can perform a client handshaker")
		handshaker.go#L241: 		return nil, nil, errors.New("only handshakers created using NewServerHandshaker can perform a server handshaker")

	google.golang.org/grpc/internal/binarylog
		env_config.go#L65: 		return errors.New("empty string is not a valid method binary logging config")

	google.golang.org/grpc/internal/grpcutil
		method.go#L31: 		return "", "", errors.New("invalid method name: should start with /")
		method.go#L37: 		return "", "", errors.New("invalid method name: suffix /method is missing")

	google.golang.org/grpc/internal/resolver/dns
		dns_resolver.go#L65: 	errMissingAddr = errors.New("dns resolver: missing address")
		dns_resolver.go#L71: 	errEndsWithColon = errors.New("dns resolver: missing port after port-separator colon")

	google.golang.org/grpc/internal/status
		status.go#L107: 		return nil, errors.New("no error details for status with code OK")

	google.golang.org/grpc/internal/transport
		handler_server.go#L54: 		return nil, errors.New("gRPC requires HTTP/2")
		handler_server.go#L57: 		return nil, errors.New("invalid gRPC request method")
		handler_server.go#L63: 		return nil, errors.New("invalid gRPC request content-type")
		handler_server.go#L66: 		return nil, errors.New("gRPC requires a ResponseWriter supporting http.Flusher")
		http2_server.go#L54: 	ErrIllegalHeaderWrite = errors.New("transport: the stream is done or WriteHeader was already called")
		http2_server.go#L57: 	ErrHeaderListSizeLimitViolation = errors.New("transport: trying to send header list size larger than the limit set by peer")
		http2_server.go#L1056: 		return errors.New("transport: Close() was already called")
		transport.go#L751: 	errStreamDone = errors.New("the stream is done")

	google.golang.org/protobuf/internal/errors
		errors.go#L16: var Error = errors.New("protobuf error")

	google.golang.org/protobuf/internal/impl
		codec_map.go#L133: 			return out, errors.New("invalid field number")
		codec_map.go#L190: 			return out, errors.New("invalid field number")

	gopkg.in/yaml.v2
		yaml.go#L350: 					return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
		yaml.go#L360: 					return nil, errors.New("Multiple ,inline maps in struct " + st.String())
		yaml.go#L363: 					return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String())
		yaml.go#L374: 						return nil, errors.New(msg)
		yaml.go#L387: 				return nil, errors.New("Option ,inline needs a struct value field")
		yaml.go#L400: 			return nil, errors.New(msg)

	hash/adler32
		adler32.go#L67: 		return errors.New("hash/adler32: invalid hash state identifier")
		adler32.go#L70: 		return errors.New("hash/adler32: invalid hash state size")

	hash/crc32
		crc32.go#L186: 		return errors.New("hash/crc32: invalid hash state identifier")
		crc32.go#L189: 		return errors.New("hash/crc32: invalid hash state size")
		crc32.go#L192: 		return errors.New("hash/crc32: tables do not match")

	hash/fnv
		fnv.go#L272: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L275: 		return errors.New("hash/fnv: invalid hash state size")
		fnv.go#L283: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L286: 		return errors.New("hash/fnv: invalid hash state size")
		fnv.go#L294: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L297: 		return errors.New("hash/fnv: invalid hash state size")
		fnv.go#L305: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L308: 		return errors.New("hash/fnv: invalid hash state size")
		fnv.go#L316: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L319: 		return errors.New("hash/fnv: invalid hash state size")
		fnv.go#L328: 		return errors.New("hash/fnv: invalid hash state identifier")
		fnv.go#L331: 		return errors.New("hash/fnv: invalid hash state size")

	image
		format.go#L16: var ErrFormat = errors.New("image: unknown format")

	image/jpeg
		writer.go#L578: 		return errors.New("jpeg: image is too large to encode")

	internal/oserror
		errors.go#L13: 	ErrInvalid    = errors.New("invalid argument")
		errors.go#L14: 	ErrPermission = errors.New("permission denied")
		errors.go#L15: 	ErrExist      = errors.New("file already exists")
		errors.go#L16: 	ErrNotExist   = errors.New("file does not exist")
		errors.go#L17: 	ErrClosed     = errors.New("file already closed")

	internal/poll
		fd.go#L20: var ErrNetClosing = errors.New("use of closed network connection")
		fd.go#L24: var ErrFileClosing = errors.New("use of closed file")
		fd.go#L28: var ErrNoDeadline = errors.New("file type does not support deadline")
		fd.go#L55: var ErrNotPollable = errors.New("not pollable")
		fd_poll_runtime.go#L85: 		return errors.New("waiting for unsupported file type")

	io
		io.go#L29: var ErrShortWrite = errors.New("short write")
		io.go#L32: var errInvalidWrite = errors.New("invalid write result")
		io.go#L35: var ErrShortBuffer = errors.New("short buffer")
		io.go#L44: var EOF = errors.New("EOF")
		io.go#L48: var ErrUnexpectedEOF = errors.New("unexpected EOF")
		io.go#L53: var ErrNoProgress = errors.New("multiple Read calls return no data or error")
		io.go#L505: var errWhence = errors.New("Seek: invalid whence")
		io.go#L506: var errOffset = errors.New("Seek: invalid offset")
		pipe.go#L36: var ErrClosedPipe = errors.New("io: read/write on closed pipe")

	io/fs
		readdir.go#L41: 		return nil, &PathError{Op: "readdir", Path: name, Err: errors.New("not implemented")}
		sub.go#L36: 		return nil, &PathError{Op: "sub", Path: dir, Err: errors.New("invalid name")}
		sub.go#L55: 		return "", &PathError{Op: op, Path: name, Err: errors.New("invalid name")}
		sub.go#L122: 			return nil, errors.New("invalid result from inner fsys Glob: " + name + " not in " + f.dir) // can't use fmt in this package
		walk.go#L15: var SkipDir = errors.New("skip this directory")

	io/ioutil
		tempfile.go#L78: var errPatternHasSeparator = errors.New("pattern contains path separator")

	math/big
		intconv.go#L253: 		return errors.New("Int.Scan: invalid verb")
		natconv.go#L60: 	errNoDigits = errors.New("number has no digits")
		natconv.go#L61: 	errInvalSep = errors.New("'_' must separate successive digits")
		ratconv.go#L32: 		return errors.New("Rat.Scan: invalid verb")
		ratconv.go#L35: 		return errors.New("Rat.Scan: invalid syntax")
		ratmarsh.go#L29: 		return nil, errors.New("Rat.GobEncode: numerator too large")

	mime
		encodedword.go#L29: 	errInvalidWord = errors.New("mime: invalid RFC 2047 encoded-word")
		mediatype.go#L107: 		return errors.New("mime: no media type")
		mediatype.go#L113: 		return errors.New("mime: expected slash after first token")
		mediatype.go#L117: 		return errors.New("mime: expected token after slash")
		mediatype.go#L120: 		return errors.New("mime: unexpected content after media subtype")
		mediatype.go#L128: var ErrInvalidMediaParameter = errors.New("mime: invalid media parameter")
		mediatype.go#L190: 			return "", nil, errors.New("mime: duplicate parameter name")

	mime/multipart
		formdata.go#L18: var ErrMessageTooLarge = errors.New("multipart: message too large")
		writer.go#L47: 		return errors.New("mime: SetBoundary called after write")
		writer.go#L51: 		return errors.New("mime: invalid boundary length")
		writer.go#L66: 		return errors.New("mime: invalid boundary character")
		writer.go#L194: 		return 0, errors.New("multipart: can't write to finished part")

	net
		dnsclient_unix.go#L35: 	errLameReferral              = errors.New("lame referral")
		dnsclient_unix.go#L36: 	errCannotUnmarshalDNSMessage = errors.New("cannot unmarshal DNS message")
		dnsclient_unix.go#L37: 	errCannotMarshalDNSMessage   = errors.New("cannot marshal DNS message")
		dnsclient_unix.go#L38: 	errServerMisbehaving         = errors.New("server misbehaving")
		dnsclient_unix.go#L39: 	errInvalidDNSResponse        = errors.New("invalid DNS response")
		dnsclient_unix.go#L40: 	errNoAnswerFromDNSServer     = errors.New("no answer from DNS server")
		dnsclient_unix.go#L45: 	errServerTemporarilyMisbehaving = errors.New("server misbehaving")
		interface.go#L20: 	errInvalidInterface         = errors.New("invalid network interface")
		interface.go#L21: 	errInvalidInterfaceIndex    = errors.New("invalid network interface index")
		interface.go#L22: 	errInvalidInterfaceName     = errors.New("invalid network interface name")
		interface.go#L23: 	errNoSuchInterface          = errors.New("no such network interface")
		interface.go#L24: 	errNoSuchMulticastInterface = errors.New("no such multicast network interface")
		net.go#L406: 	errNoSuitableAddress = errors.New("no suitable address found")
		net.go#L409: 	errMissingAddress = errors.New("missing address")
		net.go#L412: 	errCanceled         = errors.New("operation was canceled")
		net.go#L413: 	ErrWriteToConnected = errors.New("use of WriteTo with pre-connected connection")
		net.go#L601: 	errNoSuchHost = errors.New("no such host")
		nss.go#L91: 			return errors.New("no colon on line")
		nss.go#L114: 					return errors.New("unclosed criterion bracket")
		nss.go#L119: 					return errors.New("invalid criteria: " + string(srcs[1:bclose]))
		nss.go#L145: 			return errors.New("criterion too short")
		nss.go#L149: 			return errors.New("criterion lacks equal sign")
		unixsock_posix.go#L42: 		return nil, errors.New("unknown mode: " + mode)

	net/http
		client.go#L208: 		return nil, alwaysFalse, errors.New("http: no Client.Transport or DefaultTransport")
		client.go#L213: 		return nil, alwaysFalse, errors.New("http: nil Request.URL")
		client.go#L218: 		return nil, alwaysFalse, errors.New("http: Request.RequestURI can't be set in client requests")
		client.go#L262: 				err = errors.New("http: server gave HTTP response to HTTPS client")
		client.go#L483: var ErrUseLastResponse = errors.New("net/http: use last response")
		client.go#L598: 			Err: errors.New("http: nil Request.URL"),
		client.go#L806: 		return errors.New("stopped after 10 redirects")
		fs.go#L73: 		return nil, errors.New("http: invalid character in file path")
		fs.go#L211: var errSeeker = errors.New("seeker can't seek")
		fs.go#L215: var errNoOverlap = errors.New("invalid range: failed to overlap")
		fs.go#L771: var errMissingSeek = errors.New("io.File missing Seek method")
		fs.go#L772: var errMissingReadDir = errors.New("io.File directory missing ReadDir method")
		fs.go#L875: 		return nil, errors.New("invalid range")
		fs.go#L886: 			return nil, errors.New("invalid range")
		fs.go#L897: 				return nil, errors.New("invalid range")
		fs.go#L901: 				return nil, errors.New("invalid range")
		fs.go#L911: 				return nil, errors.New("invalid range")
		fs.go#L926: 					return nil, errors.New("invalid range")
		h2_bundle.go#L1016: var http2errReadEmpty = errors.New("read from empty dataBuffer")
		h2_bundle.go#L1212: 	http2errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
		h2_bundle.go#L1213: 	http2errPseudoAfterRegular   = errors.New("pseudo header field after regular")
		h2_bundle.go#L1712: var http2ErrFrameTooLarge = errors.New("http2: frame too large")
		h2_bundle.go#L1770: 	fr.errDetail = errors.New(reason)
		h2_bundle.go#L1866: 	http2errStreamID    = errors.New("invalid stream ID")
		h2_bundle.go#L1867: 	http2errDepStreamID = errors.New("invalid dependent stream ID")
		h2_bundle.go#L1868: 	http2errPadLength   = errors.New("pad length too large")
		h2_bundle.go#L1869: 	http2errPadBytes    = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
		h2_bundle.go#L2199: 		return errors.New("illegal window increment value")
		h2_bundle.go#L2727: 		return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
		h2_bundle.go#L2967: 		err = errors.New("invalid base " + strconv.Itoa(base))
		h2_bundle.go#L3519: var http2errClosedPipeWrite = errors.New("write on closed buffer")
		h2_bundle.go#L3629: 	http2errClientDisconnected = errors.New("client disconnected")
		h2_bundle.go#L3630: 	http2errClosedBody         = errors.New("body closed by handler")
		h2_bundle.go#L3631: 	http2errHandlerComplete    = errors.New("http2: request body closed due to handler exiting")
		h2_bundle.go#L3632: 	http2errStreamClosed       = errors.New("http2: stream closed")
		h2_bundle.go#L4526: var http2errPrefaceTimeout = errors.New("timeout waiting for client preface")
		h2_bundle.go#L4746: var http2errHandlerPanicked = errors.New("http2: handler panicked")
		h2_bundle.go#L6258: 		return 0, errors.New("http2: handler wrote more than declared Content-Length")
		h2_bundle.go#L6287: 	http2ErrRecursivePush    = errors.New("http2: recursive push not allowed")
		h2_bundle.go#L6288: 	http2ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
		h2_bundle.go#L6336: 			return errors.New("URL must have a host")
		h2_bundle.go#L6516: 		return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
		h2_bundle.go#L6969: 		return nil, errors.New("http2: unsupported scheme")
		h2_bundle.go#L7016: 	http2errClientConnClosed    = errors.New("http2: client conn is closed")
		h2_bundle.go#L7017: 	http2errClientConnUnusable  = errors.New("http2: client conn not usable")
		h2_bundle.go#L7018: 	http2errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
		h2_bundle.go#L7121: 		return nil, errors.New("http2: could not negotiate protocol mutually")
		h2_bundle.go#L7419: 	err := errors.New("http2: client connection force closed via ClientConn.Close")
		h2_bundle.go#L7425: 	err := errors.New("http2: client connection lost")
		h2_bundle.go#L7471: var http2errRequestCanceled = errors.New("net/http: request canceled")
		h2_bundle.go#L7803: 	http2errStopReqBodyWrite = errors.New("http2: aborting request body write")
		h2_bundle.go#L7806: 	http2errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
		h2_bundle.go#L7808: 	http2errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
		h2_bundle.go#L8467: 		return nil, errors.New("malformed response from server: missing status pseudo header")
		h2_bundle.go#L8471: 		return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
		h2_bundle.go#L8515: 			return nil, errors.New("http2: too many 1xx informational responses")
		h2_bundle.go#L8616: 				err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
		h2_bundle.go#L8667: var http2errClosedResponseBody = errors.New("http2: response body closed")
		h2_bundle.go#L9021: 	http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
		h2_bundle.go#L9022: 	http2errRequestHeaderListSize  = errors.New("http2: request header list larger than peer's advertised limit")
		request.go#L38: var ErrMissingFile = errors.New("http: no such file")
		request.go#L414: var ErrNoCookie = errors.New("http: named cookie not present")
		request.go#L468: 		return nil, errors.New("http: MultipartReader called twice")
		request.go#L471: 		return nil, errors.New("http: multipart handled by ParseMultipartForm")
		request.go#L542: var errMissingHost = errors.New("http: Request.Write on Request with no Host or URL set")
		request.go#L594: 		return errors.New("net/http: can't write control character in Request.URL")
		request.go#L864: 		return nil, errors.New("net/http: nil Context")
		request.go#L1173: 	l.err = errors.New("http: request body too large")
		request.go#L1189: 		err = errors.New("missing form body")
		request.go#L1215: 			err = errors.New("http: POST too large")
		request.go#L1294: 		return errors.New("http: multipart handled by MultipartReader")
		request.go#L1366: 		return nil, nil, errors.New("http: multipart handled by MultipartReader")
		response.go#L131: var ErrNoLocation = errors.New("http: no Location header in response")
		server.go#L41: 	ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")
		server.go#L48: 	ErrHijacked = errors.New("http: connection has been hijacked")
		server.go#L54: 	ErrContentLength = errors.New("http: wrote more than the declared Content-Length")
		server.go#L59: 	ErrWriteAfterFlush = errors.New("unused")
		server.go#L954: var errTooLarge = errors.New("http: request too large")
		server.go#L1797: var ErrAbortHandler = errors.New("net/http: abort Handler")
		server.go#L2939: var ErrServerClosed = errors.New("http: Server closed")
		server.go#L3276: var ErrHandlerTimeout = errors.New("http: Handler timeout")
		socks_bundle.go#L63: 			return nil, errors.New("too many authentication methods")
		socks_bundle.go#L78: 		return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
		socks_bundle.go#L82: 		return nil, errors.New("no acceptable authentication methods")
		socks_bundle.go#L100: 			return nil, errors.New("unknown address type")
		socks_bundle.go#L104: 			return nil, errors.New("FQDN too long")
		socks_bundle.go#L119: 		return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
		socks_bundle.go#L122: 		return nil, errors.New("unknown error " + cmdErr.String())
		socks_bundle.go#L125: 		return nil, errors.New("non-zero reserved field")
		socks_bundle.go#L142: 		return nil, errors.New("unknown address type " + strconv.Itoa(int(b[3])))
		socks_bundle.go#L171: 		return "", 0, errors.New("port number out of range " + port)
		socks_bundle.go#L314: 		return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
		socks_bundle.go#L350: 		return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
		socks_bundle.go#L393: 		return errors.New("network not implemented")
		socks_bundle.go#L398: 		return errors.New("command not implemented")
		socks_bundle.go#L449: 			return errors.New("invalid username/password")
		socks_bundle.go#L465: 			return errors.New("invalid username/password version")
		socks_bundle.go#L468: 			return errors.New("username/password authentication failed")
		socks_bundle.go#L472: 	return errors.New("unsupported authentication method " + strconv.Itoa(int(auth)))
		transfer.go#L826: var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")
		transfer.go#L906: var errTrailerEOF = errors.New("http: unexpected EOF reading trailer")
		transfer.go#L931: 		return errors.New("http: suspiciously long trailer after chunked body")
		transport.go#L509: 		return nil, errors.New("http: nil Request.URL")
		transport.go#L513: 		return nil, errors.New("http: nil Request.Header")
		transport.go#L556: 		return nil, errors.New("http: no Host in request URL")
		transport.go#L622: var errCannotRewind = errors.New("net/http: cannot rewind body after connection loss")
		transport.go#L727: var ErrSkipAltProtocol = errors.New("net/http: skip alternate protocol")
		transport.go#L852: 	errKeepAlivesDisabled = errors.New("http: putIdleConn: keep alives disabled")
		transport.go#L853: 	errConnBroken         = errors.New("http: putIdleConn: connection is in bad state")
		transport.go#L854: 	errCloseIdle          = errors.New("http: putIdleConn: CloseIdleConnections was called")
		transport.go#L855: 	errTooManyIdle        = errors.New("http: putIdleConn: too many idle connections")
		transport.go#L856: 	errTooManyIdleHost    = errors.New("http: putIdleConn: too many idle connections for host")
		transport.go#L857: 	errCloseIdleConns     = errors.New("http: CloseIdleConnections called")
		transport.go#L858: 	errReadLoopExiting    = errors.New("http: persistConn.readLoop exiting")
		transport.go#L859: 	errIdleConnTimeout    = errors.New("http: idle connection timeout")
		transport.go#L865: 	errServerClosedIdle = errors.New("http: server closed idle connection")
		transport.go#L1167: 			err = errors.New("net/http: Transport.Dial hook returned (nil, nil)")
		transport.go#L1315: 		err = errors.New("net/http: Transport.DialTLS or DialTLSContext returned (nil, nil)")
		transport.go#L1717: 				return nil, errors.New("unknown status code")
		transport.go#L1719: 			return nil, errors.New(f[1])
		transport.go#L2046: var errCallerOwnsConn = errors.New("read loop ending; caller owns writable underlying conn")
		transport.go#L2299: 				return nil, errors.New("net/http: too many 1xx informational responses")
		transport.go#L2508: var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?
		transport.go#L2751: var errReadOnClosedResBody = errors.New("http: read on closed response body")

	net/http/httputil
		dump.go#L293: var errNoBody = errors.New("sentinel error value")
		persist.go#L30: var errClosed = errors.New("i/o operation on closed connection")
		persist.go#L203: 		return errors.New("persist server pipe count")

	net/http/internal
		chunked.go#L21: var ErrLineTooLong = errors.New("header line too long")
		chunked.go#L81: 					cr.err = errors.New("malformed chunked encoding")
		chunked.go#L246: 			return 0, errors.New("invalid byte in chunk length")
		chunked.go#L249: 			return 0, errors.New("http chunk length too large")

	net/url
		url.go#L443: 				return "", "", errors.New("missing protocol scheme")
		url.go#L513: 		return nil, errors.New("net/url: invalid control character in URL")
		url.go#L517: 		return nil, errors.New("empty url")
		url.go#L547: 			return nil, errors.New("invalid URI for request")
		url.go#L560: 			return nil, errors.New("first path segment in URL cannot contain colon")
		url.go#L597: 		return nil, "", errors.New("net/url: invalid userinfo")
		url.go#L625: 			return "", errors.New("missing ']' in host")

	os
		exec.go#L18: var ErrProcessDone = errors.New("os: process already finished")
		exec_unix.go#L64: 		return errors.New("os: process already released")
		exec_unix.go#L67: 		return errors.New("os: process not initialized")
		exec_unix.go#L76: 		return errors.New("os: unsupported signal type")
		executable_darwin.go#L16: 		return ep, errors.New("cannot find executable path")
		file.go#L131: 		return 0, &PathError{Op: "readat", Path: f.name, Err: errors.New("negative offset")}
		file.go#L191: var errWriteAtInAppendMode = errors.New("os: invalid use of WriteAt on file opened with O_APPEND")
		file.go#L207: 		return 0, &PathError{Op: "writeat", Path: f.name, Err: errors.New("negative offset")}
		file.go#L406: 			return "", errors.New("%LocalAppData% is not defined")
		file.go#L412: 			return "", errors.New("$HOME is not defined")
		file.go#L419: 			return "", errors.New("$home is not defined")
		file.go#L428: 				return "", errors.New("neither $XDG_CACHE_HOME nor $HOME are defined")
		file.go#L457: 			return "", errors.New("%AppData% is not defined")
		file.go#L463: 			return "", errors.New("$HOME is not defined")
		file.go#L470: 			return "", errors.New("$home is not defined")
		file.go#L479: 				return "", errors.New("neither $XDG_CONFIG_HOME nor $HOME are defined")
		file.go#L511: 	return "", errors.New(enverr + " is not defined")
		tempfile.go#L52: var errPatternHasSeparator = errors.New("pattern contains path separator")

	os/exec
		exec.go#L392: 		return errors.New("exec: already started")
		exec.go#L500: 		return errors.New("exec: not started")
		exec.go#L503: 		return errors.New("exec: Wait was already called")
		exec.go#L536: 		return nil, errors.New("exec: Stdout already set")
		exec.go#L559: 		return nil, errors.New("exec: Stdout already set")
		exec.go#L562: 		return nil, errors.New("exec: Stderr already set")
		exec.go#L579: 		return nil, errors.New("exec: Stdin already set")
		exec.go#L582: 		return nil, errors.New("exec: StdinPipe after process started")
		exec.go#L621: 		return nil, errors.New("exec: Stdout already set")
		exec.go#L624: 		return nil, errors.New("exec: StdoutPipe after process started")
		exec.go#L646: 		return nil, errors.New("exec: Stderr already set")
		exec.go#L649: 		return nil, errors.New("exec: StderrPipe after process started")
		lp_unix.go#L18: var ErrNotFound = errors.New("executable file not found in $PATH")

	path
		match.go#L14: var ErrBadPattern = errors.New("syntax error in pattern")

	path/filepath
		match.go#L17: var ErrBadPattern = errors.New("syntax error in pattern")
		path.go#L283: 		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
		path.go#L309: 		return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
		symlink.go#L100: 			return "", errors.New("EvalSymlinks: too many links")

	runtime/pprof
		elf.go#L15: 	errBadELF    = errors.New("malformed ELF binary")
		elf.go#L16: 	errNoBuildID = errors.New("no NT_GNU_BUILD_ID found in ELF binary")

	strconv
		atoi.go#L18: var ErrRange = errors.New("value out of range")
		atoi.go#L21: var ErrSyntax = errors.New("invalid syntax")
		atoi.go#L45: 	return &NumError{fn, str, errors.New("invalid base " + Itoa(base))}
		atoi.go#L49: 	return &NumError{fn, str, errors.New("invalid bit size " + Itoa(bitSize))}

	strings
		reader.go#L53: 		return 0, errors.New("strings.Reader.ReadAt: negative offset")
		reader.go#L79: 		return errors.New("strings.Reader.UnreadByte: at beginning of string")
		reader.go#L105: 		return errors.New("strings.Reader.UnreadRune: at beginning of string")
		reader.go#L108: 		return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune")
		reader.go#L127: 		return 0, errors.New("strings.Reader.Seek: invalid whence")
		reader.go#L130: 		return 0, errors.New("strings.Reader.Seek: negative position")

	syscall
		exec_unix.go#L194: 		return 0, errorspkg.New("both Setctty and Foreground set in SysProcAttr")
		exec_unix.go#L197: 		return 0, errorspkg.New("Setctty set but Ctty not valid in child")

	testing
		testing.go#L1077: var errNilPanicOrGoexit = errors.New("test executed panic(nil) or runtime.Goexit")
		testing.go#L1313: var errMain = errors.New("testing: unexpected use of func Main")

	text/template
		funcs.go#L419: 	errBadComparisonType = errors.New("invalid type for comparison")
		funcs.go#L420: 	errBadComparison     = errors.New("incompatible types for comparison")
		funcs.go#L421: 	errNoComparison      = errors.New("missing argument for comparison")

	time
		format.go#L394: var atoiError = errors.New("time: invalid number")
		format.go#L678: var errBad = errors.New("bad value for field") // placeholder not passed to user
		format.go#L1304: var errLeadingInt = errors.New("time: bad [0-9]*") // never printed
		format.go#L1393: 		return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1405: 			return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1411: 			return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1425: 			return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1437: 			return 0, errors.New("time: missing unit in duration " + quote(orig))
		format.go#L1443: 			return 0, errors.New("time: unknown unit " + quote(u) + " in duration " + quote(orig))
		format.go#L1447: 			return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1456: 				return 0, errors.New("time: invalid duration " + quote(orig))
		format.go#L1462: 			return 0, errors.New("time: invalid duration " + quote(orig))
		sys_unix.go#L47: 				return errors.New("short read")
		tick.go#L24: 		panic(errors.New("non-positive interval for NewTicker"))
		time.go#L1152: 			return nil, errors.New("Time.MarshalBinary: zone offset has fractional minute")
		time.go#L1156: 			return nil, errors.New("Time.MarshalBinary: unexpected zone offset")
		time.go#L1188: 		return errors.New("Time.UnmarshalBinary: no data")
		time.go#L1192: 		return errors.New("Time.UnmarshalBinary: unsupported version")
		time.go#L1196: 		return errors.New("Time.UnmarshalBinary: invalid length")
		time.go#L1244: 		return nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")
		time.go#L1271: 		return nil, errors.New("Time.MarshalText: year outside of range [0,9999]")
		zoneinfo.go#L612: var errLocation = errors.New("time: invalid location name")
		zoneinfo_read.go#L110: var badData = errors.New("malformed time zone information")
		zoneinfo_read.go#L409: 		return nil, errors.New("corrupt zip file " + zipfile)
		zoneinfo_read.go#L417: 		return nil, errors.New("corrupt zip file " + zipfile)
		zoneinfo_read.go#L459: 			return nil, errors.New("unsupported compression for " + name + " in " + zipfile)
		zoneinfo_read.go#L484: 			return nil, errors.New("corrupt zip file " + zipfile)
		zoneinfo_read.go#L490: 			return nil, errors.New("corrupt zip file " + zipfile)
		zoneinfo_read.go#L545: 	return nil, errors.New("unknown time zone " + name)

	vendor/golang.org/x/crypto/chacha20
		chacha_generic.go#L82: 		return nil, errors.New("chacha20: wrong key size")
		chacha_generic.go#L93: 		return nil, errors.New("chacha20: wrong nonce size")
		chacha_generic.go#L354: 		return nil, errors.New("chacha20: wrong HChaCha20 key size")
		chacha_generic.go#L357: 		return nil, errors.New("chacha20: wrong HChaCha20 nonce size")

	vendor/golang.org/x/crypto/chacha20poly1305
		chacha20poly1305.go#L38: 		return nil, errors.New("chacha20poly1305: bad key length")
		chacha20poly1305.go#L65: var errOpen = errors.New("chacha20poly1305: message authentication failed")
		xchacha20poly1305.go#L26: 		return nil, errors.New("chacha20poly1305: bad key length")

	vendor/golang.org/x/crypto/cryptobyte
		builder.go#L234: 			b.err = errors.New("pending ASN.1 child too long")
		builder.go#L292: 		b.err = errors.New("cryptobyte: length overflow")
		builder.go#L295: 		b.err = errors.New("cryptobyte: Builder is exceeding its fixed-size buffer")

	vendor/golang.org/x/crypto/hkdf
		hkdf.go#L51: 		return 0, errors.New("hkdf: entropy limit reached")

	vendor/golang.org/x/net/dns/dnsmessage
		message.go#L252: 	ErrNotStarted = errors.New("parsing/packing of this type isn't available yet")
		message.go#L256: 	ErrSectionDone = errors.New("parsing/packing of this section has completed")
		message.go#L258: 	errBaseLen            = errors.New("insufficient data for base length type")
		message.go#L259: 	errCalcLen            = errors.New("insufficient data for calculated length type")
		message.go#L260: 	errReserved           = errors.New("segment prefix is reserved")
		message.go#L261: 	errTooManyPtr         = errors.New("too many pointers (>10)")
		message.go#L262: 	errInvalidPtr         = errors.New("invalid pointer")
		message.go#L263: 	errNilResouceBody     = errors.New("nil resource body")
		message.go#L264: 	errResourceLen        = errors.New("insufficient data for resource body length")
		message.go#L265: 	errSegTooLong         = errors.New("segment length too long")
		message.go#L266: 	errZeroSegLen         = errors.New("zero length segment")
		message.go#L267: 	errResTooLong         = errors.New("resource length too long")
		message.go#L268: 	errTooManyQuestions   = errors.New("too many Questions to pack (>65535)")
		message.go#L269: 	errTooManyAnswers     = errors.New("too many Answers to pack (>65535)")
		message.go#L270: 	errTooManyAuthorities = errors.New("too many Authorities to pack (>65535)")
		message.go#L271: 	errTooManyAdditionals = errors.New("too many Additionals to pack (>65535)")
		message.go#L272: 	errNonCanonicalName   = errors.New("name is not in canonical format (it must end with a .)")
		message.go#L273: 	errStringTooLong      = errors.New("character string exceeds maximum length (255)")
		message.go#L274: 	errCompressedSRV      = errors.New("compressed name in SRV resource data")
		message.go#L2143: 		return nil, off, errors.New("invalid resource type: " + hdr.Type.String())

	vendor/golang.org/x/net/http/httpproxy
		proxy.go#L134: 			return nil, errors.New("refusing to use HTTP_PROXY value in CGI environment; see golang.org/s/cgihttpproxy")

	vendor/golang.org/x/net/http2/hpack
		hpack.go#L116: var ErrStringLength = errors.New("hpack: string too long")
		hpack.go#L238: 		return DecodingError{errors.New("truncated headers")}
		hpack.go#L287: var errNeedMore = errors.New("need more data")
		hpack.go#L334: 	return DecodingError{errors.New("invalid encoding")}
		hpack.go#L403: 		return DecodingError{errors.New("dynamic table size update MUST occur at the beginning of a header block")}
		hpack.go#L412: 		return DecodingError{errors.New("dynamic table size update too large")}
		hpack.go#L419: var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
		huffman.go#L44: var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")

	vendor/golang.org/x/net/route
		route.go#L22: 	errUnsupportedMessage = errors.New("unsupported message")
		route.go#L23: 	errMessageMismatch    = errors.New("message mismatch")
		route.go#L24: 	errMessageTooShort    = errors.New("message too short")
		route.go#L25: 	errInvalidMessage     = errors.New("invalid message")
		route.go#L26: 	errInvalidAddr        = errors.New("invalid address")
		route.go#L27: 	errShortBuffer        = errors.New("short buffer")

	vendor/golang.org/x/text/secure/bidirule
		bidirule.go#L46: var ErrInvalid = errors.New("bidirule: failed Bidi Rule")

	vendor/golang.org/x/text/transform
		transform.go#L21: 	ErrShortDst = errors.New("transform: short destination buffer")
		transform.go#L25: 	ErrShortSrc = errors.New("transform: short source buffer")
		transform.go#L29: 	ErrEndOfSpan = errors.New("transform: input and output are not identical")
		transform.go#L33: 	errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
		transform.go#L37: 	errShortInternal = errors.New("transform: short internal buffer")

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.