* #create(Object...)}.
   */
  protected abstract List<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }

   * #create(Object...)}.
   */
  protected abstract List<Character> create(Character[] elements);

  @Override
  public Character[] createArray(int length) {
    return new Character[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Character> order(List<Character> insertionOrder) {
    return insertionOrder;
  }

   * #create(Object...)}.
   */
  protected abstract T create(UnhashableObject[] elements);

  @Override
  public UnhashableObject[] createArray(int length) {
    return new UnhashableObject[length];
  }

  @Override
  public Iterable<UnhashableObject> order(List<UnhashableObject> insertionOrder) {
    return insertionOrder;
  }

     */
    public HMACT64(final byte[] key) {
        super("HMACT64");
        final int length = Math.min(key.length, BLOCK_LENGTH);
        for (int i = 0; i < length; i++) {
            ipad[i] = (byte) (key[i] ^ IPAD);
            opad[i] = (byte) (key[i] ^ OPAD);
        }
        for (int i = length; i < BLOCK_LENGTH; i++) {
            ipad[i] = IPAD;
            opad[i] = OPAD;
        }
        try {

     */
    public HMACT64(final byte[] key) {
        super("HMACT64");
        final int length = Math.min(key.length, BLOCK_LENGTH);
        for (int i = 0; i < length; i++) {
            this.ipad[i] = (byte) (key[i] ^ IPAD);
            this.opad[i] = (byte) (key[i] ^ OPAD);
        }
        for (int i = length; i < BLOCK_LENGTH; i++) {
            this.ipad[i] = IPAD;
            this.opad[i] = OPAD;
        }

      // Split by line, then ensure each line can fit into Log's maximum length.
      var i = 0
      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)
        newline = if (newline != -1) newline else length
        do {
          val end = minOf(newline, i + MAX_LOG_LENGTH)

  private static long fingerprint(byte[] bytes) {
    return fingerprint(bytes, bytes.length);
  }

  /** Convenience method to compute a fingerprint on a subset of a byte array. */
  private static long fingerprint(byte[] bytes, int length) {
    return HASH_FN.hashBytes(bytes, 0, length).asLong();
  }

  /**

     * @param remoteAddress remote memory address
     * @param remoteKey remote memory key
     * @param length number of bytes to read
     * @throws IOException if read fails
     */
    public abstract void rdmaRead(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException;

    /**
     * Perform RDMA write operation
     *

            final byte[] lmResponse = getLMResponse();
            final int lmLength = lmResponse != null ? lmResponse.length : 0;
            final byte[] ntResponse = getNTResponse();
            final int ntLength = ntResponse != null ? ntResponse.length : 0;
            final byte[] sessionKey = getSessionKey();
            final int keyLength = sessionKey != null ? sessionKey.length : 0;

        byte[] domainBytes = null;
        if (domainName != null && domainName.length() != 0) {
            domainBytes = unicode ? domainName.getBytes(UNI_ENCODING) : domainName.getBytes(oemCp);
            size += domainBytes.length;
        }

        final String userName = getUser();
        byte[] userBytes = null;
        if (userName != null && userName.length() != 0) {