*
   * @return the count of {@code element} in the multiset before this call
   * @throws IllegalArgumentException if {@code count} is negative
   */
  @CanIgnoreReturnValue
  @Override
  public int setCount(E element, int count) {
    checkNotNull(element);
    checkNonnegative(count, "count");
    while (true) {
      AtomicInteger existingCounter = safeGet(countMap, element);
      if (existingCounter == null) {

   *
   * @return the count of {@code element} in the multiset before this call
   * @throws IllegalArgumentException if {@code count} is negative
   */
  @CanIgnoreReturnValue
  @Override
  public int setCount(E element, int count) {
    checkNotNull(element);
    checkNonnegative(count, "count");
    while (true) {
      AtomicInteger existingCounter = safeGet(countMap, element);
      if (existingCounter == null) {

     * Even if empty string, treated as empty plainly. So "IF pmb != null" is false if empty.
     * @param count The parameter value of count. (NotNull)
     */
    public void setCount(String count) {
        registerVariable("count", count);
    }

    /**
     * Set the value of interval, used in parameter comment. <br>

    }

    frequency.add(-numberRemoved);
    size -= numberRemoved;
    return oldCount;
  }

  // Roughly a 33% performance improvement over AbstractMultiset.setCount().
  @CanIgnoreReturnValue
  @Override
  public int setCount(@ParametricNullness E element, int count) {
    checkNonnegative(count, "count");

    Count existingCounter;
    int oldCount;
    if (count == 0) {

   *     zero instead.
   */
  @CanIgnoreReturnValue
  int setCount(@ParametricNullness E element, int count);

  /**
   * Conditionally sets the count of an element to a new value, as described in {@link
   * #setCount(Object, int)}, provided that the element has the expected current count. If the
   * current count is not {@code oldCount}, no change is made.
   *

   *     zero instead.
   */
  @CanIgnoreReturnValue
  int setCount(@ParametricNullness E element, int count);

  /**
   * Conditionally sets the count of an element to a new value, as described in {@link
   * #setCount(Object, int)}, provided that the element has the expected current count. If the
   * current count is not {@code oldCount}, no change is made.
   *

     *
     * @return the count of {@code element} in the multiset before this call
     * @throws IllegalArgumentException if {@code count} is negative
     */
    @Override
    public int setCount(E element, int count) {
      checkNonnegative(count, "count");
      return (count == 0) ? removeAllOccurrences(element) : unbox(countMap.put(element, count));
    }

    /**

			return nil
		}, index)
	}

	errs := g.Wait()

	// Initialize heal result info
	res = madmin.HealResultItem{
		Type:      madmin.HealItemBucket,
		Bucket:    bucket,
		DiskCount: len(localDrives),
		SetCount:  -1, // explicitly set an invalid value -1, for bucket heal scenario
	}

	// mutate only if not a dry-run
	if opts.DryRun {
		return res, nil
	}

	for i := range beforeState {

                        postcard.dryrun();
                    }
                    postcard.setHostname(systemHelper.getHostname());
                    postcard.setLevel(level);
                    postcard.setCount(String.valueOf(levelEvents.size()));
                    postcard.setInterval(String.valueOf(fessConfig.getLogNotificationIntervalAsInteger()));
                    postcard.setDetails(details);
                });

  }

  void expectSetCountFailure(SortedMultiset<E> multiset, Entry<E> entry) {
    try {
      multiset.setCount(entry.getElement(), multiset.count(entry.getElement()));
    } catch (IllegalArgumentException acceptable) {
    }
    try {
      multiset.setCount(entry.getElement(), multiset.count(entry.getElement()) + 1);
      fail("Expected IllegalArgumentException");