* @throws NullPointerException if {@code listener} is null
     */
    void registerListener(@Nonnull Listener listener);

    /**
     * Unregisters a previously registered listener.
     *
     * @param listener the listener to unregister
     * @throws NullPointerException if {@code listener} is null
     */
    void unregisterListener(@Nonnull Listener listener);

    /**

    return Iterables.removeIf(
        multimap.unfiltered().entries(),
        and(multimap.entryPredicate(), valuePredicateOnEntries(not(in(c)))));
  }

  @Override
  public void clear() {
    multimap.clear();
  }

   *     call to {@link #next()} and this implementation does not support this sequence of calls
   *     (optional)
   */
  @Override
  void remove();

 */
@NullUnmarked
public class ComparatorDelegationOverheadBenchmark {
  private final Integer[][] inputArrays = new Integer[0x100][];

  @Param({"10000"})
  int n;

  @BeforeExperiment
  void setUp() throws Exception {
    Random rng = new Random();
    for (int i = 0; i < 0x100; i++) {
      Integer[] array = new Integer[n];
      for (int j = 0; j < n; j++) {
        array[j] = rng.nextInt();
      }

  private static final double[] positiveDoubles = new double[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      doubleInIntRange[i] = randomDouble(Integer.SIZE - 2);
      doubleInLongRange[i] = randomDouble(Long.SIZE - 2);
      positiveDoubles[i] = randomPositiveDouble();

        }
    }

    /**
     * Resets the {@link InputStream}.
     *
     * @param is the input stream (must not be {@literal null})
     * @see InputStream#reset()
     */
    public static void reset(final InputStream is) {
        assertArgumentNotNull("is", is);

        try {
            is.reset();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }

    /** The cache key for this referral */
    String key = null;

    /**
     * Constructs a new DfsReferral instance
     */
    public DfsReferral() {
        this.next = this;
    }

    void append(final DfsReferral dr) {
        dr.next = next;
        next = dr;
    }

    @Override
    public String toString() {

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;
    }

    @Override
    public synchronized void close() throws IOException {
        if (this.opened) {
            this.opened = false;
            final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
            this.handle.sendrecv(rpc);

        return new Smb2FlushResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.RequestWithFileId#setFileId(byte[])
     */
    @Override
    public void setFileId(final byte[] fileId) {
        this.fileId = fileId;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override

 * SystemPropertyProfileActivator
 */
@Deprecated
public class SystemPropertyProfileActivator extends DetectedProfileActivator implements Contextualizable {
    private Properties properties;

    @Override
    public void contextualize(Context context) throws ContextException {
        properties = (Properties) context.get("SystemProperties");
    }

    @Override
    protected boolean canDetectActivation(Profile profile) {