* Constructs a PAC logon information object from raw PAC data.
     * @param data the raw PAC logon info buffer data
     * @throws PACDecodingException if the data is malformed or invalid
     */
    public PacLogonInfo(final byte[] data) throws PACDecodingException {
        try {
            final PacDataInputStream pacStream = new PacDataInputStream(new DataInputStream(new ByteArrayInputStream(data)));

            // Skip firsts

   * [trailers], this doesn't block if the trailers are not immediately available, and instead
   * returns null.
   *
   * This will typically return null until [ResponseBody.source] has buffered the last byte of the
   * response body. Call `body.source().request(1024 * 1024)` to block until either that's done, or
   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values

	for i, format := range formats {
		if format == nil {
			continue
		}
		h := sha256.New()
		for _, set := range format.Erasure.Sets {
			for _, diskID := range set {
				h.Write([]byte(diskID))
			}
		}
		formatHashes[i] = hex.EncodeToString(h.Sum(nil))
	}

	formatCountMap := make(map[string]int)
	for _, hash := range formatHashes {
		if hash == "" {
			continue
		}

   * time it is closed. In such calls [byteCount] is the number of bytes returned to the
   * application. This may be smaller than the resource's byte count if were read to completion.
   *
   * This method is always invoked after [responseBodyStart].
   */
  open fun responseBodyEnd(
    call: Call,
    byteCount: Long,
  ) {
  }

  /**

        if (msg != null && (msg.startsWith("NTLM ") || offerBasic && msg.startsWith("Basic "))) {
            if (msg.startsWith("NTLM ")) {
                final HttpSession ssn = req.getSession();
                byte[] challenge;

                if (this.loadBalance) {
                    NtlmChallenge chal = (NtlmChallenge) ssn.getAttribute("NtlmHttpChal");
                    if (chal == null) {

            .buildKeepingLast();
    assertMapEquals(map, key1, 3, key2, 4);
  }

  // The java7 branch has different code depending on whether the entry indexes fit in a byte,
  // short, or int. The small table in testBuildKeepingLast_allowsOverwrite will test the byte
  // case. This method tests the short case.
  public void testBuildKeepingLast_shortTable() {
    Builder<Integer, String> builder = ImmutableMap.builder();

    clientReader.processNextFrame()
    callback.assertClosing(1005, "")
  }

  @Test fun closeLengthOfOneThrows() {
    data.write("880100".decodeHex()) // Close with invalid 1-byte payload
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Malformed close payload length of 1.")
    }

```
Package: jcifs.internal.smb2.lease
├── Smb2LeaseBreak.java          - Lease break notification handling
├── Smb2LeaseContext.java        - Lease context for create requests
├── Smb2LeaseKey.java            - 16-byte lease key management
├── Smb2LeaseState.java          - Lease state flags (R, H, W)
└── LeaseManager.java            - Central lease management
```

#### 1.2 Implementation Tasks

		go p.AddMRFWorker()
	}
	for p.mrfWorkerSize > n {
		p.mrfWorkerSize--
		go func() { p.mrfWorkerKillCh <- struct{}{} }()
	}
}

const (
	minLargeObjSize = 128 * humanize.MiByte // 128MiB
)

// getWorkerCh gets a worker channel deterministically based on bucket and object names.
// Must be able to grab read lock from p.

pkg database/sql, method (NullByte) Value() (driver.Value, error)
pkg database/sql, method (NullInt16) Value() (driver.Value, error)
pkg database/sql, type NullByte struct
pkg database/sql, type NullByte struct, Byte uint8
pkg database/sql, type NullByte struct, Valid bool
pkg database/sql, type NullInt16 struct
pkg database/sql, type NullInt16 struct, Int16 int16
pkg database/sql, type NullInt16 struct, Valid bool