code: private void findUnmatchedAssertions(final List<ACE> aces, List<AceAssertion> unsatisfiedAssertions) {
          List<AceAssertion> unmatchedAssertions = null;
          if (aces == null || aces.isEmpty()) {
              return;
          }
  
          for (ACE ace : aces) {
              long rightsMask = ace.getRights().asUInt();
              unmatchedAssertions = new ArrayList<>(unsatisfiedAssertions);
              LOG.debug("findUnmatchedAssertions, processing ACE: {}", ace);
  
              // can only match type ACCESS_ALLOWED or ACCESS_ALLOWED_OBJECT
              if (ace.getType().getValue() != AceType.ACCESS_ALLOWED_ACE_TYPE.getValue()
                      && ace.getType().getValue() != AceType.ACCESS_ALLOWED_OBJECT_ACE_TYPE.getValue()) {
                  LOG.debug("findUnmatchedAssertions, skipping ACE with non allowed object type: {}",
                          ace.getType().getValue());
                  continue;
              }
  
              for (AceAssertion assertion : unmatchedAssertions) {
                  long assertRight = assertion.getAceRight().asUInt();
                  LOG.debug("findUnmatchedAssertions, assertRightMask: {}, aceRightsMask: {}", assertRight, rightsMask);
                  if ((rightsMask & assertRight) == assertRight) {
                      // found a rights match
                      if (doObjectFlagsMatch(ace.getObjectFlags(), assertion.getObjectFlags())
                              && doObjectTypesMatch(
                                      ace.getObjectType(),
                                      assertion.getObjectType(),
                                      assertion.getObjectFlags())
                              && doInheritedObjectTypesMatch(
                                      ace.getInheritedObjectType(),
                                      assertion.getInheritedObjectType(),
                                      assertion.getObjectFlags())
                              && doRequiredFlagsMatch(ace.getFlags(), assertion.getRequiredFlag())
                              && !isAceExcluded(ace.getFlags(), assertion.getExcludedFlag())) {
                          LOG.debug("findUnmatchedAssertions, found an assertion match for: {}", assertion);
                          unsatisfiedAssertions.remove(assertion);
                      }
                  }
              }
          }
      }
docs: Finds which AceAssertions are satisfied by the given list of ACEs, removes those from the unsatisfied list, and
  returns. Upon returning, only the assertions still unmatched will be in the given {@code unsatisfiedAssertions}
  list.
  
  @param aces
  ACE list to be evaluated
  @param unsatisfiedAssertions
  list of AceAssertions currently unmatched in the DACL.