public int compare(Entry<K, V> a, Entry<K, V> b) {
      return (keyComparator == null)
          ? ((Comparable) a.getKey()).compareTo(b.getKey())
          : keyComparator.compare(a.getKey(), b.getKey());
    }
  }

  public static <K extends @Nullable Object, V extends @Nullable Object>

                    .build();

            versions.put(getKey(sv.getClassifier(), sv.getExtension()), sv);
        }

        artifacts.clear();

        Versioning versioning = recessive.getVersioning();
        if (versioning != null) {
            for (SnapshotVersion sv : versioning.getSnapshotVersions()) {
                String key = getKey(sv.getClassifier(), sv.getExtension());

	c.Register(func(o Event[I]) {
		idx.mu.Lock()
		defer idx.mu.Unlock()

		if o.Old != nil {
			obj := *o.Old
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {
				sets.DeleteCleanupLast(idx.objects, indexKey, key)
			}
		}
		if o.New != nil {
			obj := *o.New
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {
				sets.InsertOrNew(idx.objects, indexKey, key)
			}
		}
	})

	synced         <-chan struct{}
}

func (j *join[T]) GetKey(k Key[T]) *T {
	for _, c := range j.collections {
		if r := c.GetKey(k); r != nil {
			return r
		}
	}
	return nil
}

func (j *join[T]) List() []T {
	res := []T{}
	found := sets.New[Key[T]]()
	for _, c := range j.collections {
		for _, i := range c.List() {
			key := GetKey(i)
			if !found.InsertContains(key) {

            if (APP_NAME_REGEX.matcher(entry.getKey()).matches()
                || JAVA_MAIN_CLASS_REGEX.matcher(entry.getKey()).matches()
                || entry.getKey().equals("TERM_SESSION_ID")
                || entry.getKey().equals("ITERM_SESSION_ID")) {
                continue;
            }
            vars.put(entry.getKey(), entry.getValue());
        }
        return vars;
    }

        reportGenerator().generateReport(
            modelsByProjectDetails.entrySet(),
            Map.Entry::getKey,
            () -> generateReportHeaderFor(modelsByProjectDetails),
            entry -> {
                generateReportFor(entry.getKey(), entry.getValue());
                logClickableOutputFileUrl();
            },
            () -> generateReportFooterFor(modelsByProjectDetails)

        for (Map.Entry<Class<?>, SerializerFactory<?>> entry : serializerMap.entrySet()) {
            if (baseType.isAssignableFrom(entry.getKey())) {
                matches.put(entry.getKey(), entry.getValue());
            }
        }
        Set<Class<?>> matchingJavaSerialization = new LinkedHashSet<Class<?>>();
        for (Class<?> candidate : javaSerialization.keySet()) {

    override fun getKey(): SecretKey = secretKey

    override val sourceDescription: String
        get() = "$GRADLE_ENCRYPTION_KEY_ENV_KEY environment variable"

    companion object {
        const val GRADLE_ENCRYPTION_KEY_ENV_KEY = "GRADLE_ENCRYPTION_KEY"
    }
}


private
class NoEncryptionKeySource : SecretKeySource {
    override fun getKey(): SecretKey? {

	id   collectionUID
}

func NewStaticCollection[T any](vals []T) Collection[T] {
	res := map[Key[T]]T{}
	for _, v := range vals {
		res[GetKey(v)] = v
	}
	return &staticList[T]{
		vals: res,
		id:   nextUID(),
	}
}

func (s *staticList[T]) GetKey(k Key[T]) *T {
	if o, f := s.vals[k]; f {
		return &o
	}
	return nil
}

// nolint: unused // (not true, its to implement an interface)

    public int compare(Entry<K, V> a, Entry<K, V> b) {
      return (keyComparator == null)
          ? ((Comparable) a.getKey()).compareTo(b.getKey())
          : keyComparator.compare(a.getKey(), b.getKey());
    }
  }

  public static <K extends @Nullable Object, V extends @Nullable Object>