long id = 0;
            String line = null;
            while ((line = reader.readLine()) != null) {
                // Remove comments
                final String replacedLine = line.replaceAll("#.*$", StringUtil.EMPTY).trim();

                // Skip empty lines or comment lines
                if (replacedLine.length() == 0) {

            final String[] parts = line.split("=", 2);
            final String key = parts[0];
            // remove optional leading and trailing quotes and whitespace
            final String value = parts[1].replaceAll("^['\"]?\\s*", "").replaceAll("\\s*['\"]?$", "");

            values.put(key, value.toLowerCase());
        });

    - [Dependencies](#dependencies-7)
      - [Changed](#changed-7)
      - [Unchanged](#unchanged)
      - [Removed](#removed-7)
      - [Detailed go Dependency Changes](#detailed-go-dependency-changes)
        - [Added](#added-7)
        - [Changed](#changed-8)
        - [Removed](#removed-8)
- [v1.16.0-rc.2](#v1160-rc2)
  - [Downloads for v1.16.0-rc.2](#downloads-for-v1160-rc2)

     * implementation, because {@code map.get()} returns a view collection that changes in the
     * course of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code
     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      Map<String, Map<Integer, Character>> map;

     * implementation, because {@code map.get()} returns a view collection that changes in the
     * course of a call to {@code remove()}. Thus, the expectation doesn't hold that {@code
     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      Map<String, Map<Integer, Character>> map;

      NavigableSet<E> navigableSet) {
    return Synchronized.navigableSet(navigableSet);
  }

  /** Remove each element in an iterable from a set. */
  static boolean removeAllImpl(Set<?> set, Iterator<?> iterator) {
    boolean changed = false;
    while (iterator.hasNext()) {
      changed |= set.remove(iterator.next());
    }
    return changed;
  }

	}
}

var (
	errDecommissionAlreadyRunning = errors.New("decommission is already in progress")
	errDecommissionComplete       = errors.New("decommission is complete, please remove the servers from command-line")
	errDecommissionNotStarted     = errors.New("decommission is not in progress")
)

func (p *poolMeta) Decommission(idx int, pi poolSpaceInfo) error {

  /**
   * Removes the mapping, if any, associated with the given keys.
   *
   * @param rowKey row key of mapping to be removed
   * @param columnKey column key of mapping to be removed
   * @return the value previously associated with the keys, or {@code null} if no such value existed
   */
  @CanIgnoreReturnValue
  @Nullable V remove(
      @CompatibleWith("R") @Nullable Object rowKey,

    public Integer getTimeToLive() {
        String value = getHandlerParameterMap().get("time_to_live");
        if (StringUtil.isBlank(value)) {
            value = getHandlerParameterMap().get("timeToLive"); // TODO remove
            if (StringUtil.isBlank(value)) {
                return null;
            }
            logger.warn("timeToLive is deprecated. Please use time_to_live.");
        }
        try {

                        .addException(
                                new Exception("Build failed due to log statements with a higher severity than allowed. "
                                        + "Fix the logged issues or remove flag --fail-on-severity (-fos)."));
            }

            logResult(event.getSession());

            logStats(event.getSession());

            infoLine('-');
        }
    }