func fmt.Errorf

2268 uses

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

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

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

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

	crypto/x509
		parser.go#L104: 	return "", fmt.Errorf("unsupported string type: %v", tag)
		parser.go#L138: 				return nil, fmt.Errorf("x509: invalid RDNSequence: invalid attribute value: %s", err)
		parser.go#L408: 				return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
		parser.go#L412: 					return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
		parser.go#L537: 				return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
		parser.go#L563: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
		parser.go#L581: 					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
		parser.go#L585: 					return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
		parser.go#L600: 						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
		parser.go#L609: 						return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
		parser.go#L621: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
		parser.go#L633: 					return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
		pkcs8.go#L70: 			return nil, fmt.Errorf("x509: invalid Ed25519 private key: %v", err)
		pkcs8.go#L73: 			return nil, fmt.Errorf("x509: invalid Ed25519 private key length: %d", l)
		pkcs8.go#L78: 		return nil, fmt.Errorf("x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
		pkcs8.go#L127: 			return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
		pkcs8.go#L132: 		return nil, fmt.Errorf("x509: unknown key type while marshaling PKCS#8: %T", key)
		sec1.go#L80: 		return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
		verify.go#L398: 			return false, fmt.Errorf("x509: internal error: cannot parse constraint %q", constraint)
		verify.go#L419: 		return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
		verify.go#L432: 		return false, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
		verify.go#L461: 		return false, fmt.Errorf("x509: internal error: cannot parse domain %q", domain)
		verify.go#L477: 		return false, fmt.Errorf("x509: internal error: cannot parse domain %q", constraint)
		verify.go#L608: 					return fmt.Errorf("x509: cannot parse rfc822Name %q", mailbox)
		verify.go#L621: 					return fmt.Errorf("x509: cannot parse dnsName %q", name)
		verify.go#L635: 					return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", name)
		verify.go#L648: 					return fmt.Errorf("x509: internal error: IP SAN %x failed to parse", data)
		verify.go#L740: 			return nil, fmt.Errorf("crypto/x509: error fetching intermediate: %w", err)
		x509.go#L103: 		return nil, pkix.AlgorithmIdentifier{}, fmt.Errorf("x509: unsupported public key type: %T", pub)
		x509.go#L818: 	return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
		x509.go#L1028: 			return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
		x509.go#L1607: 			return nil, fmt.Errorf("x509: signature over certificate returned by signer is invalid: %w", err)

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

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

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

	encoding/json
		decode.go#L728: 								d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
		decode.go#L747: 				d.saveError(fmt.Errorf("json: unknown field %q", key))
		decode.go#L771: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
		decode.go#L865: 		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L876: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L892: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L906: 			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L919: 			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L925: 				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
		decode.go#L943: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L964: 				return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
		decode.go#L978: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		decode.go#L992: 				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
		encode.go#L628: 			e.error(fmt.Errorf("json: invalid number literal %q", numStr))
		encode.go#L803: 			e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))

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

	flag
		flag.go#L433: 		return fmt.Errorf("no such flag -%v", name)

	github.com/aws/aws-sdk-go-v2/aws
		credential_cache.go#L128: 			return Credentials{}, fmt.Errorf("failed to refresh cached credentials, %w", err)
		credential_cache.go#L140: 			return Credentials{}, fmt.Errorf("failed to get random provider, %w", err)
		credential_cache.go#L151: 			return Credentials{}, fmt.Errorf("failed to adjust credentials expires, %w", err)
		credentials.go#L70: 		fmt.Errorf("the AnonymousCredentials is not a valid credential provider, and cannot be used to sign AWS requests with")
		retryer.go#L35: 		return mode, fmt.Errorf("unknown RetryMode, %v", v)
		retryer.go#L109: 	return 0, fmt.Errorf("not retrying any attempt errors")

	github.com/aws/aws-sdk-go-v2/aws/defaults
		defaults.go#L48: 		return Configuration{}, fmt.Errorf("unsupported defaults mode: %v", mode)

	github.com/aws/aws-sdk-go-v2/aws/middleware
		middleware.go#L31: 		return out, metadata, fmt.Errorf("unknown transport type %T", req)
		user_agent.go#L173: 		return nil, fmt.Errorf("%T for %s middleware did not match expected type", bm, id)
		user_agent.go#L216: 		return out, metadata, fmt.Errorf("unknown transport type %T", in)

	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream
		debug.go#L68: 		return 0, fmt.Errorf("failed to get int64 json number, %v", err)

	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream/eventstreamapi
		middleware.go#L45: 		return out, metadata, fmt.Errorf("unknown transport type: %T", in.Request)

	github.com/aws/aws-sdk-go-v2/aws/protocol/xml
		error_utils.go#L22: 			return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response: %w", err)
		error_utils.go#L33: 		return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response: %w", err)

	github.com/aws/aws-sdk-go-v2/aws/retry
		adaptive.go#L139: 			return nil, fmt.Errorf(
		adaptive.go#L144: 			return nil, fmt.Errorf("failed to wait for token to be available, %w", err)
		middleware.go#L138: 		return out, attemptResult, nopRelease, fmt.Errorf(
		middleware.go#L156: 				return out, attemptResult, nopRelease, fmt.Errorf(
		middleware.go#L174: 		return out, attemptResult, nopRelease, fmt.Errorf(
		middleware.go#L179: 		return out, attemptResult, nopRelease, fmt.Errorf(
		middleware.go#L281: 		return out, metadata, fmt.Errorf("unknown transport type %T", req)
		standard.go#L242: 		return nil, fmt.Errorf("failed to get rate limit token, %w", err)

	github.com/aws/aws-sdk-go-v2/aws/signer/v4
		middleware.go#L81: 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
		middleware.go#L170: 			Err: fmt.Errorf("unexpected request middleware type %T", in.Request),
		middleware.go#L187: 				Err: fmt.Errorf("failed to compute payload hash, %w", err),
		middleware.go#L193: 				Err: fmt.Errorf("failed to seek body to start, %w", err),
		middleware.go#L244: 		return out, metadata, &HashComputationError{Err: fmt.Errorf("unexpected request middleware type %T", in.Request)}
		middleware.go#L290: 		return out, metadata, &SigningError{Err: fmt.Errorf("unexpected request middleware type %T", in.Request)}
		middleware.go#L296: 		return out, metadata, &SigningError{Err: fmt.Errorf("computed payload hash missing from context")}
		middleware.go#L301: 		return out, metadata, &SigningError{Err: fmt.Errorf("failed to retrieve credentials: %w", err)}
		middleware.go#L310: 		return out, metadata, &SigningError{Err: fmt.Errorf("failed to sign http request, %w", err)}
		middleware.go#L356: 					return nil, fmt.Errorf("invalid request signature authorization header")
		middleware.go#L367: 	return nil, fmt.Errorf("request not signed")
		presign_middleware.go#L77: 			Err: fmt.Errorf("unexpected request middleware type %T", in.Request),
		presign_middleware.go#L97: 			Err: fmt.Errorf("computed payload hash missing from context"),
		presign_middleware.go#L104: 			Err: fmt.Errorf("failed to retrieve credentials: %w", err),
		presign_middleware.go#L116: 			Err: fmt.Errorf("failed to sign http request, %w", err),

	github.com/aws/aws-sdk-go-v2/aws/transport/http
		content_type.go#L27: 		return out, metadata, fmt.Errorf("unknown transport type %T", in)
		timeout_read_closer.go#L94: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}

	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2
		endpoints.go#L93: 		return aws.Endpoint{}, fmt.Errorf("no partitions found")
		endpoints.go#L225: 		return aws.Endpoint{}, fmt.Errorf("unable to resolve endpoint for region: %v", region)

	github.com/aws/aws-sdk-go-v2/internal/rand
		rand.go#L23: 		return 0, fmt.Errorf("failed to read random value, %v", err)

	github.com/aws/aws-sdk-go-v2/internal/v4a
		credentials.go#L92: 		return Credentials{}, fmt.Errorf("failed to retrieve symmetric credentials: %v", err)
		credentials.go#L97: 		return Credentials{}, fmt.Errorf("failed to derive assymetric key from credentials")
		middleware.go#L60: 		return out, metadata, fmt.Errorf("unexpected request middleware type %T", in.Request)
		middleware.go#L66: 		return out, metadata, &SigningError{Err: fmt.Errorf("computed payload hash missing from context")}
		middleware.go#L71: 		return out, metadata, &SigningError{Err: fmt.Errorf("failed to retrieve credentials: %w", err)}
		middleware.go#L79: 		return out, metadata, &SigningError{Err: fmt.Errorf("failed to sign http request, %w", err)}
		presign_middleware.go#L67: 			Err: fmt.Errorf("unexpected request middleware type %T", in.Request),
		presign_middleware.go#L87: 			Err: fmt.Errorf("computed payload hash missing from context"),
		presign_middleware.go#L94: 			Err: fmt.Errorf("failed to retrieve credentials: %w", err),
		presign_middleware.go#L106: 			Err: fmt.Errorf("failed to sign http request, %w", err),
		v4a.go#L141: 			return nil, fmt.Errorf("exhausted single byte external counter")

	github.com/aws/aws-sdk-go-v2/internal/v4a/internal/crypto
		compare.go#L14: 		return 0, fmt.Errorf("slice lengths do not match")
		ecc.go#L50: 		return nil, fmt.Errorf("point(%v, %v) is not on the given curve", xPoint.String(), yPoint.String())
		ecc.go#L80: 		return nil, fmt.Errorf("unable to derive key of size %d using 32-bit counter", bitLen)
		ecc.go#L85: 		return nil, fmt.Errorf("bitLen is greater than 32-bits")
		ecc.go#L93: 		return nil, fmt.Errorf("failed to write bit length to fixed input string: %v", err)

	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding
		accept_encoding_gzip.go#L59: 			Err: fmt.Errorf("unknown request type %T", input.Request),
		accept_encoding_gzip.go#L89: 			Err: fmt.Errorf("unknown request type %T", input.Request),
		accept_encoding_gzip.go#L123: 			Err: fmt.Errorf("unknown response type %T", output.RawResponse),
		accept_encoding_gzip.go#L158: 			return 0, fmt.Errorf("failed to decompress gzip response, %w", err)
		accept_encoding_gzip.go#L172: 		return fmt.Errorf("failed to decompress gzip response, %w", err)

	github.com/aws/aws-sdk-go-v2/service/internal/checksum
		algorithms.go#L53: 	return "", fmt.Errorf("unknown checksum algorithm, %v", v)
		algorithms.go#L93: 		return nil, fmt.Errorf("unknown checksum algorithm, %v", v)
		algorithms.go#L110: 		return 0, fmt.Errorf("unknown checksum algorithm, %v", v)
		algorithms.go#L148: 		return nil, fmt.Errorf("failed compute MD5 hash of reader, %w", err)
		algorithms.go#L239: 		return "", fmt.Errorf(
		aws_chunked_encoding.go#L253: 				return 0, fmt.Errorf("failed to get trailer value, %w", err)
		middleware_compute_input_checksum.go#L364: 			return out, metadata, fmt.Errorf("failed to get computed checksum, %w", err)
		middleware_compute_input_checksum.go#L384: 		return "", false, fmt.Errorf(
		middleware_compute_input_checksum.go#L396: 		return "", "", fmt.Errorf(
		middleware_compute_input_checksum.go#L414: 			return "", "", fmt.Errorf(
		middleware_compute_input_checksum.go#L437: 		return 0, fmt.Errorf("failed getting request stream's length, %w", err)
		middleware_compute_input_checksum.go#L465: 		return "", fmt.Errorf(
		middleware_compute_input_checksum.go#L474: 		return "", fmt.Errorf("failed to rewind stream after computing MD5 checksum, %w", err)
		middleware_validate_output.go#L77: 			Err: fmt.Errorf("unknown transport type %T", out.RawResponse),
		middleware_validate_output.go#L120: 		return out, metadata, fmt.Errorf("failed to create checksum validation reader, %w", err)

	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url
		middleware.go#L72: 		return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
		middleware.go#L80: 		return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
		middleware.go#L90: 		return out, metadata, fmt.Errorf("unable to create presigned URL, %w", err)
		middleware.go#L96: 		return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
		middleware.go#L101: 		return out, metadata, fmt.Errorf("unable to create presigned URL, %w", err)
		middleware.go#L106: 		return out, metadata, fmt.Errorf("presign middleware failed, %w", err)

	github.com/aws/aws-sdk-go-v2/service/internal/s3shared
		arn_lookup.go#L45: 		return out, metadata, fmt.Errorf("error parsing arn: %w", err)
		resource_request.go#L59: 		return false, fmt.Errorf("no partition id for provided ARN")
		update_endpoint.go#L57: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		update_endpoint.go#L63: 			return out, metadata, fmt.Errorf("unable to update endpoint host for dualstack, hostname invalid, %s", req.URL.Host)
		xml_utils.go#L24: 		return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response : %w", err)
		xml_utils.go#L40: 		return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response : %w", err)

	github.com/aws/aws-sdk-go-v2/service/s3
		api_client.go#L749: 		return fmt.Errorf("presign URL duration must be 0 or greater, %v", c.Expires)
		api_op_GetBucketLocation.go#L176: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		api_op_GetBucketLocation.go#L198: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		api_op_HeadBucket.go#L243: 		return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
		api_op_HeadBucket.go#L256: 		return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
		api_op_HeadBucket.go#L300: 			return nil, fmt.Errorf("error computing waiter delay, %w", err)
		api_op_HeadBucket.go#L306: 			return nil, fmt.Errorf("request cancelled while waiting, %w", err)
		api_op_HeadBucket.go#L309: 	return nil, fmt.Errorf("exceeded max wait time for BucketExists waiter")
		api_op_HeadBucket.go#L397: 		return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
		api_op_HeadBucket.go#L410: 		return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
		api_op_HeadBucket.go#L454: 			return nil, fmt.Errorf("error computing waiter delay, %w", err)
		api_op_HeadBucket.go#L460: 			return nil, fmt.Errorf("request cancelled while waiting, %w", err)
		api_op_HeadBucket.go#L463: 	return nil, fmt.Errorf("exceeded max wait time for BucketNotExists waiter")
		api_op_HeadObject.go#L576: 		return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
		api_op_HeadObject.go#L589: 		return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
		api_op_HeadObject.go#L633: 			return nil, fmt.Errorf("error computing waiter delay, %w", err)
		api_op_HeadObject.go#L639: 			return nil, fmt.Errorf("request cancelled while waiting, %w", err)
		api_op_HeadObject.go#L642: 	return nil, fmt.Errorf("exceeded max wait time for ObjectExists waiter")
		api_op_HeadObject.go#L655: 			return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
		api_op_HeadObject.go#L735: 		return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
		api_op_HeadObject.go#L748: 		return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
		api_op_HeadObject.go#L792: 			return nil, fmt.Errorf("error computing waiter delay, %w", err)
		api_op_HeadObject.go#L798: 			return nil, fmt.Errorf("request cancelled while waiting, %w", err)
		api_op_HeadObject.go#L801: 	return nil, fmt.Errorf("exceeded max wait time for ObjectNotExists waiter")
		api_op_HeadObject.go#L810: 			return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
		api_op_ListObjectsV2.go#L345: 		return nil, fmt.Errorf("no more pages available")
		api_op_ListParts.go#L362: 		return nil, fmt.Errorf("no more pages available")
		api_op_WriteGetObjectResponse.go#L409: 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
		api_op_WriteGetObjectResponse.go#L414: 		return out, metadata, fmt.Errorf("unknown input type %T", in.Parameters)
		api_op_WriteGetObjectResponse.go#L419: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("RequestRoute forms part of the endpoint host and so may not be nil")}
		api_op_WriteGetObjectResponse.go#L421: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("RequestRoute forms part of the endpoint host and so must match \"[a-zA-Z0-9-]{1,63}\", but was \"%s\"", *input.RequestRoute)}
		deserializers.go#L47: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L58: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L67: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L109: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L137: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L148: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L163: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L174: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L185: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L224: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L265: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L420: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L431: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L446: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L457: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L468: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L510: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L571: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L628: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L639: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L648: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L693: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L721: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L732: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L747: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L758: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L769: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L808: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L873: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L963: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L974: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L984: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1038: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1049: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1059: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1113: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1124: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1134: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1188: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1199: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1209: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1263: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1274: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1284: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1338: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1349: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1359: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1413: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1424: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1434: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1488: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1499: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1509: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1563: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1574: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1584: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1638: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1649: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1659: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1713: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1724: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1734: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1788: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1799: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1809: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1863: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1874: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L1884: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1938: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L1949: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L1958: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L1997: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L2039: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2050: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L2065: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2076: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2087: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2126: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L2138: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L2201: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2212: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L2221: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2260: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L2288: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2299: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L2309: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2363: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2384: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2395: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2406: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2445: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L2509: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2530: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2541: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2552: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2591: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L2654: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2675: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2686: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2697: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2736: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L2793: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2814: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2825: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2836: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L2875: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L2932: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L2953: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2964: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L2975: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3014: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3071: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3092: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3103: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3114: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3153: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3210: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3231: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3242: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3253: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3292: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3349: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3370: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3381: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3392: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3431: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3488: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3509: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3520: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3531: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3570: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3634: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3655: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3666: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3677: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3716: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3773: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3794: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3805: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3816: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3855: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L3912: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L3933: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3944: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L3955: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L3994: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4069: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4090: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4101: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4112: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4151: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4208: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4219: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
		deserializers.go#L4228: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4267: 		return fmt.Errorf("unsupported deserialization of nil %T", v)
		deserializers.go#L4303: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4324: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4335: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4346: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4385: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4442: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4463: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4474: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4485: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4524: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4581: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4602: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4613: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4624: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4663: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4727: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4748: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4759: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4770: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4809: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L4866: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L4887: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4898: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L4909: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L4948: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L5025: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L5046: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5057: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5068: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L5107: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L5182: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L5193: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L5198: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
		deserializers.go#L5207: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L5252: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L5475: 		return fmt.Errorf("unsupported deserialization of nil %T", v)
		deserializers.go#L5498: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L5509: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L5524: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5535: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5546: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L5588: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L5600: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L5663: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L5674: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L5689: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5700: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5711: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L5753: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L5788: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L5894: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L5915: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5926: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L5937: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L5976: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L6033: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6054: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6065: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6076: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6115: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L6172: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6193: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6204: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6215: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6254: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L6311: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6322: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L6337: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6348: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6359: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6398: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L6410: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L6467: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6478: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L6483: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
		deserializers.go#L6492: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6531: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L6543: 		return fmt.Errorf("unsupported deserialization of nil %T", v)
		deserializers.go#L6566: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6587: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6598: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L6609: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6648: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L6705: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6716: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L6726: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6783: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L6794: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L6803: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L6842: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L7072: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7093: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7104: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7115: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L7154: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L7204: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L7253: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7274: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7285: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7296: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L7335: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L7385: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L7434: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7455: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7466: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7477: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L7516: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L7566: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L7615: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7636: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7647: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7658: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L7697: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L7741: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L7796: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7817: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7828: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7839: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L7878: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L7941: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L7962: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7973: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L7984: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L8023: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L8099: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L8223: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L8244: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8255: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8266: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L8308: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L8377: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L8482: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L8503: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8514: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8525: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L8567: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L8649: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L8771: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L8792: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8803: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L8814: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L8853: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L8922: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L9059: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9070: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L9085: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L9096: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L9107: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9146: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L9172: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L9235: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L9365: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9376: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9386: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9440: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9451: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9461: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9515: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9526: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9536: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9590: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9601: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9611: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9665: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9676: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9686: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9740: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9751: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9761: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9815: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9826: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9836: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9890: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9901: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9911: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L9965: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L9976: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L9986: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10040: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10051: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10061: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10115: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10126: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10136: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10190: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10201: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10211: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10265: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10276: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10286: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10340: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10351: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10361: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10415: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10426: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10436: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10490: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10501: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10511: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10565: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10576: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10586: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10640: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10651: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L10661: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10715: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10726: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L10735: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10774: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L10871: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10882: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L10891: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L10933: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L10961: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L10972: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L10981: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11020: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11048: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11059: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11068: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11107: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11135: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11146: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11155: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11194: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11222: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11233: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11242: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11281: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11309: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11320: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L11330: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11384: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11395: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11404: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11446: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11479: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11494: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11548: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11559: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11568: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11607: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11689: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11700: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
		deserializers.go#L11715: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L11726: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L11737: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11776: 		return fmt.Errorf("unsupported deserialization for nil %T", v)
		deserializers.go#L11822: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L11879: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		deserializers.go#L11890: 			Err: fmt.Errorf("failed to discard response body, %w", err),
		deserializers.go#L11900: 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
		deserializers.go#L11939: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L11944: 		return fmt.Errorf("%s event header not present", eventstreamapi.EventTypeHeader)
		deserializers.go#L12003: 		return fmt.Errorf("%s event header not present", eventstreamapi.ExceptionTypeHeader)
		deserializers.go#L12039: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L12053: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L12069: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12080: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12090: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L12106: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12117: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12127: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L12143: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12154: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12164: 		return fmt.Errorf("unexpected serialization of nil %T", v)
		deserializers.go#L12180: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12191: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12201: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12237: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12273: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12360: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12469: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12480: 			Err:      fmt.Errorf("failed to decode response body, %w", err),
		deserializers.go#L12520: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12573: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12622: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12702: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12782: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12862: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12917: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L12978: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13046: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13088: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13159: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13247: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13313: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13349: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13385: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13453: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13541: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13621: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13670: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13738: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13800: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L13918: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14036: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14126: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14194: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14277: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14308: 					return fmt.Errorf("expected DeleteMarker to be of type *bool, got %T instead", val)
		deserializers.go#L14368: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14436: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14467: 					return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val)
		deserializers.go#L14537: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14586: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14654: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14753: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14802: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14890: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L14939: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15007: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15043: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15123: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15172: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15252: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15314: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15382: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15413: 					return fmt.Errorf("expected IsTruncated to be of type *bool, got %T instead", val)
		deserializers.go#L15500: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15555: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15658: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15726: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15775: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15837: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15892: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L15966: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16034: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16095: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16157: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16226: 					return fmt.Errorf("expected IsEnabled to be of type *bool, got %T instead", val)
		deserializers.go#L16259: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16327: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16369: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16417: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16466: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16546: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16640: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16689: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16763: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16831: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L16896: 					return fmt.Errorf("expected ExpiredObjectDeleteMarker to be of type *bool, got %T instead", val)
		deserializers.go#L16917: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17028: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17117: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17228: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17296: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17364: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17419: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17487: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17542: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17610: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17697: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17814: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17882: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L17952: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18035: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18103: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18139: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18175: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18211: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18247: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18289: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18410: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18446: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18514: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18569: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18618: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18684: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18726: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18762: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18884: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L18934: 					return fmt.Errorf("expected IsLatest to be of type *bool, got %T instead", val)
		deserializers.go#L19034: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19102: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19164: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19206: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19255: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19323: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19475: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19543: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19611: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19642: 					return fmt.Errorf("expected IsPublic to be of type *bool, got %T instead", val)
		deserializers.go#L19663: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19694: 					return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val)
		deserializers.go#L19710: 					return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val)
		deserializers.go#L19726: 					return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val)
		deserializers.go#L19742: 					return fmt.Errorf("expected Setting to be of type *bool, got %T instead", val)
		deserializers.go#L19763: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19837: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L19905: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20006: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20068: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20117: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20172: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20294: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20349: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20420: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20488: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20543: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20596: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20644: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20712: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20754: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20816: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20858: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20895: 					return fmt.Errorf("expected BucketKeyEnabled to be of type *bool, got %T instead", val)
		deserializers.go#L20916: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L20984: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21032: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21081: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21130: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21166: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21208: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21263: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21325: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21393: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21448: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21516: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21582: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21650: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21724: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21792: 		return fmt.Errorf("unexpected nil of type %T", v)
		deserializers.go#L21875: 		return fmt.Errorf("unexpected nil of type %T", v)
		endpoints.go#L84: 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
		endpoints.go#L88: 		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
		endpoints.go#L97: 		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
		endpoints.go#L102: 		return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
		endpoints.go#L150: 		return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
		eventstream.go#L98: 		return nil, fmt.Errorf("%s event header not present", eventstreamapi.MessageTypeHeader)
		eventstream.go#L182: 		return out, metadata, fmt.Errorf("unknown transport type: %T", in.Request)
		eventstream.go#L193: 		return out, metadata, fmt.Errorf("unknown transport type: %T", out.RawResponse)
		eventstream.go#L199: 		return out, metadata, fmt.Errorf("unexpected output result type: %T", out.Result)
		serializers.go#L33: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L39: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L64: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L68: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L82: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L114: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L120: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L169: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L173: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L207: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L254: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L260: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L285: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L294: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L413: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L520: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L526: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L575: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L584: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L642: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L648: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L673: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L682: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L756: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L853: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L859: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L884: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L888: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L916: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L922: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L947: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L951: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L983: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L989: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1014: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1018: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1046: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1052: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1077: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1081: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1109: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1115: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1140: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1144: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1171: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1177: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1202: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1206: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1238: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1244: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1269: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1273: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1301: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1307: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1332: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1336: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1368: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1374: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1399: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1403: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1431: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1437: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1462: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1466: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1494: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1500: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1525: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1529: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1557: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1563: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1588: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1592: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1620: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1626: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1651: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1655: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1683: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1689: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1714: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1718: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1737: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L1774: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1780: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1829: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1833: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1881: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1887: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1912: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1916: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L1930: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L1957: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L1963: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L1988: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L1992: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2020: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2026: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2051: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2055: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2083: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2089: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2114: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2118: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2146: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2152: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2177: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2181: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2213: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2219: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2244: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2248: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2276: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2282: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2307: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2311: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2339: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2345: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2370: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2374: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2401: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2407: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2432: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2436: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2468: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2474: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2499: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2503: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2531: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2537: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2562: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2566: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2594: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2600: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2625: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2629: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2657: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2663: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2688: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2692: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2724: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2730: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2755: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2759: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2787: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2793: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2818: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2822: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2850: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2856: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2881: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2885: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2913: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2919: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L2944: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L2948: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L2976: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L2982: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3007: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3011: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3039: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3045: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3070: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3074: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3102: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3108: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3133: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3137: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3165: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3171: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3196: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3200: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3228: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3234: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3259: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3263: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3291: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3297: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3322: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3326: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3365: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3445: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3451: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3476: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3480: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3494: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3526: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3532: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3557: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3561: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3575: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3646: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3652: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3677: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3681: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3695: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3727: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3733: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3758: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3762: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3790: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3796: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3821: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3825: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3839: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3871: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3877: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3902: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3906: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L3920: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L3952: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L3958: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L3983: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L3987: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4001: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L4029: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4035: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4060: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4064: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4092: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4098: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4123: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4127: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4155: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4161: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4186: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4190: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4229: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L4285: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4291: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4316: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4320: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4352: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4358: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4383: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4387: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4414: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4420: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4445: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4449: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4481: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4487: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4512: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4516: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4548: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4554: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4575: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4593: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4599: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4624: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4628: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4680: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4686: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4711: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4715: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4768: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4774: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4799: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4803: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4864: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4870: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4895: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4899: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L4951: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L4957: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L4982: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L4986: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5000: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L5055: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5061: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5110: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5114: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5147: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5153: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5202: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5211: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5274: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5280: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5329: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5333: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5365: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5371: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5420: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5424: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5462: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5468: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5517: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5521: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5559: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5565: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5614: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5618: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5645: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5651: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5700: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5704: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5736: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5742: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5791: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5795: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5828: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5834: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5883: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5887: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L5925: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L5931: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L5980: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L5984: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6016: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6022: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6071: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6075: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6108: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6114: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6163: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6167: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6200: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6206: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6243: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6247: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6290: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6296: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6345: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6349: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6392: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6398: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6447: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6451: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6489: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6495: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6544: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6548: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6586: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6592: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6641: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6645: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6688: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6694: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6743: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6747: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6785: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L6791: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L6828: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L6837: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L6941: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7038: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7044: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7093: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7102: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7151: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7183: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7189: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7238: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7242: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7266: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7298: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7304: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7353: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7357: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7405: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7411: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7460: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7464: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7493: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7525: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7531: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7580: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7584: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7608: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7640: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7646: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7695: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7699: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7737: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7743: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7792: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7796: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7815: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L7847: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L7853: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L7896: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L7900: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L7914: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L8031: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L8037: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L8074: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L8078: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L8127: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L8178: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L8184: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L8209: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L8213: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Bucket must not be empty")}
		serializers.go#L8277: 		return &smithy.SerializationError{Err: fmt.Errorf("input member Key must not be empty")}
		serializers.go#L8328: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
		serializers.go#L8334: 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
		serializers.go#L8371: 		return fmt.Errorf("unsupported serialization of nil %T", v)
		serializers.go#L8824: 		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
		serializers.go#L10586: 		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
		serializers.go#L10824: 		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
		serializers.go#L11680: 		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
		validators.go#L25: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L45: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L65: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L85: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L105: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L125: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L145: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L165: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L185: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L205: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L225: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L245: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L265: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L285: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L305: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L325: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L345: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L365: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L385: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L405: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L425: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L445: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L465: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L485: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L505: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L525: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L545: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L565: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L585: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L605: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L625: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L645: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L665: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L685: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L705: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L725: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L745: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L765: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L785: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L805: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L825: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L845: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L865: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L885: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L905: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L925: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L945: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L965: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L985: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1005: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1025: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1045: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1065: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1085: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1105: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1125: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1145: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1165: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1185: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1205: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1225: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1245: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1265: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1285: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1305: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1325: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1345: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1365: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1385: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1405: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1425: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1445: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1465: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1485: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1505: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1525: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1545: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1565: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1585: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1605: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1625: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1645: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1665: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1685: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1705: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1725: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1745: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1765: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1785: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1805: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1825: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
		validators.go#L1845: 		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)

	github.com/aws/aws-sdk-go-v2/service/s3/internal/customizations
		handle_200_error.go#L44: 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
		handle_200_error.go#L59: 			Err: fmt.Errorf("received empty response payload"),
		presigned_expires.go#L40: 		return out, metadata, fmt.Errorf("unknown transport type %T", req)
		process_arn_resource.go#L61: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		process_arn_resource.go#L95: 				return out, metadata, fmt.Errorf("Invalid configuration, Multi-Region access point ARNs are disabled")
		process_arn_resource.go#L277: 		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
		process_arn_resource.go#L342: 		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
		process_arn_resource.go#L428: 		return ctx, fmt.Errorf("Error determining dns suffix from arn partition, %w", err)
		process_arn_resource.go#L436: 		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
		process_arn_resource.go#L450: 		return ctx, fmt.Errorf("endpoint validation error: %w, when using arn %v", err, tv)
		process_arn_resource.go#L518: 		return ctx, fmt.Errorf("failed to parse endpoint URL: %w", err)
		remove_bucket_middleware.go#L32: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		s3_object_lambda.go#L39: 		return out, metadata, fmt.Errorf("unknown transport type: %T", in.Request)
		s3_object_lambda.go#L43: 		return out, metadata, fmt.Errorf("client configured for dualstack but not supported for operation")
		s3_object_lambda.go#L47: 		return out, metadata, fmt.Errorf("client configured for accelerate but not supported for operation")
		signer_wrapper.go#L90: 			return out, metadata, fmt.Errorf("invalid credential-provider provided for sigV4a Signer")
		signer_wrapper.go#L181: 			return out, metadata, fmt.Errorf("invalid credential-provider provided for sigV4a Signer")
		update_endpoint.go#L156: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		update_endpoint.go#L198: 			err = fmt.Errorf("bucket name %s is not compatible with S3", bucket)
		update_endpoint.go#L209: 			return fmt.Errorf("unable to update endpoint host for S3 accelerate, hostname invalid, %s", req.URL.Host)

	github.com/aws/aws-sdk-go-v2/service/s3/internal/endpoints
		endpoints.go#L775: 			return "", fmt.Errorf("unsupported endpoint variant %v, in partition %s", variant, id)
		endpoints.go#L794: 			return "", fmt.Errorf("unsupported endpoint variant %v, in partition %s", variant, id)
		endpoints.go#L807: 			return "", fmt.Errorf("unsupported endpoint variant %v, in partition %s", variant, id)
		endpoints.go#L820: 			return "", fmt.Errorf("unsupported endpoint variant %v, in partition %s", variant, id)
		endpoints.go#L839: 			return "", fmt.Errorf("unsupported endpoint variant %v, in partition %s", variant, id)
		endpoints.go#L844: 		return "", fmt.Errorf("unknown partition")

	github.com/aws/smithy-go/auth/bearer
		middleware.go#L61: 		return out, metadata, fmt.Errorf("failed AuthenticationMiddleware wrap message, %w", err)
		middleware.go#L66: 		return out, metadata, fmt.Errorf("failed AuthenticationMiddleware sign message, %w", err)
		middleware.go#L93: 		return nil, fmt.Errorf("expect smithy-go HTTP Request, got %T", message)
		middleware.go#L97: 		return nil, fmt.Errorf("bearer token with HTTP request requires HTTPS")
		token_cache.go#L180: 		return Token{}, fmt.Errorf("retrieve bearer token canceled, %w", ctx.Err())
		token_cache.go#L187: 		return Token{}, fmt.Errorf("failed to retrieve bearer token, %w", err)

	github.com/aws/smithy-go/document
		document.go#L141: 		return nil, fmt.Errorf("failed to convert to big.Float")
		document.go#L150: 		return nil, fmt.Errorf("failed to convert to big.Float")

	github.com/aws/smithy-go/encoding/httpbinding
		encode.go#L35: 		return nil, fmt.Errorf("failed to parse query string: %w", err)
		path_replace.go#L33: 		return path, fieldBuf, fmt.Errorf("invalid path index, start=%d,end=%d. %s", start, end, path)
		path_replace.go#L48: 		return path, fieldBuf, fmt.Errorf("invalid path element, does not contain token stop, %s", path)

	github.com/aws/smithy-go/encoding/xml
		error_utils.go#L21: 			return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response: %w", err)
		error_utils.go#L31: 		return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response: %w", err)
		value.go#L44: 		return fmt.Errorf("xml start element cannot be nil")
		value.go#L88: 		return fmt.Errorf("xml end element cannot be nil")
		xml_decoder.go#L89: 			return t, fmt.Errorf("%s node not found", name)
		xml_decoder.go#L121: 		return c, fmt.Errorf("expected value for %v element, got %T type %v instead", d.StartEl.Name.Local, t, t)
		xml_decoder.go#L123: 		return c, fmt.Errorf("expected value for %v element, got %T type %v instead", d.StartEl.Name.Local, t, t)
		xml_decoder.go#L137: 	return c, fmt.Errorf("expected end element %v, got %T type %v instead", endElement, t, t)

	github.com/aws/smithy-go/middleware
		ordered_group.go#L40: 		return fmt.Errorf("empty ID, ID must not be empty")
		ordered_group.go#L55: 		return fmt.Errorf("insert ID must not be empty")
		ordered_group.go#L58: 		return fmt.Errorf("relative to ID must not be empty")
		ordered_group.go#L79: 		return nil, fmt.Errorf("swap from ID must not be empty")
		ordered_group.go#L84: 		return nil, fmt.Errorf("swap to ID must not be empty")
		ordered_group.go#L103: 		return nil, fmt.Errorf("remove ID must not be empty")
		ordered_group.go#L158: 			return fmt.Errorf("already exists, %v", id)
		ordered_group.go#L170: 		return fmt.Errorf("invalid position, %v", int(pos))
		ordered_group.go#L185: 			return fmt.Errorf("already exists, %v", id)
		ordered_group.go#L191: 		return fmt.Errorf("not found, %v", relativeTo)
		ordered_group.go#L203: 		return fmt.Errorf("not found, %v", id)
		ordered_group.go#L207: 		return fmt.Errorf("already exists, %v", to)
		ordered_group.go#L217: 		return fmt.Errorf("not found, %v", id)
		ordered_group.go#L255: 		return fmt.Errorf("invalid position, %v", int(pos))

	github.com/aws/smithy-go/rand
		rand.go#L21: 		return 0, fmt.Errorf("failed to read random value, %w", err)

	github.com/aws/smithy-go/time
		time.go#L100: 	return time.Time{}, fmt.Errorf("unable to parse time string, %w", errs)

	github.com/aws/smithy-go/transport/http
		checksum_middleware.go#L36: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		checksum_middleware.go#L49: 			return out, metadata, fmt.Errorf(
		checksum_middleware.go#L55: 			return out, metadata, fmt.Errorf("error computing md5 checksum, %w", err)
		checksum_middleware.go#L60: 			return out, metadata, fmt.Errorf(
		client.go#L47: 		return nil, metadata, fmt.Errorf("expect Smithy http.Request value as input, got unsupported type %T", input)
		headerlist.go#L68: 				return nil, fmt.Errorf("value %v missing closing double quote",
		headerlist.go#L77: 					return nil, fmt.Errorf("value %v has non-space trailing characters",
		headerlist.go#L88: 				return nil, fmt.Errorf("failed to unquote value %v, %w", value, err)
		headerlist.go#L135: 		return nil, fmt.Errorf("invalid timestamp HTTPDate header comma separations, %q", v)
		host.go#L54: 		return fmt.Errorf("invalid endpoint host%s", errors.String())
		md5_checksum.go#L17: 		return nil, fmt.Errorf("failed to read body: %w", err)
		middleware_content_length.go#L33: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		middleware_content_length.go#L43: 		return out, metadata, fmt.Errorf(
		middleware_content_length.go#L74: 		return out, metadata, fmt.Errorf("unknown request type %T", req)
		middleware_content_length.go#L79: 		return out, metadata, fmt.Errorf(
		middleware_headers.go#L40: 		return fmt.Errorf("failed to add %s serialize middleware, %w",
		middleware_headers.go#L53: 		return fmt.Errorf("failed to remove %s serialize middleware, %w",
		middleware_headers.go#L76: 		return out, meta, fmt.Errorf(
		middleware_headers.go#L110: 		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
		middleware_headers.go#L137: 		return nil, fmt.Errorf("%T for %s middleware did not match expected type", m, id)
		middleware_http_logging.go#L38: 			return out, metadata, fmt.Errorf("unknown transport type %T", in)
		middleware_http_logging.go#L63: 			return out, metadata, fmt.Errorf("unknown transport type %T", out.RawResponse)
		middleware_http_logging.go#L68: 			return out, metadata, fmt.Errorf("failed to dump response %w", err)
		middleware_min_proto.go#L59: 		return out, metadata, fmt.Errorf("unknown transport type: %T", out.RawResponse)
		request.go#L102: 		return fmt.Errorf("request stream is not seekable")

	github.com/aws/smithy-go/waiter
		waiter.go#L30: 		return 0, fmt.Errorf("minDelay must be greater than zero when computing Delay")
		waiter.go#L35: 		return 0, fmt.Errorf("maxDelay must be greater than zero when computing Delay")
		waiter.go#L54: 			return 0, fmt.Errorf("error computing retry jitter, %w", err)

	github.com/go-pg/migrations/v8
		collection.go#L96: 		return fmt.Errorf("Register expects at most 2 args, got %d", len(fns))
		collection.go#L210: 			err := fmt.Errorf(
		collection.go#L226: 				return fmt.Errorf("migration=%d already has Up func", version)
		collection.go#L235: 				return fmt.Errorf("migration=%d already has Down func", version)
		collection.go#L242: 		return fmt.Errorf(
		collection.go#L292: 				return fmt.Errorf("unknown gopg directive: %q", b)
		collection.go#L426: 		err = fmt.Errorf("table %q does not exist; did you run init?", c.tableName)
		collection.go#L512: 			err = fmt.Errorf("set_version requires version as 2nd arg, e.g. set_version 42")
		collection.go#L525: 		err = fmt.Errorf("unsupported command: %q", cmd)
		collection.go#L541: 			return fmt.Errorf(
		collection.go#L718: 		return 0, fmt.Errorf("file=%q must have extension .go", base)
		collection.go#L723: 		err := fmt.Errorf(
		collection.go#L754: 		return fmt.Errorf("file=%q already exists (%s)", filename, err)

	github.com/go-pg/pg/v10
		hook.go#L64: 		return nil, fmt.Errorf("pg: can't append %T", query)
		listener.go#L265: 		err := fmt.Errorf("pg: Listener.Channel is called with different buffer size")
		messages.go#L136: 				return fmt.Errorf("pg: unknown startup message response: %q", typ)
		messages.go#L187: 		return fmt.Errorf("pg: unknown authentication message response: %q", num)
		messages.go#L282: 			return fmt.Errorf("pg: unexpected authentication code: %q", c0)
		messages.go#L292: 		return fmt.Errorf("pg: unknown password message response: %q", c)
		messages.go#L316: 			return fmt.Errorf("got %q, wanted %q", s, sasl.ScramSha256.Name)
		messages.go#L357: 			return fmt.Errorf("pg: SASL: got %q, wanted %q", typ, 11)
		messages.go#L391: 		return fmt.Errorf(
		messages.go#L409: 			return fmt.Errorf("pg: SASL: got %q, wanted %q", c, 12)
		messages.go#L423: 			return fmt.Errorf("pg: SASL: state=%q, wanted %q",
		messages.go#L433: 		return fmt.Errorf(
		messages.go#L525: 		return nil, fmt.Errorf("pg: can't append %T", query)
		messages.go#L604: 			return nil, fmt.Errorf("pg: readParseDescribeSync: unexpected message %q", c)
		messages.go#L671: 			return fmt.Errorf("pg: readCloseCompleteMsg: unexpected message %q", c)
		messages.go#L734: 			return nil, fmt.Errorf("pg: readSimpleQuery: unexpected message %q", c)
		messages.go#L798: 			return nil, fmt.Errorf("pg: readExtQuery: unexpected message %q", c)
		messages.go#L982: 			return nil, fmt.Errorf("pg: readSimpleQueryData: unexpected message %q", c)
		messages.go#L1062: 			return nil, fmt.Errorf("pg: readExtQueryData: unexpected message %q", c)
		messages.go#L1102: 			return fmt.Errorf("pg: readCopyInResponse: unexpected message %q", c)
		messages.go#L1142: 			return fmt.Errorf("pg: readCopyOutResponse: unexpected message %q", c)
		messages.go#L1208: 			return nil, fmt.Errorf("pg: readCopyData: unexpected message %q", c)
		messages.go#L1269: 			return nil, fmt.Errorf("pg: readReadyForQueryOrError: unexpected message %q", c)
		messages.go#L1317: 			return "", "", fmt.Errorf("pg: readNotification: unexpected message %q", c)
		options.go#L228: 			return nil, fmt.Errorf("pg: sslmode '%v' is not supported", sslMode[0])
		options.go#L245: 			return nil, fmt.Errorf("pg: cannot parse connect_timeout option as int")

	github.com/go-pg/pg/v10/internal/parser
		streaming_parser.go#L28: 	return fmt.Errorf("got %q, wanted %q", c, skip)

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

	github.com/go-pg/pg/v10/orm
		composite.go#L48: 					firstErr = fmt.Errorf(
		composite_parser.go#L132: 				return nil, fmt.Errorf("pg: got %q, wanted ',' or ')'", c)
		field.go#L104: 		panic(fmt.Errorf("pg: AppendValue(unsupported %s)", fv.Type()))
		field.go#L111: 		return fmt.Errorf("pg: ScanValue(unsupported %s)", f.Type)
		format.go#L202: 		panic(fmt.Errorf("pg: unsupported model %T", model))
		insert.go#L176: 			err = fmt.Errorf("pg: can't bulk-insert empty slice %s", value.Type())
		model.go#L66: 			return nil, fmt.Errorf("pg: Model(unsupported %T)", value)
		model.go#L76: 		return nil, fmt.Errorf("pg: Model(non-pointer %T)", value)
		model.go#L93: 				return nil, fmt.Errorf("pg: Model(non-pointer %s)", v.Type().String())
		model.go#L128: 		return nil, fmt.Errorf("pg: Model(unsupported %T)", value)
		model.go#L146: 		return fmt.Errorf("pg: Model(unsupported %s, expected *map[string]interface{})",
		model_func.go#L25: 		panic(fmt.Errorf("ForEach expects a %s, got a %s",
		model_func.go#L30: 		panic(fmt.Errorf("ForEach expects at least 1 arg, got %d", fnt.NumIn()))
		model_func.go#L34: 		panic(fmt.Errorf("ForEach must return 1 error value, got %d", fnt.NumOut()))
		model_func.go#L37: 		panic(fmt.Errorf("ForEach must return an error, got %T", fnt.Out(0)))
		model_func.go#L66: 		panic(fmt.Errorf("ForEach accepts a %s, got %s",
		model_scan.go#L34: 		return fmt.Errorf("pg: no Scan var for column index=%d name=%q",
		model_scan.go#L65: 		return fmt.Errorf("pg: no Scan var for column index=%d name=%q",
		model_table.go#L64: 	return nil, fmt.Errorf("pg: NewModel(%s)", typ)
		model_table_m2m.go#L63: 		return fmt.Errorf(
		model_table_m2m.go#L87: 			return nil, fmt.Errorf("pg: %s does not have column=%q",
		model_table_many.go#L53: 		return fmt.Errorf(
		model_table_struct.go#L259: 	return fmt.Errorf(
		query.go#L357: 			return q.err(fmt.Errorf("pg: can't find column=%q", col))
		query.go#L419: 		return q.err(fmt.Errorf("%s does not have relation=%q",
		query.go#L1108: 	err := fmt.Errorf(
		table.go#L173: 		return fmt.Errorf("pg: %s does not have primary keys", t)
		table.go#L180: 		return fmt.Errorf("pg: %s does not support soft deletes", t)
		table.go#L229: 		return nil, fmt.Errorf("pg: %s does not have column=%s", t, name)
		table.go#L508: 			err := fmt.Errorf(
		table.go#L600: 		panic(fmt.Errorf("pg: unknown relation=%s on field=%s", rel, field.GoName))
		table.go#L619: 			panic(fmt.Errorf(
		table.go#L633: 			panic(fmt.Errorf(
		table.go#L667: 		panic(fmt.Errorf(
		table.go#L694: 			panic(fmt.Errorf(
		table.go#L728: 		panic(fmt.Errorf(
		table.go#L750: 		panic(fmt.Errorf(
		table.go#L763: 			panic(fmt.Errorf(
		table.go#L797: 		panic(fmt.Errorf(
		table.go#L810: 			panic(fmt.Errorf(
		table.go#L830: 		panic(fmt.Errorf(
		table.go#L846: 		panic(fmt.Errorf("pg: %s must have many2many tag option", field.GoName))
		table.go#L852: 		panic(fmt.Errorf(
		table.go#L869: 				panic(fmt.Errorf(
		table.go#L889: 				panic(fmt.Errorf(
		table.go#L906: 				panic(fmt.Errorf(
		table.go#L926: 				panic(fmt.Errorf(
		table.go#L1098: 			panic(fmt.Errorf("got fk_value, but there are %d fks", len(fks)))
		table.go#L1103: 			panic(fmt.Errorf("fk_value=%q not found in %s", fkValue, t))
		table.go#L1358: 		panic(fmt.Errorf("%s already has %s", t, rel))
		tables.go#L79: 		panic(fmt.Errorf("got %s, wanted %s", typ.Kind(), reflect.Struct))
		update.go#L159: 			err = fmt.Errorf("pg: can't bulk-update empty slice %s", value.Type())

	github.com/go-pg/pg/v10/types
		append_value.go#L71: 		err := fmt.Errorf("pg: appender for the type=%s is already registered",
		array.go#L23: 		panic(fmt.Errorf("pg: Array(nil)"))
		array.go#L36: 		panic(fmt.Errorf("pg: Array(unsupported %s)", a.v.Type()))
		array.go#L43: 		return fmt.Errorf("pg: Array(unsupported %s)", a.v.Type())
		array.go#L47: 		return fmt.Errorf("pg: Array(non-pointer %s)", a.v.Type())
		array_parser.go#L168: 		return fmt.Errorf("pg: got %q, wanted ',' or '}'", c)
		array_scan.go#L56: 			return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		array_scan.go#L116: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		array_scan.go#L153: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		array_scan.go#L200: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		array_scan.go#L247: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		hex.go#L71: 		return nil, fmt.Errorf("got %q, wanted %q", c, '\\')
		hex.go#L77: 		return nil, fmt.Errorf("got %q, wanted %q", c, 'x')
		hstore.go#L23: 		panic(fmt.Errorf("pg.Hstore(nil)"))
		hstore.go#L31: 		panic(fmt.Errorf("pg.Hstore(unsupported %s)", typ))
		hstore.go#L55: 		return fmt.Errorf("pg: Hstore(non-pointer %s)", h.v.Type())
		hstore_append.go#L16: 		err := fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
		hstore_scan.go#L13: 		return fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
		in_op.go#L25: 			stickyErr: fmt.Errorf("pg: In(non-slice %T)", slice),
		scan.go#L46: 		return fmt.Errorf("pg: Scan(non-pointer %T)", v)
		scan.go#L49: 		return fmt.Errorf("pg: Scan(non-settable %T)", v)
		scan.go#L60: 			return fmt.Errorf("pg: Decode(non-pointer %s)", vv.Type().String())
		scan.go#L102: 		return fmt.Errorf("pg: can't parse bytea: %q", tmp)
		scan.go#L106: 		return fmt.Errorf("pg: can't parse bytea: %q", tmp)
		scan.go#L111: 		return fmt.Errorf("pg: too small buf to decode hex")
		scan_value.go#L74: 		err := fmt.Errorf("pg: scanner for the type=%s is already registered",
		scan_value.go#L138: 			return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
		scan_value.go#L146: 				return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		scan_value.go#L154: 				return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		scan_value.go#L183: 	return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
		scan_value.go#L288: 		return fmt.Errorf("pg: invalid ip=%q", tmp)
		scan_value.go#L381: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
		scan_value.go#L403: 		return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())

	github.com/golang/mock/gomock
		call.go#L313: 			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
		call.go#L319: 				return fmt.Errorf(
		call.go#L327: 			return fmt.Errorf("expected call at %s has the wrong number of matchers. Got: %d, want: %d",
		call.go#L331: 			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
		call.go#L335: 			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d",
		call.go#L343: 					return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
		call.go#L387: 			return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
		call.go#L395: 			return fmt.Errorf("expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v",
		call.go#L402: 		return fmt.Errorf("expected call at %s has already been called the max number of times", c.origin)

	github.com/golang/protobuf/jsonpb
		decode.go#L159: 			return fmt.Errorf("can't unmarshal Any's '@type': %q", rawTypeURL)
		decode.go#L174: 					return fmt.Errorf("could not resolve Any message type: %v", typeURL)
		decode.go#L187: 				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
		decode.go#L193: 				return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
		decode.go#L196: 				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
		decode.go#L202: 			return fmt.Errorf("can't marshal proto %v into Any.Value: %v", typeURL, err)
		decode.go#L223: 			return fmt.Errorf("bad Duration: %v", err)
		decode.go#L238: 			return fmt.Errorf("bad Timestamp: %v", err)
		decode.go#L257: 				return fmt.Errorf("unrecognized type for Value %q", in)
		decode.go#L269: 				return fmt.Errorf("unrecognized type for Value %q", in)
		decode.go#L277: 			return fmt.Errorf("bad ListValue: %v", err)
		decode.go#L292: 			return fmt.Errorf("bad StructValue: %v", err)
		decode.go#L300: 				return fmt.Errorf("bad value in StructValue for key %q: %v", key, err)
		decode.go#L365: 			return fmt.Errorf("extension field %q does not extend message %q", xname, m.Descriptor().FullName())
		decode.go#L382: 			return fmt.Errorf("unknown field %q in %v", name, md.FullName())
		decode.go#L487: 				return v, fmt.Errorf("unknown value %q for enum %s", in, fd.Enum().FullName())
		encode.go#L140: 				return fmt.Errorf("type %T produced invalid JSON: %v", m.Interface(), err)
		encode.go#L144: 				return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
		encode.go#L175: 			return fmt.Errorf("seconds out of range %v", s)
		encode.go#L178: 			return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
		encode.go#L199: 			return fmt.Errorf("ns out of range [0, %v)", secondInNanos)

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

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

	github.com/robfig/cron/v3
		chain.go#L48: 						err = fmt.Errorf("%v", r)
		parser.go#L90: 		return nil, fmt.Errorf("empty spec string")
		parser.go#L100: 			return nil, fmt.Errorf("provided bad location %s: %v", spec[eq+1:i], err)
		parser.go#L108: 			return nil, fmt.Errorf("parser does not accept descriptors: %v", spec)
		parser.go#L172: 		return nil, fmt.Errorf("multiple optionals may not be configured")
		parser.go#L187: 			return nil, fmt.Errorf("expected exactly %d fields, found %d: %s", min, count, fields)
		parser.go#L189: 		return nil, fmt.Errorf("expected %d to %d fields, found %d: %s", min, max, count, fields)
		parser.go#L200: 			return nil, fmt.Errorf("unknown optional field")
		parser.go#L280: 			return 0, fmt.Errorf("too many hyphens: %s", expr)
		parser.go#L301: 		return 0, fmt.Errorf("too many slashes: %s", expr)
		parser.go#L305: 		return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
		parser.go#L308: 		return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr)
		parser.go#L311: 		return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
		parser.go#L314: 		return 0, fmt.Errorf("step of range should be a positive number: %s", expr)
		parser.go#L334: 		return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err)
		parser.go#L337: 		return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr)
		parser.go#L428: 			return nil, fmt.Errorf("failed to parse duration %s: %s", descriptor, err)
		parser.go#L433: 	return nil, fmt.Errorf("unrecognized descriptor: %s", descriptor)

	github.com/valyala/fastjson
		parser.go#L37: 		return nil, fmt.Errorf("cannot parse JSON: %s; unparsed tail: %q", err, startEndString(tail))
		parser.go#L41: 		return nil, fmt.Errorf("unexpected tail: %q", startEndString(tail))
		parser.go#L103: 		return nil, s, fmt.Errorf("cannot parse empty string")
		parser.go#L107: 		return nil, s, fmt.Errorf("too big depth for the nested JSON; it exceeds %d", MaxDepth)
		parser.go#L113: 			return nil, tail, fmt.Errorf("cannot parse object: %s", err)
		parser.go#L120: 			return nil, tail, fmt.Errorf("cannot parse array: %s", err)
		parser.go#L127: 			return nil, tail, fmt.Errorf("cannot parse string: %s", err)
		parser.go#L136: 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
		parser.go#L142: 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
		parser.go#L155: 			return nil, s, fmt.Errorf("unexpected value found: %q", s)
		parser.go#L162: 		return nil, tail, fmt.Errorf("cannot parse number: %s", err)
		parser.go#L173: 		return nil, s, fmt.Errorf("missing ']'")
		parser.go#L193: 			return nil, s, fmt.Errorf("cannot parse array value: %s", err)
		parser.go#L199: 			return nil, s, fmt.Errorf("unexpected end of array")
		parser.go#L209: 		return nil, s, fmt.Errorf("missing ',' after array value")
		parser.go#L216: 		return nil, s, fmt.Errorf("missing '}'")
		parser.go#L236: 			return nil, s, fmt.Errorf(`cannot find opening '"" for object key`)
		parser.go#L240: 			return nil, s, fmt.Errorf("cannot parse object key: %s", err)
		parser.go#L244: 			return nil, s, fmt.Errorf("missing ':' after object key")
		parser.go#L252: 			return nil, s, fmt.Errorf("cannot parse object value: %s", err)
		parser.go#L256: 			return nil, s, fmt.Errorf("unexpected end of object")
		parser.go#L265: 		return nil, s, fmt.Errorf("missing ',' after object value")
		parser.go#L388: 	return s, "", fmt.Errorf(`missing closing '"'`)
		parser.go#L394: 		return s, "", fmt.Errorf(`missing closing '"'`)
		parser.go#L415: 			return ss, "", fmt.Errorf(`missing closing '"'`)
		parser.go#L439: 			return "", s, fmt.Errorf("unexpected char: %q", s[:1])
		parser.go#L606: 		panic(fmt.Errorf("BUG: unexpected Value type: %d", v.t))
		parser.go#L673: 		panic(fmt.Errorf("BUG: unknown Value type: %d", t))
		parser.go#L864: 		return nil, fmt.Errorf("value doesn't contain object; it contains %s", v.Type())
		parser.go#L876: 		return nil, fmt.Errorf("value doesn't contain array; it contains %s", v.Type())
		parser.go#L888: 		return nil, fmt.Errorf("value doesn't contain string; it contains %s", v.Type())
		parser.go#L898: 		return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
		parser.go#L908: 		return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
		parser.go#L916: 		return 0, fmt.Errorf("number %q doesn't fit int", v.s)
		parser.go#L926: 		return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
		parser.go#L934: 		return 0, fmt.Errorf("number %q doesn't fit uint", v.s)
		parser.go#L944: 		return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
		parser.go#L954: 		return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
		parser.go#L969: 	return false, fmt.Errorf("value doesn't contain bool; it contains %s", v.Type())
		validate.go#L15: 		return fmt.Errorf("cannot parse JSON: %s; unparsed tail: %q", err, startEndString(tail))
		validate.go#L19: 		return fmt.Errorf("unexpected tail: %q", startEndString(tail))
		validate.go#L31: 		return s, fmt.Errorf("cannot parse empty string")
		validate.go#L37: 			return tail, fmt.Errorf("cannot parse object: %s", err)
		validate.go#L44: 			return tail, fmt.Errorf("cannot parse array: %s", err)
		validate.go#L51: 			return tail, fmt.Errorf("cannot parse string: %s", err)
		validate.go#L56: 				return tail, fmt.Errorf("string cannot contain control char 0x%02X", sv[i])
		validate.go#L63: 			return s, fmt.Errorf("unexpected value found: %q", s)
		validate.go#L69: 			return s, fmt.Errorf("unexpected value found: %q", s)
		validate.go#L75: 			return s, fmt.Errorf("unexpected value found: %q", s)
		validate.go#L82: 		return tail, fmt.Errorf("cannot parse number: %s", err)
		validate.go#L90: 		return s, fmt.Errorf("missing ']'")
		validate.go#L102: 			return s, fmt.Errorf("cannot parse array value: %s", err)
		validate.go#L107: 			return s, fmt.Errorf("unexpected end of array")
		validate.go#L117: 		return s, fmt.Errorf("missing ',' after array value")
		validate.go#L124: 		return s, fmt.Errorf("missing '}'")
		validate.go#L136: 			return s, fmt.Errorf(`cannot find opening '"" for object key`)
		validate.go#L142: 			return s, fmt.Errorf("cannot parse object key: %s", err)
		validate.go#L147: 				return s, fmt.Errorf("object key cannot contain control char 0x%02X", key[i])
		validate.go#L152: 			return s, fmt.Errorf("missing ':' after object key")
		validate.go#L160: 			return s, fmt.Errorf("cannot parse object value: %s", err)
		validate.go#L164: 			return s, fmt.Errorf("unexpected end of object")
		validate.go#L173: 		return s, fmt.Errorf("missing ',' after object value")
		validate.go#L190: 	return "", s, fmt.Errorf(`missing closing '"'`)
		validate.go#L211: 			return rs, tail, fmt.Errorf("BUG: parseRawString returned invalid string with trailing backslash: %q", rs)
		validate.go#L221: 				return rs, tail, fmt.Errorf(`too short escape sequence: \u%s`, rs)
		validate.go#L226: 				return rs, tail, fmt.Errorf(`invalid escape sequence \u%s: %s`, xs, err)
		validate.go#L230: 			return rs, tail, fmt.Errorf(`unknown escape sequence \%c`, ch)
		validate.go#L237: 		return s, fmt.Errorf("zero-length number")
		validate.go#L242: 			return s, fmt.Errorf("missing number after minus")
		validate.go#L253: 		return s, fmt.Errorf("expecting 0..9 digit, got %c", s[0])
		validate.go#L256: 		return s, fmt.Errorf("unexpected number starting from 0")
		validate.go#L265: 			return s, fmt.Errorf("missing fractional part")
		validate.go#L275: 			return s, fmt.Errorf("expecting 0..9 digit in fractional part, got %c", s[0])
		validate.go#L285: 			return s, fmt.Errorf("missing exponent part")
		validate.go#L290: 				return s, fmt.Errorf("missing exponent part")
		validate.go#L301: 			return s, fmt.Errorf("expecting 0..9 digit in exponent part, got %c", s[0])

	github.com/valyala/fastjson/fastfloat
		parse.go#L57: 		return 0, fmt.Errorf("cannot parse uint64 from empty string")
		parse.go#L80: 		return 0, fmt.Errorf("cannot parse uint64 from %q", s)
		parse.go#L84: 		return 0, fmt.Errorf("unparsed tail left after parsing uint64 from %q: %q", s, s[i:])
		parse.go#L147: 		return 0, fmt.Errorf("cannot parse int64 from empty string")
		parse.go#L154: 			return 0, fmt.Errorf("cannot parse int64 from %q", s)
		parse.go#L178: 		return 0, fmt.Errorf("cannot parse int64 from %q", s)
		parse.go#L182: 		return 0, fmt.Errorf("unparsed tail left after parsing int64 form %q: %q", s, s[i:])
		parse.go#L363: 		return 0, fmt.Errorf("cannot parse float64 from empty string")
		parse.go#L370: 			return 0, fmt.Errorf("cannot parse float64 from %q", s)
		parse.go#L377: 		return 0, fmt.Errorf("missing integer and fractional part in %q", s)
		parse.go#L415: 		return 0, fmt.Errorf("unparsed tail left after parsing float64 from %q: %q", s, ss)
		parse.go#L443: 						return 0, fmt.Errorf("cannot parse mantissa in %q: %s", s, err)
		parse.go#L452: 			return 0, fmt.Errorf("cannot find mantissa in %q", s)
		parse.go#L468: 			return 0, fmt.Errorf("cannot parse exponent in %q", s)
		parse.go#L475: 				return 0, fmt.Errorf("cannot parse exponent in %q", s)
		parse.go#L489: 						return 0, fmt.Errorf("cannot parse exponent in %q: %s", s, err)
		parse.go#L498: 			return 0, fmt.Errorf("cannot parse exponent in %q", s)
		parse.go#L511: 	return 0, fmt.Errorf("cannot parse float64 from %q", s)

	github.com/vmihailenco/msgpack/v5
		decode.go#L272: 		return fmt.Errorf("msgpack: Decode(non-pointer %T)", v)
		decode.go#L275: 		return fmt.Errorf("msgpack: Decode(non-settable %T)", v)
		decode.go#L283: 				return fmt.Errorf("msgpack: Decode(non-pointer %s)", vv.Type().String())
		decode.go#L318: 		return fmt.Errorf("msgpack: invalid code=%x decoding nil", c)
		decode.go#L353: 	return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c)
		decode.go#L443: 	return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
		decode.go#L501: 	return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
		decode.go#L548: 	return fmt.Errorf("msgpack: unknown code %x", c)
		decode_map.go#L221: 		return nil, fmt.Errorf("msgpack: unsupported map key: %s", keyType.String())
		decode_map.go#L331: 			return fmt.Errorf("msgpack: unknown field %q", name)
		decode_number.go#L119: 	return 0, fmt.Errorf("msgpack: invalid code=%x decoding uint64", c)
		decode_number.go#L162: 	return 0, fmt.Errorf("msgpack: invalid code=%x decoding int64", c)
		decode_number.go#L184: 		return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c)
		decode_number.go#L216: 		return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c)
		decode_query.go#L65: 		err = fmt.Errorf("msgpack: unsupported code=%x decoding key=%q", code, q.key)
		decode_slice.go#L35: 	return 0, fmt.Errorf("msgpack: invalid code=%x decoding array length", c)
		decode_slice.go#L136: 		return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
		decode_string.go#L31: 	return 0, fmt.Errorf("msgpack: invalid code=%x decoding string/bytes length", c)
		decode_string.go#L187: 		return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
		decode_value.go#L144: 			return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
		decode_value.go#L208: 	return fmt.Errorf("msgpack: Decode(unsupported %s)", v.Type())
		encode_value.go#L135: 		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
		encode_value.go#L152: 		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
		encode_value.go#L190: 	return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type())
		encode_value.go#L205: 		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
		encode_value.go#L228: 		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
		ext.go#L99: 			return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
		ext.go#L151: 			return fmt.Errorf("msgpack: got ext type=%d, wanted %d", extID, wantedExtID)
		ext.go#L160: 			return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
		ext.go#L242: 		return 0, fmt.Errorf("msgpack: invalid code=%x decoding ext len", c)
		ext.go#L254: 		return nil, fmt.Errorf("msgpack: unknown ext id=%d", extID)
		intern.go#L99: 	return fmt.Errorf("msgpack: interned string index=%d is too large", idx)
		intern.go#L152: 			err := fmt.Errorf("msgpack: got ext type=%d, wanted %d",
		intern.go#L211: 	err := fmt.Errorf("msgpack: unsupported ext len=%d decoding interned string", extLen)
		intern.go#L217: 		err := fmt.Errorf("msgpack: interned string at index=%d does not exist", idx)
		time.go#L107: 		return time.Time{}, fmt.Errorf("msgpack: invalid time ext id=%d", extID)
		time.go#L142: 		err = fmt.Errorf("msgpack: invalid ext len=%d decoding time", extLen)
		types.go#L214: 				err := fmt.Errorf("msgpack: intern strings are not supported on %s", f.Type)

	go.pact.im/x/crypt
		argon2.go#L27: 			return "", fmt.Errorf("parse version: %w", err)
		argon2.go#L68: 			return "", fmt.Errorf("parse parameter %q: %w", it.Name, err)
		argon2.go#L94: 			return "", fmt.Errorf("decode salt: %w", err)
		argon2.go#L100: 			return "", fmt.Errorf("generate salt: %w", err)
		crypt.go#L79: 			err = fmt.Errorf("%s: %w", hash.ID, err)
		crypt.go#L87: 		return "", fmt.Errorf("crypt: %w", err)

	go.pact.im/x/old/pgtxtar
		pgtxtar.go#L42: 			parseErrors = multierr.Append(parseErrors, fmt.Errorf("parse version: %q", err))
		pgtxtar.go#L48: 			parseErrors = multierr.Append(parseErrors, fmt.Errorf("migration %q: %v", name, err))
		pgtxtar.go#L86: 				err = multierr.Append(err, fmt.Errorf(
		pgtxtar.go#L91: 			err = multierr.Append(err, fmt.Errorf(
		pgtxtar.go#L97: 			err = multierr.Append(err, fmt.Errorf(
		pgtxtar.go#L109: 		err = multierr.Append(err, fmt.Errorf(

	go.pact.im/x/process
		process.go#L137: 		return fmt.Errorf("run: %w", p.Err())
		process.go#L186: 			return fmt.Errorf("run: %w", err)
		runnable.go#L77: 	return fmt.Errorf("%s: %w", p.name, err)

	go.pact.im/x/supervisor
		restart.go#L65: 		return fmt.Errorf("create iterator: %w", err)
		supervisor.go#L142: 		return nil, fmt.Errorf("get process from table: %w", err)
		supervisor.go#L172: 		return nil, fmt.Errorf("start process: %w", err)

	go.pact.im/x/task
		task.go#L30: 		return fmt.Errorf("%s: %w", name, err)

	go.pact.im/x/zapjournal
		zapjournal_linux.go#L78: 		return fmt.Errorf("create memfd: %w", err)
		zapjournal_linux.go#L85: 		return fmt.Errorf("write to memfd: %w", err)
		zapjournal_linux.go#L90: 		return fmt.Errorf("seal memfd: %w", err)

	go.uber.org/goleak
		leaks.go#L73: 	return fmt.Errorf("found unexpected goroutines:\n%s", stacks)

	go.uber.org/zap
		encoder.go#L58: 		return fmt.Errorf("encoder already registered for name %q", name)
		encoder.go#L76: 		return nil, fmt.Errorf("no encoder registered for name %q", name)
		global.go#L158: 	return nil, fmt.Errorf("unrecognized level: %q", lvl)
		http_handler.go#L126: 		return 0, fmt.Errorf("malformed request body: %v", err)
		sink.go#L83: 		return fmt.Errorf("%q is not a valid scheme: %v", scheme, err)
		sink.go#L86: 		return fmt.Errorf("sink factory already registered for scheme %q", normalized)
		sink.go#L103: 		return nil, fmt.Errorf("can't parse %q as a URL: %v", rawURL, err)
		sink.go#L131: 		return nil, fmt.Errorf("user and password not allowed with file URLs: got %v", u)
		sink.go#L134: 		return nil, fmt.Errorf("fragments not allowed with file URLs: got %v", u)
		sink.go#L137: 		return nil, fmt.Errorf("query parameters not allowed with file URLs: got %v", u)
		sink.go#L141: 		return nil, fmt.Errorf("ports not allowed with file URLs: got %v", u)
		sink.go#L144: 		return nil, fmt.Errorf("file URLs must leave host empty or use localhost: got %v", u)
		sink.go#L176: 		return "", fmt.Errorf("may not contain %q", c)
		writer.go#L73: 			openErr = multierr.Append(openErr, fmt.Errorf("open sink %q: %w", path, err))

	go.uber.org/zap/zapcore
		error.go#L59: 			retErr = fmt.Errorf("PANIC=%v", rerr)
		field.go#L227: 			retErr = fmt.Errorf("PANIC=%v", err)
		increase_level.go#L42: 			return nil, fmt.Errorf("invalid increase level, as level %q is allowed by increased level, but not by existing core", l)
		level.go#L175: 		return fmt.Errorf("unrecognized level: %q", text)

	go/build
		build.go#L541: 		return p, fmt.Errorf("import %q: invalid import path", path)
		build.go#L558: 		pkgerr = fmt.Errorf("import %q: unknown compiler %q", path, ctxt.Compiler)
		build.go#L575: 			return p, fmt.Errorf("import %q: import relative to unknown directory", path)
		build.go#L628: 			return p, fmt.Errorf("import %q: cannot import absolute path", path)
		build.go#L766: 		return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))
		build.go#L792: 		return p, fmt.Errorf("cannot find package %q in:\n\t%s", p.ImportPath, p.Dir)
		build.go#L925: 					badFile(name, fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
		build.go#L930: 					badFile(name, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
		build.go#L940: 					badFile(name, fmt.Errorf("use of cgo in test %s not supported", filename))
		build.go#L1102: 			return fmt.Errorf("go/build: Dir is non-empty, so relative srcDir is not allowed: %v", srcDir)
		build.go#L1191: 		return fmt.Errorf("go/build: go list %s: %v\n%s\n", path, err, stderr.String())
		build.go#L1196: 		return fmt.Errorf("go/build: importGo %s: unexpected output:\n%s\n", path, stdout.String())
		build.go#L1439: 		return nil, fmt.Errorf("read %s: %v", info.name, err)
		build.go#L1445: 		return nil, fmt.Errorf("%s: %v", name, err)
		build.go#L1535: 			return false, false, fmt.Errorf("parsing //go:build line: %v", err)
		build.go#L1654: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1660: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1679: 			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
		build.go#L1683: 				return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg)
		build.go#L1708: 			return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig)
		read.go#L460: 				return fmt.Errorf("parser returned invalid quoted string: <%s>", quoted)
		read.go#L543: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
		read.go#L557: 						return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
		read.go#L565: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
		read.go#L572: 				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)

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

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

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

	go/types
		eval.go#L82: 				return fmt.Errorf("no position %s found in package %s", fset.Position(pos), pkg.name)
		instantiate.go#L52: 			return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams))
		resolver.go#L90: 		return "", fmt.Errorf("empty string")
		resolver.go#L95: 			return s, fmt.Errorf("invalid character %#U", r)
		resolver.go#L155: 			err = fmt.Errorf("Config.Importer not installed")
		resolver.go#L159: 				err = fmt.Errorf("Config.Importer.ImportFrom(%s, %s, 0) returned nil but no error", path, dir)
		resolver.go#L164: 				err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path)
		resolver.go#L170: 			err = fmt.Errorf("invalid package name: %q", imp.name)
		version.go#L70: 		err = fmt.Errorf(`should be something like "go1.12"`)

	golang.org/x/net/http2
		server.go#L282: 			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
		server.go#L1061: 			errc <- fmt.Errorf("bogus greeting %q", buf)
		server.go#L1812: 		st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
		server.go#L1877: 		st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
		server.go#L1902: 	st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
		server.go#L2994: 			return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
		server.go#L3000: 			return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
		server.go#L3008: 			return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
		server.go#L3020: 			return fmt.Errorf("promised request headers cannot include %q", k)
		server.go#L3031: 		return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
		server.go#L3182: 			return fmt.Errorf("request header %q is not valid in HTTP/2", k)
		transport.go#L639: 	return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
		transport.go#L695: 		return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
		transport.go#L1150: 			return "", fmt.Errorf("invalid Trailer key %q", k)
		transport.go#L1177: 		return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
		transport.go#L1180: 		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
		transport.go#L1183: 		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
		transport.go#L1856: 					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
		transport.go#L1858: 					return nil, fmt.Errorf("invalid request :path %q", orig)
		transport.go#L1869: 			return nil, fmt.Errorf("invalid HTTP header name %q", k)
		transport.go#L1874: 				return nil, fmt.Errorf("invalid HTTP header value for header %q", k)
		transport.go#L3071: 			err = fmt.Errorf("%v", e)

	golang.org/x/sync/errgroup
		errgroup.go#L129: 		panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", len(g.sem)))

	golang.org/x/sys/execabs
		execabs.go#L42: 	return fmt.Errorf("%s resolves to executable in current directory (.%c%s)", file, filepath.Separator, path)

	golang.org/x/text/unicode/bidi
		core.go#L1016: 		return fmt.Errorf("types is null")
		core.go#L1020: 			return fmt.Errorf("B type before end of paragraph at index: %d", i)
		core.go#L1030: 		return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
		core.go#L1039: 			return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
		core.go#L1044: 		return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
		core.go#L1051: 		return fmt.Errorf("pairTypes is null")
		core.go#L1057: 			return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
		core.go#L1065: 		return fmt.Errorf("pairValues is null")
		core.go#L1068: 		return fmt.Errorf("pairTypes is different length from pairValues")

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

	golang.org/x/tools/go/gcexportdata
		gcexportdata.go#L119: 		return nil, fmt.Errorf("reading export data for %q: %v", path, err)
		gcexportdata.go#L123: 		return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
		gcexportdata.go#L148: 			return nil, fmt.Errorf("unexpected export data with prefix %q for path %s", string(data[:l]), path)
		gcexportdata.go#L151: 	return nil, fmt.Errorf("empty export data for %s", path)
		gcexportdata.go#L176: 		return nil, fmt.Errorf("reading export bundle: %v", err)
		importer.go#L49: 		return nil, fmt.Errorf("can't find import: %s", importPath)
		importer.go#L65: 			err = fmt.Errorf("reading export data: %s: %v", filename, err)

	golang.org/x/tools/go/internal/packagesdriver
		sizes.go#L42: 			return nil, fmt.Errorf("could not parse GOARCH and Go compiler in format \"<GOARCH> <compiler>\":\nstdout: <<%s>>\nstderr: <<%s>>",

	golang.org/x/tools/go/packages
		external.go#L76: 			return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
		external.go#L89: 			return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
		golist.go#L191: 				return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
		golist.go#L302: 			return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
		golist.go#L469: 			return nil, fmt.Errorf("JSON decoding failed: %v", err)
		golist.go#L483: 			return nil, fmt.Errorf("package missing import path: %+v", p)
		golist.go#L525: 					return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
		golist.go#L542: 						return nil, fmt.Errorf(`internal error: go list gave a %q error with empty import stack`, errkind)
		golist.go#L550: 							return nil, fmt.Errorf(`internal error: go list gave a %q error with an import stack without importing package`, errkind)
		golist.go#L949: 			return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
		golist.go#L956: 			return nil, fmt.Errorf("couldn't run 'go': %w", err)
		golist.go#L961: 			return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
		golist_overlay.go#L237: 				return nil, nil, fmt.Errorf("cannot resolve imports for package %q with no Go files", pkg.PkgPath)
		golist_overlay.go#L454: 		return "", fmt.Errorf("files (%v) are in more than one directory: %v", files, seen)
		packages.go#L673: 			return nil, fmt.Errorf("root package %v is missing", root)
		packages.go#L716: 					importErr = fmt.Errorf("missing package: %q", ipkg.ID)
		packages.go#L718: 					importErr = fmt.Errorf("import cycle: %s", stack)
		packages.go#L1021: 			return nil, fmt.Errorf("no metadata for %s", path)
		packages.go#L1236: 		return fmt.Errorf("no export data file")
		packages.go#L1252: 		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
		packages.go#L1296: 		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)

	golang.org/x/tools/internal/gcimporter
		bimport.go#L61: 				err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
		bimport.go#L63: 				err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)
		exportdata.go#L34: 		err = fmt.Errorf("invalid archive header")
		exportdata.go#L51: 		err = fmt.Errorf("can't find export data (%v)", err)
		exportdata.go#L64: 			err = fmt.Errorf("go archive is missing __.PKGDEF")
		exportdata.go#L71: 			err = fmt.Errorf("can't find export data (%v)", err)
		exportdata.go#L80: 		err = fmt.Errorf("not a Go object file")
		exportdata.go#L88: 			err = fmt.Errorf("can't find export data (%v)", err)
		gcimporter.go#L179: 			return nil, fmt.Errorf("can't find import: %q", id)
		gcimporter.go#L195: 				err = fmt.Errorf("%s: %v", filename, err)
		gcimporter.go#L243: 				return nil, fmt.Errorf("unexpected export data with prefix %q for path %s", string(data[:l]), id)
		gcimporter.go#L248: 		err = fmt.Errorf("unknown export data header: %q", hdr)
		iimport.go#L107: 					err = fmt.Errorf("%v", e)
		iimport.go#L109: 					err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
		iimport.go#L111: 					err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)

	golang.org/x/tools/internal/gocommand
		invoke.go#L161: 			friendlyError = fmt.Errorf("go command required, not found: %v", ee)
		invoke.go#L166: 		friendlyError = fmt.Errorf("err: %v: stderr: %s", friendlyError, stderr)
		vendor.go#L99: 		return nil, false, fmt.Errorf("unexpected stdout: %q", stdout.String())
		version.go#L47: 		return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
		version.go#L58: 	return 0, fmt.Errorf("no parseable ReleaseTags in %v", tags)

	golang.org/x/tools/internal/pkgbits
		decoder.go#L87: 		panic(fmt.Errorf("unsupported version: %v", pr.version))
		decoder.go#L442: 		panic(fmt.Errorf("unexpected scalar tag: %v", tag))
		support.go#L16: 	panic(fmt.Errorf(format, args...))

	golang.org/x/tools/internal/typeparams
		normalize.go#L66: 		return nil, fmt.Errorf("%s has nil constraint", tparam)
		normalize.go#L70: 		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
		normalize.go#L146: 			return nil, fmt.Errorf("cycle detected in the declaration of %s", t)
		normalize.go#L166: 				return nil, fmt.Errorf("invalid embedded type %T", embedded)
		normalize.go#L190: 				return nil, fmt.Errorf("invalid union term %T", t)
		normalize.go#L199: 				return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)

	google.golang.org/grpc
		balancer_conn_wrappers.go#L304: 		return nil, fmt.Errorf("grpc: cannot create SubConn with empty address list")
		clientconn.go#L205: 			return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
		clientconn.go#L231: 				conn, err = nil, fmt.Errorf("%v: %v", ctx.Err(), err)
		clientconn.go#L298: 		return nil, fmt.Errorf("failed to build resolver: %v", err)
		clientconn.go#L1583: 		return nil, fmt.Errorf("could not get resolver for default scheme: %q", parsedTarget.URL.Scheme)
		clientconn.go#L1626: 		return "", fmt.Errorf("ClientConn's authority from transport creds %q and dial option %q don't match", authorityFromCreds, authorityFromDialOption)
		pickfirst.go#L67: 		Picker:            &picker{err: fmt.Errorf("name resolver error: %v", err)},
		pickfirst.go#L98: 			Picker:            &picker{err: fmt.Errorf("error creating connection: %v", err)},
		rpc_util.go#L74: 		return nil, fmt.Errorf("grpc: invalid compression level: %d", level)
		service_config.go#L137: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L141: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L150: 			return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
		service_config.go#L157: 			return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L161: 			return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
		service_config.go#L170: 		return nil, fmt.Errorf("malformed duration %q", *s)
		service_config.go#L224: 		return &serviceconfig.ParseResult{Err: fmt.Errorf("no JSON service config provided")}
		service_config.go#L302: 			return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: maxTokens (%v) out of range (0, 1000]", mt)}
		service_config.go#L305: 			return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: tokenRatio (%v) may not be negative", tr)}

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

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

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

	google.golang.org/grpc/encoding/proto
		proto.go#L43: 		return nil, fmt.Errorf("failed to marshal, message is %T, want proto.Message", v)
		proto.go#L51: 		return fmt.Errorf("failed to unmarshal, message is %T, want proto.Message", v)

	google.golang.org/grpc/internal/balancer/gracefulswitch
		gracefulswitch.go#L334: 		return nil, fmt.Errorf("%T at address %p that called NewSubConn is deleted", bw, bw)
		gracefulswitch.go#L346: 		return nil, fmt.Errorf("%T at address %p that called NewSubConn is deleted", bw, bw)

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

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

	google.golang.org/grpc/internal/metadata
		metadata.go#L95: 				return fmt.Errorf("header key %q contains illegal characters not in [0-9a-z-_.]", k)
		metadata.go#L104: 				return fmt.Errorf("header key %q contains value with non-printable ASCII characters", k)

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

	google.golang.org/grpc/internal/resolver/unix
		unix.go#L38: 		return nil, fmt.Errorf("invalid (non-empty) authority: %v", target.URL.Host)

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

	google.golang.org/grpc/internal/syscall
		syscall_linux.go#L79: 		return fmt.Errorf("error getting raw connection: %v", err)
		syscall_linux.go#L85: 		return fmt.Errorf("error setting option on socket: %v", err)
		syscall_linux.go#L95: 		err = fmt.Errorf("conn is not *net.TCPConn. got %T", conn)
		syscall_linux.go#L100: 		err = fmt.Errorf("error getting raw connection: %v", err)
		syscall_linux.go#L107: 		err = fmt.Errorf("error getting option on socket: %v", err)

	google.golang.org/grpc/internal/transport
		controlbuf.go#L857: 		return fmt.Errorf("transport: unknown control message type %T", i)
		flowcontrol.go#L184: 		return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", rcvd, limit)
		http2_server.go#L371: 		return fmt.Errorf("received an illegal stream id: %v. headers frame: %+v", streamID, frame)
		http2_server.go#L1187: 				t.Close(fmt.Errorf("keepalive ping not acked within timeout %s", t.kp.Time))
		http_util.go#L202: 		return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
		http_util.go#L206: 		return 0, fmt.Errorf("transport: timeout string is too long: %q", s)
		http_util.go#L211: 		return 0, fmt.Errorf("transport: timeout unit is not recognized: %q", s)
		proxy.go#L92: 		return nil, fmt.Errorf("failed to write the HTTP request: %v", err)
		proxy.go#L98: 		return nil, fmt.Errorf("reading server HTTP response: %v", err)
		proxy.go#L104: 			return nil, fmt.Errorf("failed to do connect handshake, status code: %s", resp.Status)
		proxy.go#L106: 		return nil, fmt.Errorf("failed to do connect handshake, response: %q", dump)
		proxy.go#L139: 		return fmt.Errorf("failed to write the HTTP request: %v", err)

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

	gotest.tools/v3/assert/cmp
		compare.go#L380: 	stdlibFmtErrorType = reflect.TypeOf(fmt.Errorf("%w", fmt.Errorf("")))

	gotest.tools/v3/internal/source
		defers.go#L31: 		return nil, fmt.Errorf("failed to find expression in defer")
		defers.go#L35: 		return nil, fmt.Errorf(
		source.go#L41: 		return nil, fmt.Errorf("failed to parse source file %s: %w", filename, err)
		source.go#L46: 		return nil, fmt.Errorf("call from %s:%d: %w", filename, line, err)
		source.go#L85: 		return nil, fmt.Errorf("failed to find an expression")
		update.go#L27: var ErrNotFound = fmt.Errorf("failed to find variable for update of golden value")
		update.go#L43: 		return fmt.Errorf("failed to parse source file %s: %w", filename, err)
		update.go#L48: 		return fmt.Errorf("call from %s:%d: %w", filename, line, err)
		update.go#L125: 		return fmt.Errorf("failed to format file after update: %w", err)
		update.go#L130: 		return fmt.Errorf("failed to open file %v: %w", filename, err)
		update.go#L133: 		return fmt.Errorf("failed to write file %v: %w", filename, err)
		update.go#L136: 		return fmt.Errorf("failed to sync file %v: %w", filename, err)

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

	internal/buildcfg
		cfg.go#L67: 	Error = fmt.Errorf("invalid GOAMD64: must be v1, v2, v3, v4")
		cfg.go#L85: 	Error = fmt.Errorf("invalid GOARM: must be 5, 6, 7")
		cfg.go#L94: 	Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
		cfg.go#L103: 	Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
		cfg.go#L114: 	Error = fmt.Errorf("invalid GOPPC64: must be power8, power9")
		cfg.go#L144: 			Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
		exp.go#L106: 				err = fmt.Errorf("unknown GOEXPERIMENT %s", f)
		exp.go#L126: 		err = fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers,regabireflect")

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

	internal/profile
		encode.go#L235: 					return fmt.Errorf("Function ID %d not found", id)
		legacy_profile.go#L597: 		return value, blocksize, addrs, fmt.Errorf("unexpected number of sample values: got %d, want 6", len(sampleData))
		legacy_profile.go#L610: 		return value, blocksize, addrs, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L613: 		return value, blocksize, addrs, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L618: 			return value, blocksize, addrs, fmt.Errorf("allocation count was 0 but allocation bytes was %d", v2)
		legacy_profile.go#L844: 		return value, addrs, fmt.Errorf("malformed sample: %s: %v", line, err)
		legacy_profile.go#L848: 		return value, addrs, fmt.Errorf("malformed sample: %s: %v", line, err)
		merge.go#L23: 		return nil, fmt.Errorf("no profiles to merge")
		merge.go#L442: 		return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
		merge.go#L446: 		return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		merge.go#L451: 			return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		profile.go#L136: 			return nil, fmt.Errorf("decompressing profile: %v", err)
		profile.go#L140: 			return nil, fmt.Errorf("decompressing profile: %v", err)
		profile.go#L146: 			return nil, fmt.Errorf("parsing profile: %v", err)
		profile.go#L151: 		return nil, fmt.Errorf("malformed profile: %v", err)
		profile.go#L156: var errUnrecognized = fmt.Errorf("unrecognized profile format")
		profile.go#L157: var errMalformed = fmt.Errorf("malformed profile format")
		profile.go#L236: 		return fmt.Errorf("missing sample type information")
		profile.go#L240: 			return fmt.Errorf("mismatch: sample has: %d values vs. %d types", len(s.Value), len(p.SampleType))
		profile.go#L249: 			return fmt.Errorf("found mapping with reserved ID=0")
		profile.go#L252: 			return fmt.Errorf("multiple mappings with same id: %d", m.ID)
		profile.go#L259: 			return fmt.Errorf("found function with reserved ID=0")
		profile.go#L262: 			return fmt.Errorf("multiple functions with same id: %d", f.ID)
		profile.go#L269: 			return fmt.Errorf("found location with reserved id=0")
		profile.go#L272: 			return fmt.Errorf("multiple locations with same id: %d", l.ID)
		profile.go#L277: 				return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
		profile.go#L283: 					return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
		profile.go#L484: 		return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
		profile.go#L488: 		return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		profile.go#L493: 			return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
		profile.go#L593: 		return fmt.Errorf("mismatched scale ratios, got %d, want %d", len(ratios), len(p.SampleType))
		proto.go#L238: 		return nil, fmt.Errorf("unknown wire type: %d", b.typ)
		prune.go#L87: 			return fmt.Errorf("failed to compile regexp %s: %v", p.DropFrames, err)
		prune.go#L91: 				return fmt.Errorf("failed to compile regexp %s: %v", p.KeepFrames, err)

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

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

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

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

	net/http
		client.go#L269: 		return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
		client.go#L283: 			return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a *Response with content length %d but a nil Body", rt, resp.ContentLength)
		client.go#L645: 				return nil, uerr(fmt.Errorf("%d response missing Location header", resp.StatusCode))
		client.go#L650: 				return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
		cookie.go#L254: 			return fmt.Errorf("http: invalid byte %q in Cookie.Value", c.Value[i])
		cookie.go#L260: 				return fmt.Errorf("http: invalid byte %q in Cookie.Path", c.Path[i])
		h2_bundle.go#L3969: 			return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
		h2_bundle.go#L4703: 			errc <- fmt.Errorf("bogus greeting %q", buf)
		h2_bundle.go#L5432: 		st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
		h2_bundle.go#L5496: 		st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
		h2_bundle.go#L6507: 			return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
		h2_bundle.go#L6513: 			return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
		h2_bundle.go#L6521: 			return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
		h2_bundle.go#L6533: 			return fmt.Errorf("promised request headers cannot include %q", k)
		h2_bundle.go#L6544: 		return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
		h2_bundle.go#L6695: 			return fmt.Errorf("request header %q is not valid in HTTP/2", k)
		h2_bundle.go#L7286: 	return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
		h2_bundle.go#L7340: 			return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
		h2_bundle.go#L7750: 			return "", fmt.Errorf("invalid Trailer key %q", k)
		h2_bundle.go#L7777: 		return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
		h2_bundle.go#L7780: 		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
		h2_bundle.go#L7783: 		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
		h2_bundle.go#L8448: 					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
		h2_bundle.go#L8450: 					return nil, fmt.Errorf("invalid request :path %q", orig)
		h2_bundle.go#L8461: 			return nil, fmt.Errorf("invalid HTTP header name %q", k)
		h2_bundle.go#L8465: 				return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
		h2_bundle.go#L9663: 			err = fmt.Errorf("%v", e)
		request.go#L86: func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }
		request.go#L864: 		return nil, fmt.Errorf("net/http: invalid method %q", method)
		request.go#L1082: 		return nil, fmt.Errorf("too many Host headers")
		server.go#L324: 			return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
		transfer.go#L84: 			return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
		transfer.go#L389: 		return fmt.Errorf("http: ContentLength=%d with Body length %d",
		transfer.go#L680: 				return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
		transfer.go#L698: 			return 0, fmt.Errorf("http: method cannot contain a Content-Length; got %q", contentLens)
		transport.go#L523: 				return nil, fmt.Errorf("net/http: invalid header field name %q", k)
		transport.go#L528: 					return nil, fmt.Errorf("net/http: invalid header field value %q for key %v", v, k)
		transport.go#L554: 		return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
		transport.go#L1924: 		return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
		transport.go#L2048: 		return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %v", err)
		transport.go#L2116: 				err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
		transport.go#L2255: 		pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %v", peekErr))
		transport.go#L2626: 				pc.close(fmt.Errorf("write error: %v", err))

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

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

	net/url
		url.go#L616: 			return "", fmt.Errorf("invalid port %q after host", colonPort)
		url.go#L644: 			return "", fmt.Errorf("invalid port %q after host", colonPort)
		url.go#L926: 			err = fmt.Errorf("invalid semicolon separator in query")

	runtime/debug
		mod.go#L125: 			err = fmt.Errorf("could not parse Go build info: line %d: %w", lineNum, err)
		mod.go#L141: 			return Module{}, fmt.Errorf("expected 2 or 3 columns; got %d", len(elem))
		mod.go#L189: 				return nil, fmt.Errorf("expected 3 columns for replacement; got %d", len(elem))
		mod.go#L192: 				return nil, fmt.Errorf("replacement with no module on previous line")
		mod.go#L203: 				return nil, fmt.Errorf("build line missing '='")
		mod.go#L209: 				return nil, fmt.Errorf("build line with missing key")
		mod.go#L214: 					return nil, fmt.Errorf("invalid quoted key in build line")
		mod.go#L217: 					return nil, fmt.Errorf("build line missing '=' after quoted key")
		mod.go#L220: 					return nil, fmt.Errorf("unexpected character after quoted key: %q", c)
		mod.go#L229: 					return nil, fmt.Errorf("build line missing '=' after key")
		mod.go#L232: 					return nil, fmt.Errorf("unquoted key %q must be quoted", key)
		mod.go#L243: 						return nil, fmt.Errorf("invalid quoted value in build line")
		mod.go#L249: 						return nil, fmt.Errorf("unquoted value %q must be quoted", value)

	runtime/pprof
		pprof.go#L781: 		return fmt.Errorf("cpu profiling already in use")
		proto.go#L276: 			return fmt.Errorf("truncated profile")
		proto.go#L279: 			return fmt.Errorf("malformed profile")
		proto.go#L308: 			return fmt.Errorf("truncated profile")
		proto.go#L311: 			return fmt.Errorf("malformed profile")
		proto.go#L314: 			return fmt.Errorf("mismatched profile records and tags")
		proto.go#L336: 		return fmt.Errorf("mismatched profile records and tags")

	testing
		benchmark.go#L55: 			return fmt.Errorf("invalid count")
		benchmark.go#L62: 		return fmt.Errorf("invalid duration")
		match.go#L120: 			return fmt.Errorf("element %d of %s (%q): %s", i, name, s, err)
		match.go#L138: 			return fmt.Errorf("alternation %d of %s", i, err)

	testing/iotest
		reader.go#L123: 		err = fmt.Errorf("Read(%d bytes at offset %d): %v", n, r.off, err)
		reader.go#L140: 			return fmt.Errorf("Read(0) = %d, %v, want 0, nil", n, err)
		reader.go#L149: 		return fmt.Errorf("ReadAll(small amounts) = %q\n\twant %q", data, content)
		reader.go#L153: 		return fmt.Errorf("Read(10) at EOF = %v, %v, want 0, EOF", n, err)
		reader.go#L159: 			return fmt.Errorf("Seek(0, 1) from EOF = %d, %v, want %d, nil", off, err, len(content))
		reader.go#L167: 				return fmt.Errorf("Seek(-1, 1) from EOF = %d, %v, want %d, nil", -off, err, len(content)-1)
		reader.go#L170: 				return fmt.Errorf("Seek(%d, 1) from %d = %d, %v, want %d, nil", -len(content)/3, len(content)-1, off, err, middle-1)
		reader.go#L173: 				return fmt.Errorf("Seek(+1, 1) from %d = %d, %v, want %d, nil", middle-1, off, err, middle)
		reader.go#L179: 			return fmt.Errorf("Seek(0, 1) from %d = %d, %v, want %d, nil", middle, off, err, middle)
		reader.go#L185: 			return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
		reader.go#L188: 			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
		reader.go#L193: 			return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
		reader.go#L196: 			return fmt.Errorf("Seek(%d, 2) from %d = %d, %v, want %d, nil", -len(content)/3, middle/2, off, err, middle)
		reader.go#L202: 			return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
		reader.go#L205: 			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
		reader.go#L210: 			return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
		reader.go#L214: 			return fmt.Errorf("ReadAll from offset %d: %v", middle/2, err)
		reader.go#L217: 			return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle/2, data, content[middle/2:])
		reader.go#L228: 			return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, nil or EOF", len(data), n, err, len(data))
		reader.go#L231: 			return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
		reader.go#L236: 			return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 0, EOF", len(data), n, err)
		reader.go#L244: 			return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, EOF", cap(data), n, err, len(data))
		reader.go#L247: 			return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
		reader.go#L260: 				return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 1, %s", i, n, err, want)
		reader.go#L263: 				return fmt.Errorf("ReadAt(1, %d) = %q want %q", i, data[i:i+1], content[i:i+1])

	text/template
		exec.go#L139: 		Err:  fmt.Errorf(format, args...),
		exec.go#L185: 		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
		funcs.go#L91: 			panic(fmt.Errorf("function name %q is not a valid identifier", name))
		funcs.go#L98: 			panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
		funcs.go#L161: 			return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
		funcs.go#L172: 	return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
		funcs.go#L194: 		return 0, fmt.Errorf("cannot index slice/array with nil")
		funcs.go#L196: 		return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
		funcs.go#L199: 		return 0, fmt.Errorf("index out of range: %d", x)
		funcs.go#L212: 		return reflect.Value{}, fmt.Errorf("index of untyped nil")
		funcs.go#L218: 			return reflect.Value{}, fmt.Errorf("index of nil pointer")
		funcs.go#L241: 			return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
		funcs.go#L256: 		return reflect.Value{}, fmt.Errorf("slice of untyped nil")
		funcs.go#L259: 		return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
		funcs.go#L265: 			return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
		funcs.go#L271: 		return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
		funcs.go#L284: 		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
		funcs.go#L291: 		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
		funcs.go#L302: 		return 0, fmt.Errorf("len of nil pointer")
		funcs.go#L308: 	return 0, fmt.Errorf("len of type %s", item.Type())
		funcs.go#L318: 		return reflect.Value{}, fmt.Errorf("call of nil")
		funcs.go#L322: 		return reflect.Value{}, fmt.Errorf("non-function of type %s", typ)
		funcs.go#L325: 		return reflect.Value{}, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
		funcs.go#L331: 			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
		funcs.go#L336: 			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
		funcs.go#L350: 			return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
		funcs.go#L364: 				err = fmt.Errorf("%v", r)
		funcs.go#L444: 			return false, fmt.Errorf("uncomparable type %s: %v", t1, arg1)
		funcs.go#L486: 						return false, fmt.Errorf("uncomparable type %s: %v", t2, arg)
		helper.go#L64: 		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
		helper.go#L128: 		return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
		helper.go#L158: 			return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)

	text/template/parse
		node.go#L639: 			return nil, fmt.Errorf("malformed character constant: %s", text)
		node.go#L695: 				return nil, fmt.Errorf("integer overflow: %q", text)
		node.go#L711: 		return nil, fmt.Errorf("illegal number syntax: %q", text)
		parse.go#L164: 	panic(fmt.Errorf(format, args...))

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

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

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

	vendor/golang.org/x/text/unicode/bidi
		core.go#L1016: 		return fmt.Errorf("types is null")
		core.go#L1020: 			return fmt.Errorf("B type before end of paragraph at index: %d", i)
		core.go#L1030: 		return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
		core.go#L1039: 			return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
		core.go#L1044: 		return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
		core.go#L1051: 		return fmt.Errorf("pairTypes is null")
		core.go#L1057: 			return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
		core.go#L1065: 		return fmt.Errorf("pairValues is null")
		core.go#L1068: 		return fmt.Errorf("pairTypes is different length from pairValues")

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

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)