--edgeCount;
    }
    if (isDirected()) { // In undirected graphs, the successor and predecessor sets are equal.
      // Since views are returned, we need to copy the predecessors that will be removed.
      // Thus we avoid modifying the underlying view while iterating over it.
      for (N predecessor : ImmutableList.copyOf(connections.predecessors())) {
        // requireNonNull is safe because the node is a predecessor.

      return false;
    }

    // Since views are returned, we need to copy the edges that will be removed.
    // Thus we avoid modifying the underlying view while iterating over it.
    for (E edge : ImmutableList.copyOf(connections.incidentEdges())) {
      removeEdge(edge);
    }
    nodeConnections.remove(node);
    return true;
  }

  @Override
  @CanIgnoreReturnValue

    assertTrue("Could not remove larry", mmHeap.remove("larry"));
    assertEquals(6, mmHeap.size());
    assertFalse("heap contains larry which has been removed", mmHeap.contains("larry"));
    assertTrue("heap does not contain sergey", mmHeap.contains("sergey"));
    assertTrue("Could not remove larry", mmHeap.removeAll(Lists.newArrayList("sergey", "eric")));

    }

    @Override
    public boolean remove(@Nullable Object o) {
      try {
        return super.remove(o);
      } catch (UnsupportedOperationException e) {
        for (Entry<K, V> entry : map().entrySet()) {
          if (Objects.equals(o, entry.getValue())) {
            map().remove(entry.getKey());
            return true;
          }
        }

        pendingOperations.add(operation);
    }

    /**
     * Remove a pending operation
     *
     * @param operation operation to remove
     * @return true if operation was removed
     */
    public boolean removePendingOperation(CommonServerMessageBlock operation) {
        return pendingOperations.remove(operation);
    }

    /**
     * Clear all pending operations
     */

  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object object) {
    if (needsAllocArrays()) {
      return false;
    }
    Set<E> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.remove(object);
    }
    int mask = hashTableMask();
    int index =
        CompactHashing.remove(
            object,
            /* value= */ null,
            mask,

    }

    @Override
    public boolean remove(@Nullable Object o) {
      try {
        return super.remove(o);
      } catch (UnsupportedOperationException e) {
        for (Entry<K, V> entry : map().entrySet()) {
          if (Objects.equals(o, entry.getValue())) {
            map().remove(entry.getKey());
            return true;
          }
        }

import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * This should be removed when https://bugs.openjdk.org/browse/JDK-8323729
 * is released in our minimum JDK.
 */
class ImmutableCollections {

    private static final Map<?, ?> EMPTY_MAP = new AbstractImmutableMap<>() {
        @Override

        if (!Objects.equals(omittedVersion, keptVersion)) {
            logger.debug(indent + omitted + " (removed - nearer found: " + keptVersion + ")");
        }
    }

    @Override
    public void omitForCycle(Artifact omitted) {
        logger.debug(indent + omitted + " (removed - causes a cycle in the graph)");
    }

    @Override

      }

      Entry<?, ?> entry = (Entry<?, ?>) object;
      inverse.delegate.remove(entry.getValue());
      /*
       * Remove the mapping in inverse before removing from esDelegate because
       * if entry is part of esDelegate, entry might be invalidated after the
       * mapping is removed from esDelegate.
       */
      esDelegate.remove(entry);
      return true;
    }

    @Override