graph.predecessors(node).iterator(),
                          (N predecessor) -> EndpointPair.ordered(predecessor, node)),
                      Iterators.transform(
                          // filter out 'node' from successors (already covered by predecessors,
                          // above)
                          Sets.difference(graph.successors(node), ImmutableSet.of(node)).iterator(),

    return new MutableClassToInstanceMap<>(new HashMap<Class<? extends @NonNull B>, B>());
  }

  /**
   * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code
   * backingMap}. The caller surrenders control of the backing map, and thus should not allow any
   * direct references to it to remain accessible.
   */
  public static <B extends @Nullable Object> MutableClassToInstanceMap<B> create(

    }
  }

  /**
   * Views the array as an immutable list. The array must have only {@code E} elements.
   *
   * <p>The array must be internally created.
   */
  @SuppressWarnings("unchecked") // caller is reponsible for getting this right
  static <E> ImmutableList<E> asImmutableList(Object[] elements) {
    return unsafeDelegateList((List) Arrays.asList(elements));
  }

   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean removeIf(Predicate<? super E> filter) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the collection unmodified.
   *
   * @throws UnsupportedOperationException always

@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class ArrayTable<R, C, V> extends AbstractTable<R, C, @Nullable V>
    implements Serializable {

  /**
   * Creates an {@code ArrayTable} filled with {@code null}.
   *
   * @param rowKeys row keys that may be stored in the generated table
   * @param columnKeys column keys that may be stored in the generated table

                    Map<String, String> map = Maps.newHashMap();
                    putEntries(map, entries);
                    map.putAll(ENTRIES_TO_FILTER);
                    map = Maps.filterEntries(map, FILTER_ENTRIES_1);
                    return Maps.filterEntries(map, FILTER_ENTRIES_2);
                  }
                })
            .named("Maps.filterEntries[Maps.filterEntries[Map, Predicate], Predicate]")

  }

  private static final Predicate<Entry<Integer, String>> FILTER_GET_PREDICATE =
      new Predicate<Entry<Integer, String>>() {
        @Override
        public boolean apply(Entry<Integer, String> entry) {
          return !"badvalue".equals(entry.getValue()) && 55556 != entry.getKey();
        }
      };

  private static final Predicate<Entry<String, Integer>> FILTER_KEYSET_PREDICATE =
      new Predicate<Entry<String, Integer>>() {

    TreeMultimap<String, Integer> empty = TreeMultimap.create();
    TreeMultimap<String, Integer> filled = TreeMultimap.create();
    filled.put("a", 1);
    filled.put("a", 2);
    filled.put("b", 2);
    filled.put("c", 3);
    CollectorTester.of(collector, equivalence)
        .expectCollects(empty)
        .expectCollects(
            filled, mapEntry("a", 1), mapEntry("a", 2), mapEntry("b", 2), mapEntry("c", 3));
  }

  }

  interface X {}

  interface Y {}

  static class A implements X, Y {}

  static class B implements X, Y {}

  /**
   * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles.
   * That statement compiles only if {@link FluentIterable#concat concat(aIterable, bIterable)}
   * returns a {@link FluentIterable} of elements of an anonymous type whose supertypes are the <a

   * <p><b>{@code Stream} equivalent:</b> {@link Stream#filter} (same).
   */
  public final FluentIterable<E> filter(Predicate<? super E> predicate) {
    return from(Iterables.filter(getDelegate(), predicate));
  }

  /**
   * Returns the elements from this fluent iterable that are instances of class {@code type}.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.filter(type::isInstance).map(type::cast)}.