call:convertxm %FESS_MIN_MEM% JVM_XMS
call:convertxm %FESS_MAX_MEM% JVM_XMX

CALL "%FESS_HOME%\bin\fess.in.bat"

rem thread stack size
set JVM_SS=256

        if (LogStream.level >= 5) {
            log.println("update: " + updates + " " + offset + ":" + len);
            Hexdump.hexdump(log, input, offset, Math.min(len, 256));
            log.flush();
        }
        if (len == 0) {
            return; /* CRITICAL */
        }
        digest.update(input, offset, len);
        updates++;
    }

    /**

  }

  @GwtIncompatible // Chars.fromByteArray, Chars.toByteArray
  public void testByteArrayRoundTrips() {
    char c = 0;
    for (int hi = 0; hi < 256; hi++) {
      for (int lo = 0; lo < 256; lo++) {
        char result = Chars.fromByteArray(new byte[] {(byte) hi, (byte) lo});
        assertWithMessage(
                String.format(
                    Locale.ROOT,

        byte[] buffer = new byte[34]; // 10 offset + 16 header + 8 data
        int bufferIndex = offset;

        // Set up test values
        int namedPipeState = 0x02;
        int readDataAvailable = 256;
        int numberOfMessages = 5;
        int messageLength = 128;
        byte[] testData = { (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC, (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88 };

            outputBufferLengthField.setAccessible(true);
            outputBufferLengthField.set(request, 0x8000);

            // Create a buffer and write
            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 64);

            // Verify structure size (should be 41)
            assertEquals(41, SMBUtil.readInt2(buffer, 64));

        assertEquals(2048, result.length()); // 1024 bytes * 2 chars

        // Test partial conversion
        String partial = Hexdump.toHexString(data, 512, 256);
        assertEquals(512, partial.length()); // 256 bytes * 2 chars
        assertTrue(partial.startsWith("00010203")); // 512 % 256 = 0, so starts at 0
    }

        case 23:
            ms_usage = 13;
        }
        return ms_usage;
    }

    /**
     * Calculates a MAC using HMAC-SHA1 with AES key derivation.
     * This method supports both AES-128 and AES-256 encryption types.
     *
     * @param usage the Kerberos key usage number for this operation
     * @param baseKey the base Kerberos key for key derivation
     * @param input the data to calculate the MAC for

   *  * A misdirected request (HTTP 421) on a coalesced connection.
   */
  open fun isOneShot(): Boolean = false

  /**
   * Returns the SHA-256 hash of this [RequestBody]
   */
  @Throws(IOException::class)
  fun sha256(): ByteString {
    val hashingSink = HashingSink.sha256(blackholeSink())
    hashingSink.buffer().use {
      this.writeTo(it)
    }

            getHeaderStartMethod.setAccessible(true);

            // Create a buffer and write
            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 64);

            // Verify structure size (should be 33)
            assertEquals(33, SMBUtil.readInt2(buffer, 64));

          .put("SHA1", Hashing.sha1()) // Not the official name, but still works
          .put("sHa-1", Hashing.sha1()) // Not the official name, but still works
          .put("SHA-1", Hashing.sha1())
          .put("SHA-256", Hashing.sha256())
          .put("SHA-384", Hashing.sha384())
          .put("SHA-512", Hashing.sha512())
          .build();

  public void testHashing() {
    for (String stringToTest : INPUTS) {