logger.debug("Interrupted.", e);
                }
            }
        }

        public void awaitTermination(final long mills) {
            try {
                join(mills);
            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            }

import org.eclipse.aether.repository.MirrorSelector;
import org.eclipse.aether.repository.ProxySelector;
import org.eclipse.aether.repository.RemoteRepository;

/**
 * Extender that fills in legacy bits (using legacy code).
 *
 * @since 4.0.0
 */
@Named
@Singleton
public class LegacyRepositorySystemSessionExtender implements RepositorySystemSessionExtender {
    @Override
    public void extend(

    // There are several well-known algorithms for rotating part of an array (or, equivalently,
    // exchanging two blocks of memory). This classic text by Gries and Mills mentions several:
    // https://ecommons.cornell.edu/bitstream/handle/1813/6292/81-452.pdf.
    // (1) "Reversal", the one we have here.

  }

  /**
   * Creates a TimeLimiter instance using the given executor service to execute method calls.
   *
   * <p><b>Warning:</b> using a bounded executor may be counterproductive! If the thread pool fills
   * up, any time callers spend waiting for a thread may count toward their time limit, and in this
   * case the call may even time out before the target method is ever invoked.
   *

        queue[index] = elementData(minChildIndex);
        queue[minChildIndex] = x;
        return minChildIndex;
      }
      return crossOverUp(index, x);
    }

    /**
     * Fills the hole at {@code index} by moving in the least of its grandchildren to this position,
     * then recursively filling the new hole created.
     *

      ListenableFuture<? extends V>... futures) {
    ListenableFuture<List<@Nullable V>> nullable =
        new ListFuture<V>(ImmutableList.copyOf(futures), true);
    // allAsList ensures that it fills the output list with V instances.
    @SuppressWarnings("nullness")
    ListenableFuture<List<V>> nonNull = nullable;
    return nonNull;
  }

  /**