import java.util.TreeSet;

public final class NodeSets {

    public static NavigableSet<Node> newSortedNodeSet() {
        return new TreeSet<>(NodeComparator.INSTANCE);
    }

    public static List<Node> sortedListOf(Set<Node> nodes) {
        List<Node> sorted = new ArrayList<>(nodes);
        sorted.sort(NodeComparator.INSTANCE);
        return sorted;
    }

    private NodeSets() {
    }

import org.gradle.execution.plan.Node;
import org.gradle.execution.plan.NodeSets;

import java.util.Set;
import java.util.SortedSet;
import java.util.function.Consumer;

class ComplexDependentNodesSet implements DependentNodesSet {
    private final DependencyPredecessorsOnlyNodeSet dependencyPredecessors;
    private final SortedSet<Node> mustPredecessors = NodeSets.newSortedNodeSet();

import org.gradle.execution.plan.Node;
import org.gradle.execution.plan.NodeSets;

import java.util.SortedSet;
import java.util.function.Consumer;

/**
 * Only incoming dependencies, no incoming must-run-after or finalizes relationships.
 */
class DependencyPredecessorsOnlyNodeSet implements DependentNodesSet {
    private final SortedSet<Node> dependencyPredecessors = NodeSets.newSortedNodeSet();

    @Override

 * limitations under the License.
 */

package org.gradle.execution.plan.edges;

import org.gradle.execution.plan.Node;

import java.util.NavigableSet;

import static org.gradle.execution.plan.NodeSets.newSortedNodeSet;

public class ComplexDependencyNodesSet implements DependencyNodesSet {
    private final DependencySuccessorsOnlyNodeSet delegate;

import org.gradle.api.GradleException;
import org.gradle.api.internal.TaskInternal;

import java.util.NavigableSet;
import java.util.Set;
import java.util.function.Consumer;

import static org.gradle.execution.plan.NodeSets.newSortedNodeSet;

public abstract class TaskNode extends Node {
    private final NavigableSet<Node> shouldSuccessors = newSortedNodeSet();
    private final NavigableSet<Node> finalizingSuccessors = newSortedNodeSet();

import org.gradle.execution.plan.Node;

import java.util.HashSet;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;

import static org.gradle.execution.plan.NodeSets.newSortedNodeSet;

/**
 * Maintains the state for the dependencies of a node.
 *

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

import static java.lang.String.format;
import static org.gradle.execution.plan.NodeSets.sortedListOf;

/**
 * Determines the execution plan, checking for cycles and making sure `finalizedBy` constraints are honored.
 *

		}
	}

	if nts := lnts[""]; nts != nil {
		nodelets += b.numericNodelets(nts, maxNodelets, flatTags, fmt.Sprintf(`N%d`, nodeID))
	}

	fmt.Fprint(b, nodelets)
	return nodelets != ""
}

func (b *builder) numericNodelets(nts []*Tag, maxNumNodelets int, flatTags bool, source string) string {
	nodelets := ""

	// Collapse numeric labels into maxNumNodelets buckets, of the form:
	// 1MB..2MB, 3MB..5MB, ...