*/
  public static <T extends @Nullable Object> Iterable<List<@Nullable T>> paddedPartition(
      Iterable<T> iterable, int size) {
    checkNotNull(iterable);
    checkArgument(size > 0);
    return new FluentIterable<List<@Nullable T>>() {
      @Override
      public Iterator<List<@Nullable T>> iterator() {
        return Iterators.paddedPartition(iterable.iterator(), size);

 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingMultiset<E extends @Nullable Object> extends ForwardingCollection<E>
    implements Multiset<E> {

  /** Constructor for use by subclasses. */
  protected ForwardingMultiset() {}

  @Override
  protected abstract Multiset<E> delegate();

  @Override
  public int count(@Nullable Object element) {
    return delegate().count(element);
  }

      }
    };
  }

  @LazyInit private transient @Nullable ImmutableList<E> asList;

  @Override
  public ImmutableList<E> asList() {
    ImmutableList<E> result = asList;
    return (result == null) ? asList = super.asList() : result;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return count(object) > 0;
  }

  /**

   */

  static final class Node<K extends @Nullable Object, V extends @Nullable Object>
      extends SimpleEntry<K, V> {
    @Nullable Node<K, V> next; // the next node (with any key)
    @Weak @Nullable Node<K, V> previous; // the previous node (with any key)
    @Nullable Node<K, V> nextSibling; // the next node with the same key
    @Weak @Nullable Node<K, V> previousSibling; // the previous node with the same key

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link Multimaps#filterEntries(Multimap, Predicate)}.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
class FilteredEntryMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {

   * @return the replacement string, or {@code null} if no escaping was needed
   */
  public static @Nullable String computeReplacement(UnicodeEscaper escaper, int cp) {
    return stringOrNull(escaper.escape(cp));
  }

  private static @Nullable String stringOrNull(char @Nullable [] in) {
    return (in == null) ? null : new String(in);
  }

  @Override
  public @Nullable V remove(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.remove(key);
    }
    Object oldValue = removeHelper(key);
    return (oldValue == NOT_FOUND) ? null : (V) oldValue;
  }

  private @Nullable Object removeHelper(@Nullable Object key) {
    if (needsAllocArrays()) {

 */
public class SystemLogger implements Logger {
    private final PrintWriter out;
    private final Level threshold;

    public SystemLogger(@Nullable OutputStream out) {
        this(out, null);
    }

    public SystemLogger(@Nullable OutputStream out, @Nullable Level threshold) {
        this.out = new PrintWriter(toPsOrDef(out, System.err), true);
        this.threshold = Objects.requireNonNullElse(threshold, Level.INFO);

   * not have been inserted consecutively.
   */
  private final @Nullable List<NodeConnection<N>> orderedNodeConnections;

  private int predecessorCount;
  private int successorCount;

  private DirectedGraphConnections(
      Map<N, Object> adjacentNodeValues,
      @Nullable List<NodeConnection<N>> orderedNodeConnections,
      int predecessorCount,
      int successorCount) {

        "toString() isn't properly forwarded",
        proxy.toString(),
        wrapperFunction.apply(proxy).toString());
  }

  private static @Nullable Object[] getParameterValues(Method method) {
    FreshValueGenerator paramValues = new FreshValueGenerator();
    List<@Nullable Object> passedArgs = new ArrayList<>();
    for (Class<?> paramType : method.getParameterTypes()) {
      passedArgs.add(paramValues.generateFresh(paramType));