private final Map<Key<?>, Object> provided = new HashMap<>();
    }

    private final ThreadLocal<LinkedList<ScopeState>> values = new ThreadLocal<>();

    public MojoExecutionScope() {}

    public void enter() {
        LinkedList<ScopeState> stack = values.get();
        if (stack == null) {
            stack = new LinkedList<>();
            values.set(stack);
        }
        stack.addFirst(new ScopeState());
    }

    private RepositoryChainModuleResolution findBestMatch(List<ComponentMetaDataResolveState> resolveStates, Collection<Throwable> failures) {
        LinkedList<ComponentMetaDataResolveState> queue = new LinkedList<>(resolveStates);

        LinkedList<ComponentMetaDataResolveState> missing = new LinkedList<>();

        // A first pass to do local resolves only
        RepositoryChainModuleResolution best = findBestMatch(queue, failures, missing);

import com.google.common.collect.Lists;

import java.util.LinkedList;
import java.util.List;

/**
 * Discards old entries when current count is over the limit.
 *
 * @deprecated Used only by a deprecated public class GFileUtils. Prefer Guava's EvictionQueue in the new code.
 */
@Deprecated
public class LimitedDescription {

    private final LinkedList<String> content;
    private final int maxItems;

import org.gradle.internal.remote.internal.inet.InetEndpoint;
import org.gradle.launcher.daemon.context.DaemonContext;

import java.io.File;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State;

 */
package org.apache.maven.internal.impl.model;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

class Graph {

    final Map<String, Set<String>> graph = new LinkedHashMap<>();

import java.util.Hashtable
import java.util.LinkedList
import java.util.Properties
import java.util.TreeMap
import java.util.TreeSet
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.CopyOnWriteArraySet


val arrayListCodec: Codec<ArrayList<Any?>> = collectionCodec { ArrayList(it) }


val linkedListCodec: Codec<LinkedList<Any?>> = collectionCodec { LinkedList() }

import org.gradle.internal.build.BuildState;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

@ServiceScope(Scope.Gradle.class)
public class CommandLineTaskParser {
    private final CommandLineTaskConfigurer taskConfigurer;

import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;

import static java.util.Collections.singletonList;

/**
 * Generic container for conflicts. It's generic so that hopefully it's easier to comprehend (and test).
 */
class ConflictContainer<K, T> {

    final LinkedList<Conflict> conflicts = new LinkedList<>();

        return visitAll(vertices.values(), new HashMap<>(), new ArrayList<>());
    }

    List<String> findCycle(Vertex vertex) {
        return visitCycle(Collections.singleton(vertex), new HashMap<>(), new LinkedList<>());
    }

    private static List<String> visitAll(
            Collection<Vertex> children, Map<Vertex, DfsState> stateMap, List<String> list) {
        for (Vertex v : children) {

import org.gradle.plugin.use.resolve.service.internal.ClientInjectedClasspathPluginResolver;
import org.gradle.plugin.use.resolve.service.internal.DefaultInjectedClasspathPluginResolver;

import java.util.LinkedList;
import java.util.List;

@ServiceScope(Scope.Build.class)
public class PluginResolverFactory {

    private final PluginRegistry pluginRegistry;
    private final DocumentationRegistry documentationRegistry;