docs: private boolean createLandmarksForSubnetwork(final int startNode, final byte[] subnetworks, IntHashSet blockedEdges) {
          final int subnetworkId = landmarkIDs.size();
          int[] tmpLandmarkNodeIds = new int[landmarks];
          int logOffset = Math.max(1, tmpLandmarkNodeIds.length / 2);
          boolean pickedPrecalculatedLandmarks = false;
  
          if (!landmarkSuggestions.isEmpty()) {
              NodeAccess na = graph.getNodeAccess();
              double lat = na.getLatitude(startNode), lon = na.getLongitude(startNode);
              LandmarkSuggestion selectedSuggestion = null;
              for (LandmarkSuggestion lmsugg : landmarkSuggestions) {
                  if (lmsugg.getBox().contains(lat, lon)) {
                      selectedSuggestion = lmsugg;
                      break;
                  }
              }
  
              if (selectedSuggestion != null) {
                  if (selectedSuggestion.getNodeIds().size() < tmpLandmarkNodeIds.length)
                      throw new IllegalArgumentException("landmark suggestions are too few " + selectedSuggestion.getNodeIds().size() + " for requested landmarks " + landmarks);
  
                  pickedPrecalculatedLandmarks = true;
                  for (int i = 0; i < tmpLandmarkNodeIds.length; i++) {
                      int lmNodeId = selectedSuggestion.getNodeIds().get(i);
                      tmpLandmarkNodeIds[i] = lmNodeId;
                  }
              }
          }
  
          if (pickedPrecalculatedLandmarks) {
              LOGGER.info("Picked " + tmpLandmarkNodeIds.length + " landmark suggestions, skipped expensive landmark determination");
          } else {
              // 1a) pick landmarks via special weighting for a better geographical spreading
              Weighting initWeighting = lmSelectionWeighting;
              LandmarkExplorer explorer = new LandmarkExplorer(graph, this, initWeighting, traversalMode, true);
              explorer.setStartNode(startNode);
              explorer.setFilter(blockedEdges, true, true);
              explorer.runAlgo();
  
              if (explorer.getFromCount() < minimumNodes) {
                  // too small subnetworks are initialized with special id==0
                  explorer.setSubnetworks(subnetworks, UNCLEAR_SUBNETWORK);
                  return false;
              }
  
              // 1b) we have one landmark, now determine the other landmarks
              tmpLandmarkNodeIds[0] = explorer.getLastNode();
              for (int lmIdx = 0; lmIdx < tmpLandmarkNodeIds.length - 1; lmIdx++) {
                  if (Thread.currentThread().isInterrupted()) {
                      throw new RuntimeException("Thread was interrupted");
                  }
                  explorer = new LandmarkExplorer(graph, this, initWeighting, traversalMode, true);
                  explorer.setFilter(blockedEdges, true, true);
                  // set all current landmarks as start so that the next getLastNode is hopefully a "far away" node
                  for (int j = 0; j < lmIdx + 1; j++) {
                      explorer.setStartNode(tmpLandmarkNodeIds[j]);
                  }
                  explorer.runAlgo();
                  tmpLandmarkNodeIds[lmIdx + 1] = explorer.getLastNode();
                  if (logDetails && lmIdx % logOffset == 0)
                      LOGGER.info("Finding landmarks [" + weighting + "] in network [" + explorer.getVisitedNodes() + "]. "
                              + "Progress " + (int) (100.0 * lmIdx / tmpLandmarkNodeIds.length) + "%, " + Helper.getMemInfo());
              }
  
              if (logDetails)
                  LOGGER.info("Finished searching landmarks for subnetwork " + subnetworkId + " of size " + explorer.getVisitedNodes());
          }
  
          // 2) calculate weights for all landmarks -> 'from' and 'to' weight
          for (int lmIdx = 0; lmIdx < tmpLandmarkNodeIds.length; lmIdx++) {
              if (Thread.currentThread().isInterrupted()) {
                  throw new RuntimeException("Thread was interrupted");
              }
              int lmNodeId = tmpLandmarkNodeIds[lmIdx];
              LandmarkExplorer explorer = new LandmarkExplorer(graph, this, weighting, traversalMode, true);
              explorer.setStartNode(lmNodeId);
              explorer.setFilter(blockedEdges, true, false);
              explorer.runAlgo();
              explorer.initLandmarkWeights(lmIdx, lmNodeId, LM_ROW_LENGTH);
  
              // set subnetwork id to all explored nodes, but do this only for the first landmark
              if (lmIdx == 0) {
                  if (explorer.setSubnetworks(subnetworks, subnetworkId))
                      return false;
              }
  
              explorer = new LandmarkExplorer(graph, this, weighting, traversalMode, false);
              explorer.setStartNode(lmNodeId);
              explorer.setFilter(blockedEdges, false, true);
              explorer.runAlgo();
              explorer.initLandmarkWeights(lmIdx, lmNodeId, LM_ROW_LENGTH);
  
              if (lmIdx == 0) {
                  if (explorer.setSubnetworks(subnetworks, subnetworkId))
                      return false;
              }
  
              if (logDetails && lmIdx % logOffset == 0)
                  LOGGER.info("Set landmarks weights [" + weighting + "]. "
                          + "Progress " + (int) (100.0 * lmIdx / tmpLandmarkNodeIds.length) + "%");
          }
  
          // TODO set weight to SHORT_MAX if entry has either no 'from' or no 'to' entry
          landmarkIDs.add(tmpLandmarkNodeIds);
          return true;
      }