req.Trailer.Set("x-amz-checksum-crc32", "rK0DXg==")

	now := UTCNow()

	req = signer.StreamingUnsignedV4(req, "", 8, now)

	maliciousHeaders := http.Header{
		"Authorization":                []string{fmt.Sprintf("AWS4-HMAC-SHA256 Credential=%s/%s/us-east-1/s3/aws4_request, SignedHeaders=invalidheader, Signature=deadbeefdeadbeefdeadbeeddeadbeeddeadbeefdeadbeefdeadbeefdeadbeef", s.accessKey, now.Format(yyyymmdd))},

                    request.setFileId(handle.directoryFile.getFileId());
                    request.setCompletionFilter(getNotificationFilter());
                    request.setWatchTree(false);  // Non-recursive for now
                    
                    Smb2ChangeNotifyResponse response = (Smb2ChangeNotifyResponse) 
                        handle.directoryFile.getTree().send(request);
                    

	KMOVQ K7, (R10)       // c4c1f8913a
	KMOVQ K5, AX          // c4e1fb93c5
	KMOVQ K7, R10         // c461fb93d7
	KNOTB K7, K0          // c5f944c7
	KNOTB K1, K5          // c5f944e9
	KNOTW K7, K0          // c5f844c7
	KNOTW K1, K5          // c5f844e9
	KNOTD K7, K0          // c4e1f944c7
	KNOTD K1, K5          // c4e1f944e9
	KNOTQ K7, K0          // c4e1f844c7
	KNOTQ K1, K5          // c4e1f844e9

   *     instead.
   */
  @InlineMe(replacement = "this.matches(character)")
  @Deprecated
  @Override
  // We can't compatibly make this `final` now.
  @InlineMeValidationDisabled(
      "While apply() is not final, the inlining is still safe because all known overrides of"
          + " apply() call matches().")
  public boolean apply(Character character) {
    return matches(character);
  }

  /**

  private static <K, V> int countLiveEntries(LocalCache<K, V> map, long now) {
    int result = 0;
    for (Segment<K, V> segment : map.segments) {
      AtomicReferenceArray<ReferenceEntry<K, V>> table = segment.table;
      for (int i = 0; i < table.length(); i++) {
        for (ReferenceEntry<K, V> e = table.get(i); e != null; e = e.getNext()) {
          if (map.isLive(e, now)) {
            result++;
          }
        }

		if e != nil {
			return n, e
		}
		// all bytes should have been written, by definition of
		// Write method in io.Writer
		if m != nBytes {
			return n, io.ErrShortWrite
		}
	}
	// Buffer is now empty; reset.
	b.Reset()
	return n, nil
}

// WriteByte appends the byte c to the buffer, growing the buffer as needed.
// The returned error is always nil, but is included to match [bufio.Writer]'s

		IsLatest:         true,
		Deleted:          false,
		TransitionStatus: "PENDING",
		DataDir:          "bffea160-ca7f-465f-98bc-9b4f1c3ba1ef",
		XLV1:             false,
		ModTime:          time.Now(),
		Size:             1234456,
		Mode:             0,
		Metadata: map[string]string{
			xhttp.AmzRestore:                 "FAILED",
			xhttp.ContentMD5:                 mustGetUUID(),

# Persistent Handles Feature - Detailed Design Document

## 1. Overview

Persistent handles (also known as durable handles) allow SMB3 connections to survive network disconnections, server reboots, and client reconnections. This feature is critical for enterprise reliability and seamless failover scenarios.

## 2. Protocol Specification Reference

- **MS-SMB2 Section 2.2.13.2.3**: SMB2_CREATE_DURABLE_HANDLE_REQUEST

  }

  /**
   * Compares the two specified {@code int} values, treating them as unsigned values between {@code
   * 0} and {@code 2^32 - 1} inclusive.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use the
   * equivalent {@link Integer#compareUnsigned(int, int)} method instead.
   *
   * @param a the first unsigned {@code int} to compare

  }

  /**
   * Compares the two specified {@code char} values. The sign of the value returned is the same as
   * that of {@code ((Character) a).compareTo(b)}.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use the
   * equivalent {@link Character#compare} method instead.
   *
   * @param a the first {@code char} to compare
   * @param b the second {@code char} to compare