extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

    Optional<@NonNull T> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);

        synchronized (PROTOCOL_HANDLERS) {
            if (Handler.factory != null) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();
            Handler.factory = factory;
        }
    }

    /**
     * Constructs a handler with the specified CIFS context.
     *
     * @param tc context to use
     */

                System.out.flush();
            }
        } catch (IOException e) {
            // If jvm.config exists but can't be read, this is a configuration error
            // Print clear error and exit with error code to prevent Maven from running
            System.err.println("ERROR: Failed to read .mvn/jvm.config: " + e.getMessage());
            System.err.println("Please check file permissions and syntax.");

                                        List<Object> originalValues = new ArrayList<>(c);
                                        try {
                                            c.clear();
                                        } catch (UnsupportedOperationException e) {
                                            if (debugEnabled && logger != null) {

  public NavigableSet<E> elementSet() {
    return delegate().elementSet();
  }

  /**
   * A sensible implementation of {@link SortedMultiset#elementSet} in terms of the following
   * methods: {@link SortedMultiset#clear}, {@link SortedMultiset#comparator}, {@link
   * SortedMultiset#contains}, {@link SortedMultiset#containsAll}, {@link SortedMultiset#count},
   * {@link SortedMultiset#firstEntry} {@link SortedMultiset#headMultiset}, {@link

        // been closed since this read began we must discard the incoming data and tell the
        // connection we've done so.
        withLock {
          if (closed) {
            receiveBuffer.clear()
          } else {
            val wasEmpty = readBuffer.size == 0L
            readBuffer.writeAll(receiveBuffer)
            if (wasEmpty) {
              notifyAll()
            }
          }
        }

  }

  /**
   * Atomically removes all of the elements from this queue. The queue will be empty after this call
   * returns.
   */
  @Override
  public void clear() {
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      q.clear();
    } finally {
      monitor.leave();
    }
  }

  /**
   * Returns an iterator over the elements in this queue. The iterator does not return the elements

    /**
     * Clears a scroll context.
     *
     * @param scrollId The scroll ID to clear.
     */
    public void clearScroll(final String scrollId) {
        if (scrollId != null) {
            prepareClearScroll().addScrollId(scrollId)
                    .execute(ActionListener.wrap(res -> {}, e -> logger.warn("Failed to clear scroll context: scrollId={}", scrollId, e)));
        }
    }

    /**

            }
          }
          for (int i = 0; i < table.length(); ++i) {
            table.set(i, null);
          }
          clearReferenceQueues();
          writeQueue.clear();
          accessQueue.clear();
          readCount.set(0);

          ++modCount;
          count = 0; // write-volatile
        } finally {
          unlock();
          postWriteCleanup();
        }

                // Force disconnection
                this.connectionState.set(0);
                this.tid = -1;

                // Clear any cached resources
                // Note: Most fields in SmbTreeImpl are final or managed differently

                // Clear session reference if mutable
                // Note: session field may be final, cannot be nulled
            }
        } catch (Exception e) {