docs: @Override
    protected IndexTreePath<SpatialEntry> choosePath(IndexTreePath<SpatialEntry> subtree, SpatialComparable mbr, int level, int cur) {
      if(getLogger().isDebuggingFiner()) {
        getLogger().debugFiner("node " + subtree + ", level " + level);
      }
  
      N node = getNode(subtree.getEntry());
      if(node == null) {
        throw new RuntimeException("Page file did not return node for node id: " + getPageID(subtree.getEntry()));
      }
      if(node.isLeaf()) {
        return subtree;
      }
      // first test on containment
      IndexTreePath<SpatialEntry> newSubtree = containedTest(subtree, node, mbr);
      if(newSubtree != null) {
        if(height - subtree.getPathCount() == level) {
          return newSubtree;
        }
        else {
          return choosePath(newSubtree, mbr, level, ++cur);
        }
      }
  
      int optEntry = -1;
      HyperBoundingBox optTestMBR = null;
      double optOverlapInc = 0;
      boolean isLeafContainer = false; // test overlap increase?
      if((!OMIT_OVERLAP_INCREASE_4_SUPERNODES // also test supernodes
          || (OMIT_OVERLAP_INCREASE_4_SUPERNODES && !node.isSuperNode())) // don't
          && getNode(node.getEntry(0)).isLeaf()) { // children are leafs
        // overlap increase is to be tested
        optOverlapInc = Double.POSITIVE_INFINITY;
        isLeafContainer = true;
      }
      double optVolume = Double.POSITIVE_INFINITY;
      double optVolumeInc = Double.POSITIVE_INFINITY;
      double tempVolume, volume;
  
      for(int index = 0; index < node.getNumEntries(); index++) {
        SpatialEntry child = node.getEntry(index);
        SpatialComparable childMBR = child;
        HyperBoundingBox testMBR = SpatialUtil.union(childMBR, mbr);
        double pairwiseOverlapInc;
        if(isLeafContainer) {
          pairwiseOverlapInc = calculateOverlapIncrease(node, child, testMBR);
          if(Double.isInfinite(pairwiseOverlapInc) || Double.isNaN(pairwiseOverlapInc)) {
            throw new IllegalStateException("an entry's MBR is too large to calculate its overlap increase: " + pairwiseOverlapInc + "; \nplease re-scale your data s.t. it can be dealt with");
          }
        }
        else {
          // no need to examine overlap increase?
          pairwiseOverlapInc = 0;
        }
  
        if(pairwiseOverlapInc <= optOverlapInc) {
          if(pairwiseOverlapInc == optOverlapInc) {
            // If there are multiple entries with the same overlap increase,
            // choose the one with the minimum volume increase.
            // If there are also multiple entries with the same volume increase
            // choose the one with the minimum volume.
            volume = SpatialUtil.volume(childMBR);
            if(Double.isInfinite(volume) || Double.isNaN(volume)) {
              throw new IllegalStateException("an entry's MBR is too large to calculate its volume: " + volume + "; \nplease re-scale your data s.t. it can be dealt with");
            }
            tempVolume = SpatialUtil.volume(testMBR);
            if(Double.isInfinite(tempVolume) || Double.isNaN(tempVolume)) {
              throw new IllegalStateException("an entry's MBR is too large to calculate its volume: " + tempVolume + "; \nplease re-scale your data s.t. it can be dealt with");
            }
            double volumeInc = tempVolume - volume;
  
            if(Double.isNaN(optVolumeInc)) { // has not yet been calculated
              optVolume = SpatialUtil.volume(node.getEntry(optEntry));
              optVolumeInc = SpatialUtil.volume(optTestMBR) - optVolume;
            }
            if(volumeInc < optVolumeInc) {
              optVolumeInc = volumeInc;
              optVolume = volume;
              optEntry = index;
            }
            else if(volumeInc == optVolumeInc && volume < optVolume) {
              // TODO: decide whether to remove this option
              System.out.println("####\nEQUAL VOLUME INCREASE: HAPPENS!\n####");
              optVolumeInc = volumeInc;
              optVolume = volume;
              optEntry = index;
            }
          }
          else { // already better
            optOverlapInc = pairwiseOverlapInc;
            optVolume = Double.NaN;
            optVolumeInc = Double.NaN;
            optTestMBR = testMBR; // for later calculations
            optEntry = index;
          }
        }
      }
      assert optEntry >= 0;
      newSubtree = new IndexTreePath<>(subtree, node.getEntry(optEntry), optEntry);
      if(height - subtree.getPathCount() == level) {
        return newSubtree;
      }
      else {
        return choosePath(newSubtree, mbr, level, ++cur);
      }
    }