* @param clientChallenge the client challenge bytes
     * @param nanos1601 the timestamp in nanoseconds since 1601
     * @param avPairs the AV pairs from the Type 2 message
     * @return the calculated response
     */
    public static byte[] getNTLMv2Response(final byte[] responseKeyNT, final byte[] serverChallenge, final byte[] clientChallenge,
            final long nanos1601, final byte[] avPairs) {

						for idx, sh := range parityData {
							calculated := splitData[idx]
							if !bytes.Equal(calculated, sh) {
								off := 0
								for i, v := range sh {
									if v != calculated[i] {
										off = i
										break
									}
								}
								calculated := calculated[off:]
								inFile := sh[off:]
								extra := ""
								if len(calculated) != len(inFile) {

      return LinearTransformation.vertical(xStats.mean());
    }
  }

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> This tests exact equality of the calculated statistics, including the floating
   * point values. Two instances are guaranteed to be considered equal if one is copied from the
   * other using {@code second = new PairedStatsAccumulator().addAll(first).snapshot()}, if both

     */
    public void setMic(final byte[] mic) {
        this.mic = mic;
    }

    /**
     * Checks whether a message integrity code (MIC) should be calculated for this message.
     *
     * @return whether a MIC should be calculated
     */
    public boolean isMICRequired() {
        return this.micRequired;
    }

    @Override
    public byte[] toByteArray() throws IOException {

            return; /* CRITICAL */
        }
        this.digest.update(input, offset, len);
        this.updates++;
    }

    /**
     * Finalize and return the calculated message digest
     *
     * @return calculated digest
     */
    public byte[] digest() {
        byte[] b = this.digest.digest();

        if (log.isTraceEnabled()) {
            log.trace("digest: ");

    /**
     * Specifies a single quantile index to be calculated, i.e. the k in the kth q-quantile.
     *
     * @param index the quantile index, which must be in the inclusive range [0, q] for q-quantiles
     */
    public ScaleAndIndex index(int index) {
      return new ScaleAndIndex(scale, index);
    }

    /**
     * Specifies multiple quantile indexes to be calculated, each index being the k in the kth
     * q-quantile.

        // Expected result calculated manually for HMACT64 with this key and data
        HMACT64 hmac = new HMACT64(key);
        hmac.engineUpdate(data, 0, data.length);
        byte[] result = hmac.engineDigest();

        // Verify it produces a valid MD5 hash (16 bytes)
        assertNotNull(result);
        assertEquals(16, result.length);

        // Calculate the same using manual HMACT64 algorithm

    }

    /**
     * Calculates the LMv2 response for NTLM authentication.
     *
     * @param type2 the Type-2 message containing the server challenge
     * @param domain the domain name
     * @param user the username
     * @param password the user's password
     * @param clientChallenge the client challenge bytes
     * @return the calculated LMv2 response
     */

        }
    }

    @Test
    @DisplayName("Test maxOutputResponse calculation with transaction buffer size")
    void testMaxOutputResponseCalculation() {
        // Test that maxOutputResponse is properly calculated from transaction buffer size
        when(mockConfig.getTransactionBufferSize()).thenReturn(8192);

        Smb2IoctlRequest request = new Smb2IoctlRequest(mockConfig, TEST_CONTROL_CODE);

            throw exception;
        }
    }

    /**
     * Calculates the limit document number based on total, percentage, and number.
     * @param total The total number of documents.
     * @param limitPercentage The limit percentage.
     * @param limitNumber The limit number.
     * @return The calculated limit document number.
     */