* returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.

    }

    public static String getFormattedDifference(DataSeries<Duration> baselineVersion, DataSeries<Duration> currentVersion) {
        Amount<Duration> base = baselineVersion.getMedian();
        Amount<Duration> current = currentVersion.getMedian();
        Amount<Duration> diff = current.minus(base);

        String sign = diff.getValue().doubleValue() > 0 ? "+" : "";

                .map((DataSeries<Duration> data) -> data.isEmpty() ? null : data)
                .collect(Collectors.toList());

            Amount<Duration> min = totalTimeMedianStream(experiments).min(Comparator.naturalOrder()).orElse(null);
            Amount<Duration> max = totalTimeMedianStream(experiments).max(Comparator.naturalOrder()).orElse(null);

            if (min != null && min.equals(max)) {

    }

    public static MemoryAmount of(String notation) {
        return new MemoryAmount(parseNotation(notation), notation);
    }

    /**
     * Parse memory amount notation.
     *
     * @return The parsed memory amount in bytes, {@literal -1} if the notation is {@literal null} or empty.
     * @throws IllegalArgumentException if the notation is invalid
     */

// The effective memory address is R or R+X depending on Index, Extend and Amount.
type MemExtend struct {
	Base   RegSP
	Index  Reg
	Extend ExtShift
	// Amount indicates the index shift amount (but also see ShiftMustBeZero field below).
	Amount uint8
	// Refer to ARM reference manual, for byte load/store(register), the index
	// shift amount must be 0, encoded in "S" as 0 if omitted, or as 1 if present.

        updateProgress();
    }

    @Override
    public void incrementSkipped() {
        incrementSkipped(1);
    }

    @Override
    public void incrementSkipped(long amount) {
        skipped += amount;
        updateProgress();
    }

    public long getDeleted() {
        return deleted;
    }

    private void updateProgress() {

	// ADD <Wd>, <Wn>, <Wm> {, <shift> #<amount> }
	{0xff208000, 0x0b000000, ADD, instArgs{arg_Wd, arg_Wn, arg_Wm_shift__LSL_0__LSR_1__ASR_2__0_31}, nil},
	// ADD <Xd>, <Xn>, <Xm> {, <shift> #<amount> }
	{0xff200000, 0x8b000000, ADD, instArgs{arg_Xd, arg_Xn, arg_Xm_shift__LSL_0__LSR_1__ASR_2__0_63}, nil},
	// CMN <Wn|WSP>, <Wm>{, <extend> {#<amount>}}

//     a W register encoded in Rm with an extend encoded in option[15:13] and an amount
//     encoded in imm3[12:10] in the range [0,4].
//
// - arg_Rm_extend__UXTB_0__UXTH_1__UXTW_2__LSL_UXTX_3__SXTB_4__SXTH_5__SXTW_6__SXTX_7__0_4:
//     a W or X register encoded in Rm with an extend encoded in option[15:13] and an
//     amount encoded in imm3[12:10] in the range [0,4]. If the extend is UXTX or SXTX,

/**
 * Memory holder.
 */
public interface MemoryHolder {

    /**
     * Attempt to release system memory.
     *
     * @param memoryAmountBytes The amount of system memory to release.
     * @return The amount of released system memory
     * @throws IllegalArgumentException if memoryAmountBytes is negative
     */
    long attemptToRelease(long memoryAmountBytes) throws IllegalArgumentException;

    void incrementSkipped();

    void incrementSkipped(long amount);

    CleanupProgressMonitor NO_OP = new CleanupProgressMonitor() {
        @Override
        public void incrementDeleted() {
        }

        @Override
        public void incrementSkipped() {
        }

        @Override
        public void incrementSkipped(long amount) {
        }
    };