.filter(entry -> verificationsBuilder.getTrustedKeys().stream()
                        .filter(trustedKey -> trustedKey.getKeyId().equals(e.getKey()))
                        .noneMatch(entry::checkAndMarkSatisfiedBy))
                    .collect(Collectors.toList());
                if (pgpKeys.size() > 1) {
                    // if there's only one entry, we won't "normalize" into globally trusted keys

            state.failedSignatures();
            if (((SignatureVerificationFailure) failure).getErrors().values().stream().map(SignatureVerificationFailure.SignatureError::getKind).noneMatch(kind -> kind == SignatureVerificationFailure.FailureKind.PASSED_NOT_TRUSTED)) {
                state.maybeCompromised();
            } else {
                state.hasUntrustedKeys();
            }

            options.setDocTitle(getTitle());
        }

        String maxMemory = getMaxMemory();
        if (maxMemory != null && options.getJFlags().stream().noneMatch(flag -> flag.startsWith("-Xmx"))) {
            options.jFlags("-Xmx" + maxMemory);
        }

        options.setSourceNames(sourceNames());

        JavadocSpec spec = createJavadocSpec(options);

            extensionsToPrint.addAll(extensions.stream()
                .flatMap(e -> e.getExtendedConfigurations().stream())
                .filter(e -> extensionsToPrint.stream().noneMatch(eToP -> eToP.name.equals(e.getName())))
                .map(e -> new FormattedExtension(e.getName(), true))
                .collect(Collectors.toList()));
            if (nonRecursiveCount != extensionsToPrint.size()) {

    }

    // A ∩ (A ∪ B) ∩ (A ∪ C) -> A
    // A ∪ (A ∩ B) ∪ (A ∩ C) -> A
    private Set<ExcludeSpec> simplifySet(Class<? extends CompositeExclude> clazz, Set<ExcludeSpec> specs) {
        if (specs.stream().noneMatch(clazz::isInstance)) {
            return specs;
        }
        ExcludeSpec[] asArray = specs.toArray(new ExcludeSpec[0]);
        boolean doDrop = false;
        for (int i = 0; i < asArray.length; i++) {

        }
    }

    private void warnAboutInsecureChecksums() {
        if (checksums.stream().noneMatch(SECURE_CHECKSUMS::contains)) {

                // If it's not in the matches, it's only in the requested attributes
                if (buckets.bothAttributes.values().stream().map(AttributeMatchDetails::requested).noneMatch(Predicate.isEqual(attribute))) {
                    buckets.requestedAttributes.add(attribute);
                }
            }
            return buckets;
        }

	regionMatch := ruleRegion == "*" || proxyLocality.GetRegion() == ruleRegion
	zoneMatch := ruleZone == "*" || ruleZone == "" || proxyLocality.GetZone() == ruleZone
	subzoneMatch := ruleSubzone == "*" || ruleSubzone == "" || proxyLocality.GetSubZone() == ruleSubzone

	if regionMatch && zoneMatch && subzoneMatch {
		return true
	}
	return false
}