docs: private void constructHittingSetTree(E entailment, Explanation<E> justification, Set<Explanation<E>> allJustifications,
                                           Set<Set<OWLAxiom>> satPaths, Set<OWLAxiom> currentPathContents,
                                           int maxExplanations) throws OWLException {
  
  //        dumpHSTNodeDiagnostics(entailment, justification, allJustifications, currentPathContents);
          // We go through the current justifications, checker by checker, and extend the tree
          // with edges for each checker
          List<OWLAxiom> orderedJustification = getOrderedJustifications(new ArrayList<OWLAxiom>(justification.getAxioms()), allJustifications);
  
          while (!orderedJustification.isEmpty()) {
              OWLAxiom axiom = orderedJustification.get(0);
              orderedJustification.remove(0);
              if (allJustifications.size() == maxExplanations) {
                  return;
              }
  
              // Remove the current checker from all the ontologies it is included
              // in
  
              module.remove(axiom);
              currentPathContents.add(axiom);
  
              boolean earlyTermination = false;
              // Early path termination. If our path contents are the superset of
              // the contents of a path then we can terminate here.
              for (Set<OWLAxiom> satPath : satPaths) {
                  if (currentPathContents.containsAll(satPath)) {
                      earlyTermination = true;
                      break;
                  }
              }
  
              if (!earlyTermination) {
                  Explanation<E> newJustification = null;
                  for (Explanation<E> foundJustification : allJustifications) {
                      Set<OWLAxiom> foundMUPSCopy = new HashSet<OWLAxiom>(foundJustification.getAxioms());
                      foundMUPSCopy.retainAll(currentPathContents);
                      if (foundMUPSCopy.isEmpty()) {
                          // Justification reuse
                          newJustification = foundJustification;
                          break;
                      }
                  }
                  if (newJustification == null) {
                      newJustification = computeExplanation(entailment);//getExplanation();
                  }
                  // Generate a new node - i.e. a new justification set
                  if (axiom.isLogicalAxiom() && newJustification.contains(axiom)) {
                      // How can this be the case???
                      throw new OWLRuntimeException("Explanation contains removed axiom: " + axiom + " (Working axioms contains axiom: " + module.contains(axiom) + ")");
                  }
  
                  if (!newJustification.isEmpty()) {
                      // Note that getting a previous justification does not mean
                      // we
                      // can stop. stopping here causes some justifications to be
                      // missed
                      boolean added = allJustifications.add(newJustification);
                      if (added) {
                          progressMonitor.foundExplanation(this, newJustification, allJustifications);
                      }
                      if (progressMonitor.isCancelled()) {
                          return;
                      }
  
                      // Recompute priority here?
  //                    MutableTree<Explanation> node = new MutableTree<Explanation>(newJustification);
  //                    currentNode.addChild(node, checker);
                      constructHittingSetTree(entailment,
                              newJustification,
                              allJustifications,
                              satPaths,
                              currentPathContents,
                              maxExplanations);
                      // We have found a new MUPS, so recalculate the ordering
                      // axioms in the MUPS at the current level
                      orderedJustification = getOrderedJustifications(orderedJustification, allJustifications);
                  } else {
                      // End of current path - add it to the list of paths
                      satPaths.add(new HashSet<OWLAxiom>(currentPathContents));
                      Explanation exp = new Explanation<E>(entailment, new HashSet<OWLAxiom>(0));
                      MutableTree<Explanation> node = new MutableTree<Explanation>(exp);
  //                    currentNode.addChild(node, checker);
  //                    increment(checker);
                  }
              }
  
              // Back track - go one level up the tree and run for the next checker
              currentPathContents.remove(axiom);
  
              // Done with the checker that was removed. Add it back in
              module.add(axiom);
          }
      }