byte[] buf = new byte[outlen];
        int carry = 0;
        for (int i = lcm - 1; i >= 0; i--) {
            carry = carry_add(data, buf, carry, i);
        }

        if (carry != 0) {
            for (int i = outlen - 1; i >= 0; i--) {
                carry += buf[i] & 0xff;
                buf[i] = (byte) (carry & 0xff);
                carry >>>= 8;
            }
        }
        return buf;

 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being
 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any
 * number of streams, dynamically configured with `SETTINGS_MAX_CONCURRENT_STREAMS`. A connection

      For new upload configuration, which new counters will be collected, what
      do they measure, and why is it important to collect them?
      Note that uploaded data must not carry sensitive user information.
      See [go.dev/doc/telemetry#proposals](https://go.dev/doc/telemetry#proposals)
      for more details on telemetry proposals.
  validations:
    required: true
- type: input
  attributes:

 * <ul>
 *   <li>User and system properties for interpolation</li>
 *   <li>Session start time information</li>
 *   <li>Project directory structures</li>
 * </ul>
 *
 * <p>Requests can optionally carry trace information through {@link RequestTrace} to support:
 * <ul>
 *   <li>Debugging and troubleshooting of request flows</li>
 *   <li>Audit logging of operations</li>
 *   <li>Performance monitoring of nested operations</li>

    * the server.
    */
    int NTLMSSP_REQUEST_TARGET = 0x00000004;

    /**
    * Specifies that communication across the authenticated channel
    * should carry a digital signature (message integrity).
    */
    int NTLMSSP_NEGOTIATE_SIGN = 0x00000010;

    /**
    * Specifies that communication across the authenticated channel
    * should be encrypted (message confidentiality).

     * the server.
     */
    int NTLMSSP_REQUEST_TARGET = 0x00000004;

    /**
     * Specifies that communication across the authenticated channel
     * should carry a digital signature (message integrity).
     */
    int NTLMSSP_NEGOTIATE_SIGN = 0x00000010;

    /**
     * Specifies that communication across the authenticated channel

// getting cached statements, setting cached statements, and deleting cached statements.
type Store interface {
	// New creates a new Stmt object and caches it.
	// Parameters:
	//   ctx: The context for the request, which can carry deadlines, cancellation signals, etc.
	//   key: The key representing the SQL query, used for caching and preparing the statement.

 * needed, use {@code supplier::get}.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/FunctionalExplained">the use of {@code Function}</a>.
 *
 * @author Harry Heymann
 * @since 2.0
 */
@GwtCompatible
@FunctionalInterface
public interface Supplier<T extends @Nullable Object> extends java.util.function.Supplier<T> {
  /**

 * java.util.function.Supplier}, making conversion code necessary only in one direction. At that
 * time, this interface will be officially discouraged.
 *
 * @author Harry Heymann
 * @since 2.0
 */
@GwtCompatible
public interface Supplier<T extends @Nullable Object> {
  /**
   * Retrieves an instance of the appropriate type. The returned object may or may not be a new

func (e stsErrorCodeMap) ToSTSErr(errCode STSErrorCode) STSError {
	apiErr, ok := e[errCode]
	if !ok {
		return e[ErrSTSInternalError]
	}
	return apiErr
}

// error code to STSError structure, these fields carry respective
// descriptions for all the error responses.
var stsErrCodes = stsErrorCodeMap{
	ErrSTSAccessDenied: {
		Code:           "AccessDenied",