this.classWorldManaged = classWorldManaged;
    }

    /**
     * The main entry point.
     */
    public int run(
            String[] args,
            @Nullable InputStream stdIn,
            @Nullable OutputStream stdOut,
            @Nullable OutputStream stdErr,
            boolean embedded)
            throws IOException {
        try (Invoker invoker = createInvoker()) {
            return invoker.invoke(createParser()

 * methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingMapEntry<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingObject implements Map.Entry<K, V> {
  // TODO(lowasser): identify places where thread safety is actually lost

  /** Constructor for use by subclasses. */

  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);
  private static final Iterable<@Nullable Integer> iterableNullNull =
      Arrays.asList((Integer) null, null);
  private static final Iterable<@Nullable Integer> iterableNull1 = Arrays.asList(null, 1);
  private static final Iterable<@Nullable Integer> iterable1Null = Arrays.asList(1, null);

    return forwardMultiset();
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forwardMultiset().lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forwardMultiset().firstEntry();
  }

  abstract Iterator<Entry<E>> entryIterator();

  @LazyInit private transient @Nullable Set<Entry<E>> entrySet;

  @Override

          null, null, (Entry<Object, Object>[]) ImmutableMap.EMPTY_ENTRY_ARRAY, 0, 0);

  static final double MAX_LOAD_FACTOR = 1.2;

  private final transient @Nullable ImmutableMapEntry<K, V> @Nullable [] keyTable;
  private final transient @Nullable ImmutableMapEntry<K, V> @Nullable [] valueTable;
  @VisibleForTesting final transient Entry<K, V>[] entries;
  private final transient int mask;
  private final transient int hashCode;

  public VerifyException(@Nullable String message) {
    super(message);
  }

  /**
   * Constructs a {@code VerifyException} with the cause {@code cause} and a message that is {@code
   * null} if {@code cause} is null, and {@code cause.toString()} otherwise.
   *
   * @since 19.0
   */
  public VerifyException(@Nullable Throwable cause) {
    super(cause);
  }

  /**

    }

    @Override
    public @Nullable T lower(T e) {
      return standardLower(e);
    }

    @Override
    public @Nullable T floor(T e) {
      return standardFloor(e);
    }

    @Override
    public @Nullable T ceiling(T e) {
      return standardCeiling(e);
    }

    @Override
    public @Nullable T higher(T e) {
      return standardHigher(e);
    }

        }
      }
    };

    abstract <E extends @Nullable Object> void forEach(
        GeneralSpliterator<E> spliterator, Consumer<? super E> consumer);

    static final Set<SpliteratorDecompositionStrategy> ALL_STRATEGIES =
        unmodifiableSet(new LinkedHashSet<>(asList(values())));
  }

  private static <E extends @Nullable Object> @Nullable GeneralSpliterator<E> trySplitTestingSize(

        }
      }
    };

    abstract <E extends @Nullable Object> void forEach(
        GeneralSpliterator<E> spliterator, Consumer<? super E> consumer);

    static final Set<SpliteratorDecompositionStrategy> ALL_STRATEGIES =
        unmodifiableSet(new LinkedHashSet<>(asList(values())));
  }

  private static <E extends @Nullable Object> @Nullable GeneralSpliterator<E> trySplitTestingSize(

    }
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return delegate().firstEntry();
  }

  /**
   * A sensible definition of {@link #firstEntry()} in terms of {@code entrySet().iterator()}.
   *
   * <p>If you override {@link #entrySet()}, you may wish to override {@link #firstEntry()} to
   * forward to this implementation.
   */
  protected @Nullable Entry<E> standardFirstEntry() {