if (logger.isDebugEnabled()) {
                logger.debug("Failed to put {}:{}", key, value, e);
            }
        }
    }

    /**
     * Decodes MIME-encoded text.
     *
     * @param value the encoded text to decode
     * @return the decoded text or empty string if decoding fails
     */
    protected String getDecodeText(final String value) {
        if (value == null) {

    // Base64 encoded Type 1 message: NTLMSSP, Type 1, flags=0x00088207
    // Domain="DOMAIN", Workstation="WORKSTATION"
    private final String type1MessageBase64 = "TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABET01BSU5XT1JLU1RBVElPTg==";

    // Base64 encoded Type 3 message: NTLMSSP, Type 3
    // User: "user", Domain: "DOMAIN", Workstation: "WORKSTATION"

	return signature
}

// compareSignatureV2 returns true if and only if both signatures
// are equal. The signatures are expected to be base64 encoded strings
// according to the AWS S3 signature V2 spec.
func compareSignatureV2(sig1, sig2 string) bool {
	// Decode signature string to binary byte-sequence representation is required
	// as Base64 encoding of a value is not unique:

// ScanRunes is a split function for a [Scanner] that returns each
// UTF-8-encoded rune as a token. The sequence of runes returned is
// equivalent to that from a range loop over the input as a string, which
// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
// Because of the Scan interface, this makes it impossible for the client to
// distinguish correctly encoded replacement runes from encoding errors.

  public val bodySize: Long,
  /**
   * The sizes of the chunks of this request's body, or null if the request's body was not encoded
   * with chunked encoding.
   */
  public val chunkSizes: List<Int>?,
  /**
   * The failure MockWebServer recorded when attempting to decode this request. If, for example,
   * the inbound request was truncated, this exception will be non-null.
   */

        int avPairsLength = avPairs.length;
        byte[] blob = new byte[28 + avPairsLength + 4];
        Encdec.enc_uint32le(0x00000101, blob, 0); // Header
        Encdec.enc_uint32le(0x00000000, blob, 4); // Reserved
        Encdec.enc_uint64le(nanos1601, blob, 8);
        System.arraycopy(clientChallenge, 0, blob, 16, 8);
        Encdec.enc_uint32le(0x00000000, blob, 24); // Unknown

 * an existing external tool is required.
 *
 * See https://stackoverflow.com/questions/61929216/how-to-log-tlsv1-3-keys-in-jsse-for-wireshark-to-decode-traffic
 *
 * Steps to run in your own code
 *
 * 1. In your main method `WireSharkListenerFactory.register()`
 * 2. Create Listener factory `val eventListenerFactory = WireSharkListenerFactory(
logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`

     */
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**

  }

  /**
   * Creates a {@code HashCode} from a hexadecimal ({@code base 16}) encoded string. The string must
   * be at least 2 characters long, and contain only valid, lower-cased hexadecimal characters.
   *
   * <p>This method accepts the exact format generated by {@link #toString}. If you require more
   * lenient {@code base 16} decoding, please use {@link com.google.common.io.BaseEncoding#decode}

                new RequestParameter("lang", new String[] { "en", "ja" }) };
        String encoded = searchHelper.serializeParameters(params);
        assertNotNull(encoded);
        byte[] compressed = Base64.getUrlDecoder().decode(encoded);
        byte[] jsonBytes = searchHelper.gzipDecompress(compressed);
        String json = new String(jsonBytes);
        assertTrue(json.contains("q"));