@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class SparseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  static final ImmutableTable<Object, Object, Object> EMPTY =
      new SparseImmutableTable<>(ImmutableList.of(), ImmutableSet.of(), ImmutableSet.of());

  private final ImmutableMap<R, ImmutableMap<C, V>> rowMap;
  private final ImmutableMap<C, ImmutableMap<R, V>> columnMap;

        }

        return executionPlan;
    }

    public void handleBuildError(
            final ReactorContext buildContext,
            final MavenSession rootSession,
            final MavenSession currentSession,
            final MavenProject mavenProject,
            Throwable t,
            final Instant buildStartTime) {
        // record the error and mark the project as failed

  // TODO(b/345814817): Move this to RegularImmutableList?
  @SuppressWarnings("ClassInitializationDeadlock")
  private static final UnmodifiableListIterator<Object> EMPTY_ITR =
      new Itr<Object>(RegularImmutableList.EMPTY, 0);

  private static final class Itr<E> extends AbstractIndexedListIterator<E> {
    private final ImmutableList<E> list;

    Itr(ImmutableList<E> list, int index) {
      super(list.size(), index);

    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {

   * be added without necessarily executing immediately.
   */
  private static final class PerListenerQueue<L> implements Runnable {
    final L listener;
    final Executor executor;

    @GuardedBy("this")
    final Queue<ListenerCallQueue.Event<L>> waitQueue = new ArrayDeque<>();

    @GuardedBy("this")
    final Queue<Object> labelQueue = new ArrayDeque<>();

    @GuardedBy("this")

    public static final String HINT = "settings";

    public static final String USER_HOME = System.getProperty("user.home");

    public static final File USER_MAVEN_CONFIGURATION_HOME = new File(USER_HOME, ".m2");

    public static final File DEFAULT_USER_SETTINGS_FILE = new File(USER_MAVEN_CONFIGURATION_HOME, "settings.xml");

     * Constructs a new RequestHeader with the specified name and value.
     *
     * @param name  the name of the request header
     * @param value the value of the request header
     */
    public RequestHeader(final String name, final String value) {
        this.name = name;
        this.value = value;
    }

    /**
     * Returns the name of the request header.
     * @return The name of the request header.
     */

    /**
     * Converts a URL.
     *
     * @param url The URL.
     * @return A converted URL.
     */
    public String convert(final String url) {
        if (url == null) {
            return null;
        }
        String convertedUrl = url;
        for (final Map.Entry<String, String> entry : convertMap.entrySet()) {
            convertedUrl = convertedUrl.replaceAll(entry.getKey(), entry.getValue());
        }

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

@NullUnmarked
public class BaseEncodingBenchmark {
  private static final int INPUTS_COUNT = 0x1000;
  private static final int INPUTS_MASK = 0xFFF;

  enum EncodingOption {
    BASE64(BaseEncoding.base64()),
    BASE64_URL(BaseEncoding.base64Url()),
    BASE32(BaseEncoding.base32()),
    BASE32_HEX(BaseEncoding.base32Hex()),
    BASE16(BaseEncoding.base16());

    final BaseEncoding encoding;

    EncodingOption(BaseEncoding encoding) {