h.update(rev)
      h.update(b'\n')
  print('r1:'+base64.standard_b64encode(h.digest()).decode('utf-8'))

@command(b'golookup', [], _('url rev'), norepo=True)
def golookup(ui, url, rev):
  """
  golookup looks up a single identifier in the repo,
  printing its hash.
  """

    @Override
    public void updateLogging(LookupContext context) {
        plexusContainer.getLoggerManager().setThresholds(toPlexusLoggingLevel(context.loggerLevel));
    }

    @Override
    public Lookup getLookup() {
        return lookup;
    }

    @Override
    public Optional<ClassLoader> currentThreadClassLoader() {
        return Optional.of(plexusContainer.getContainerRealm());
    }

    @Override

import org.apache.maven.api.services.Lookup;

/**
 * Container capsule.
 */
public interface ContainerCapsule extends AutoCloseable {
    /**
     * Updates the existing capsule logging setup.
     */
    void updateLogging(LookupContext context);

    /**
     * The {@link Lookup} service backed by container in this capsule.
     */
    @Nonnull
    Lookup getLookup();

    /**

    }

    protected void lookup(C context) throws Exception {
        if (context.eventSpyDispatcher == null) {
            context.eventSpyDispatcher = context.lookup.lookup(EventSpyDispatcher.class);
        }
    }

    protected void init(C context) throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("plexus", context.lookup.lookup(PlexusContainer.class));

@Singleton
@Deprecated(since = "4.0.0")
public class ToolchainManagerFactory {

    private final Lookup lookup;
    private final Logger logger;

    @Inject
    ToolchainManagerFactory(Lookup lookup) {
        this(lookup, null);
    }

    protected ToolchainManagerFactory(Lookup lookup, Logger logger) {
        this.lookup = lookup;
        this.logger = logger;
    }

    @Provides

        this.customLifecycles = lifecycles;
        this.lookup = null;
        this.registry = null;
    }

    @Inject
    public DefaultLifecycles(LifecycleRegistry registry, Lookup lookup) {
        this.lookup = lookup;
        this.registry = registry;
    }

    /**
     * Get lifecycle based on phase
     *
     * @param phase

    dns[PROXY_A_HOST] = dns.allocate(2)
    val selection = routeSelector.next()
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 0), PROXY_A_PORT)
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 1), PROXY_A_PORT)
    assertThat(selection.hasNext()).isFalse()
    assertThat(routeSelector.hasNext()).isFalse()
    dns.assertRequests(PROXY_A_HOST)

    private final Lookup lookup;
    private final RuntimeInformation runtimeInformation;

    @Inject
    @SuppressWarnings("checkstyle:ParameterNumber")
    public DefaultSessionFactory(
            RepositorySystem repositorySystem,
            MavenRepositorySystem mavenRepositorySystem,
            Lookup lookup,
            RuntimeInformation runtimeInformation) {

            }
        }

        private static final Lookup EMPTY_LOOKUP = new Lookup() {
            @Override
            public <T> T lookup(Class<T> type) {
                throw new LookupException("empty lookup");
            }

            @Override
            public <T> T lookup(Class<T> type, String name) {
                throw new LookupException("empty lookup");
            }

            @Override

    private final Lookup lookup;

    private final LanguageRegistry languageRegistry;

    private final ConcurrentHashMap<String, Type> usedTypes;

    private final LegacyArtifactHandlerManager manager;

    @Inject
    public DefaultTypeRegistry(Lookup lookup, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
        this.lookup = requireNonNull(lookup, "lookup cannot be null");