*/
    private rpc() {
        // Utility class
    }

    /**
     * UUID (Universally Unique Identifier) structure for DCE/RPC.
     * Represents a 128-bit UUID as defined by DCE/RPC specification.
     */
    public static class uuid_t extends NdrObject {

        /**
         * Default constructor for uuid_t.
         */
        public uuid_t() {

        if ((this.server.scapabilities & SmbConstants.CAP_EXTENDED_SECURITY) == SmbConstants.CAP_EXTENDED_SECURITY) {
            this.capabilities |= SmbConstants.CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if (ctx.getConfig().isUseUnicode() || ctx.getConfig().isForceUnicode()) {
            this.capabilities |= SmbConstants.CAP_UNICODE;
        }

It can be used by third party applications and systems.

And it can also be used by yourself, to debug, check and test the same application.

## The `password` flow { #the-password-flow }

Now let's go back a bit and understand what is all that.

The `password` "flow" is one of the ways ("flows") defined in OAuth2, to handle security and authentication.

   * Reads an unsigned {@code short} as specified by {@link DataInputStream#readUnsignedShort()},
   * except using little-endian byte order.
   *
   * @return the next two bytes of the input stream, interpreted as an unsigned 16-bit integer in
   *     little-endian byte order
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip some bytes
  @Override
  public int readUnsignedShort() throws IOException {

form of wildcards `*.example.com` where the `*` must be first and doesn't match nested subdomains.

By default certificates use fast and secure 256-bit ECDSA keys. For interoperability with very old
clients use `HeldCertificate.Builder.rsa2048()`.

Download
--------

```kotlin
implementation("com.squareup.okhttp3:okhttp-tls:5.3.0")
```

        }
      }
    }
  }

  @GwtIncompatible // java.math.BigInteger
  public void testIsPowerOfTwo() {
    for (int x : ALL_INTEGER_CANDIDATES) {
      // Checks for a single bit set.
      BigInteger bigX = BigInteger.valueOf(x);
      boolean expected = (bigX.signum() > 0) && (bigX.bitCount() == 1);
      assertEquals(expected, IntMath.isPowerOfTwo(x));
    }
  }

 *
 * <p>Its speed is comparable to CityHash64, and its quality of hashing is at least as good.
 *
 * <p>Note to maintainers: This implementation relies on signed arithmetic being bit-wise equivalent
 * to unsigned arithmetic in all cases except:
 *
 * <ul>
 *   <li>comparisons (signed values can be negative)
 *   <li>division (avoided here)
 *   <li>shifting (right shift must be unsigned)
 * </ul>

        // Test various boundary values
        long[] testValues = { 0L, // Zero
                1L, // One
                -1L, // Negative one
                0x00000000FFFFFFFFL, // 32-bit max as long
                0xFFFFFFFF00000000L, // High 32 bits set
                0x7FFFFFFFFFFFFFFFL, // Long.MAX_VALUE
                0x8000000000000000L, // Long.MIN_VALUE

        assertEquals(testTime + negativeOffset, response.getLastAccessTime());
    }

    @Test
    void testMaximumFileSize() {
        // Test with maximum unsigned 32-bit file size
        // Note: fileSize is stored as signed int in SmbComQueryInformationResponse
        // 0xFFFFFFFF becomes -1 when interpreted as signed int
        response = new SmbComQueryInformationResponse(mockConfig, 0L);

     */
    private rpc() {
        // Utility class
    }

    /**
     * UUID (Universally Unique Identifier) structure for DCE/RPC.
     * Represents a 128-bit UUID as defined by DCE/RPC specification.
     */
    public static class uuid_t extends NdrObject {

        /**
         * Default constructor for uuid_t.
         */
        public uuid_t() {