diff --git a/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java b/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
index c1f5b75..4dc4c7d 100644
--- a/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
+++ b/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
@@ -1,199 +1,200 @@
 package org.softwareheritage.graph.experiments.topology;
 
 import com.google.common.primitives.Longs;
 import com.martiansoftware.jsap.*;
 import it.unimi.dsi.big.webgraph.LazyLongIterator;
 import it.unimi.dsi.bits.LongArrayBitVector;
 import it.unimi.dsi.fastutil.Arrays;
 import it.unimi.dsi.io.ByteDiskQueue;
 import it.unimi.dsi.logging.ProgressLogger;
 import org.softwareheritage.graph.AllowedNodes;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.Node;
 import org.softwareheritage.graph.Subgraph;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.*;
 
 public class ConnectedComponents {
     private Subgraph graph;
 
     private void load_graph(String graphBasename, String nodeTypes) throws IOException {
         System.err.println("Loading graph " + graphBasename + " ...");
         var underlyingGraph = Graph.loadMapped(graphBasename);
         var underlyingGraphSym = underlyingGraph.symmetrize();
         graph = new Subgraph(underlyingGraphSym, new AllowedNodes(nodeTypes));
         System.err.println("Graph loaded.");
     }
 
     private static JSAPResult parse_args(String[] args) {
         JSAPResult config = null;
         try {
             SimpleJSAP jsap = new SimpleJSAP(ConnectedComponents.class.getName(), "",
                     new Parameter[]{
                             new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'g',
                                     "graph", "Basename of the compressed graph"),
                             new FlaggedOption("outdir", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'o',
                                     "outdir", "Directory where to put the results"),
                             new Switch("byOrigins", JSAP.NO_SHORTFLAG, "by-origins",
                                     "Compute size of components by number of origins"),
                             new FlaggedOption("nodeTypes", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'n',
                                     "nodetypes", "Allowed node types (comma-separated)"),});
 
             config = jsap.parse(args);
             if (jsap.messagePrinted()) {
                 System.exit(1);
             }
         } catch (JSAPException e) {
             e.printStackTrace();
         }
         return config;
     }
 
-    private HashMap<Long, Long> /* ArrayList<ArrayList<Long>> */ compute(ProgressLogger pl, boolean byOrigin) throws IOException {
+    private HashMap<Long, Long> /* ArrayList<ArrayList<Long>> */ compute(ProgressLogger pl, boolean byOrigin)
+            throws IOException {
         final long n = graph.numNodes();
         final long maxN = graph.maxNodeNumber();
 
         // Allow enough memory to behave like in-memory queue
         int bufferSize = (int) Math.min(Arrays.MAX_ARRAY_SIZE & ~0x7, 8L * maxN);
 
         // Use a disk based queue to store BFS frontier
         final File queueFile = File.createTempFile(ConnectedComponents.class.getSimpleName(), "queue");
         final ByteDiskQueue queue = ByteDiskQueue.createNew(queueFile, bufferSize, true);
         final byte[] byteBuf = new byte[Long.BYTES];
         // WARNING: no 64-bit version of this data-structure, but it can support
         // indices up to 2^37
         LongArrayBitVector visited = LongArrayBitVector.ofLength(maxN);
 
         pl.expectedUpdates = n;
         pl.itemsName = "nodes";
         pl.start("Starting connected components visit...");
 
         // ArrayList<ArrayList<Long>> components = new ArrayList<>();
         HashMap<Long, Long> componentDistribution = new HashMap<>();
 
         var it = graph.nodeIterator();
         while (it.hasNext()) {
             long i = it.nextLong();
 
             if (visited.getBoolean(i))
                 continue;
 
             // ArrayList<Long> component = new ArrayList<>();
             long componentNodes = 0;
 
             queue.enqueue(Longs.toByteArray(i));
             visited.set(i);
 
             while (!queue.isEmpty()) {
                 queue.dequeue(byteBuf);
                 final long currentNode = Longs.fromByteArray(byteBuf);
                 // component.add(currentNode);
 
                 if (!byOrigin || graph.getNodeType(currentNode) == Node.Type.ORI)
                     componentNodes += 1;
 
                 final LazyLongIterator iterator = graph.successors(currentNode);
                 long succ;
                 while ((succ = iterator.nextLong()) != -1) {
                     if (visited.getBoolean(succ))
                         continue;
                     visited.set(succ);
                     queue.enqueue(Longs.toByteArray(succ));
                 }
 
                 pl.update();
             }
 
             /*
              * if (component.size() > 0) { components.add(component); }
              */
             if (componentNodes > 0)
                 componentDistribution.merge(componentNodes, 1L, Long::sum);
         }
         pl.done();
         // return components;
         return componentDistribution;
     }
 
     private static void printDistribution(ArrayList<ArrayList<Long>> components, Formatter out) {
         TreeMap<Long, Long> distribution = new TreeMap<>();
         for (ArrayList<Long> component : components) {
             distribution.merge((long) component.size(), 1L, Long::sum);
         }
 
         for (Map.Entry<Long, Long> entry : distribution.entrySet()) {
             out.format("%d %d\n", entry.getKey(), entry.getValue());
         }
         out.close();
     }
 
     private static void printLargestComponent(ArrayList<ArrayList<Long>> components, Formatter out) {
         int indexLargest = 0;
         for (int i = 1; i < components.size(); ++i) {
             if (components.get(i).size() > components.get(indexLargest).size())
                 indexLargest = i;
         }
 
         ArrayList<Long> component = components.get(indexLargest);
         for (Long node : component) {
             out.format("%d\n", node);
         }
         out.close();
     }
 
     private static void printAllComponents(ArrayList<ArrayList<Long>> components, Formatter out) {
         for (int i = 1; i < components.size(); ++i) {
             ArrayList<Long> component = components.get(i);
             for (Long node : component) {
                 out.format("%d ", node);
             }
             out.format("\n");
         }
         out.close();
     }
 
     public static void main(String[] args) {
         JSAPResult config = parse_args(args);
 
         String graphPath = config.getString("graphPath");
         String outdirPath = config.getString("outdir");
         String nodeTypes = config.getString("nodeTypes");
         boolean byOrigin = config.getBoolean("byOrigins");
 
         ConnectedComponents connectedComponents = new ConnectedComponents();
         try {
             connectedComponents.load_graph(graphPath, nodeTypes);
         } catch (IOException e) {
             System.out.println("Could not load graph: " + e);
             System.exit(2);
         }
 
         ProgressLogger logger = new ProgressLogger();
         // noinspection ResultOfMethodCallIgnored
         new File(outdirPath).mkdirs();
         try {
             // ArrayList<ArrayList<Long>> components = connectedComponents.compute(logger);
             // components.sort(Comparator.comparing(ArrayList<Long>::size).reversed());
 
             // printDistribution(components, new Formatter(outdirPath + "/distribution.txt"));
             // printLargestComponent(components, new Formatter(outdirPath + "/largest_component.txt"));
             // printAllComponents(components, new Formatter(outdirPath + "/all_components.txt"));
 
             HashMap<Long, Long> componentDistribution = connectedComponents.compute(logger, byOrigin);
             PrintWriter f = new PrintWriter(new FileWriter(outdirPath + "/distribution.txt"));
             TreeMap<Long, Long> sortedDistribution = new TreeMap<>(componentDistribution);
             for (Map.Entry<Long, Long> entry : sortedDistribution.entrySet()) {
                 f.println(entry.getKey() + " " + entry.getValue());
             }
             f.close();
 
         } catch (IOException e) {
             e.printStackTrace();
         }
         logger.done();
     }
 }
diff --git a/java/src/main/java/org/softwareheritage/graph/maps/LabelMapBuilder.java b/java/src/main/java/org/softwareheritage/graph/maps/LabelMapBuilder.java
index da9a599..04bde71 100644
--- a/java/src/main/java/org/softwareheritage/graph/maps/LabelMapBuilder.java
+++ b/java/src/main/java/org/softwareheritage/graph/maps/LabelMapBuilder.java
@@ -1,529 +1,527 @@
 package org.softwareheritage.graph.maps;
 
 import com.martiansoftware.jsap.*;
 import it.unimi.dsi.big.webgraph.LazyLongIterator;
 import it.unimi.dsi.big.webgraph.labelling.ArcLabelledImmutableGraph;
 import it.unimi.dsi.big.webgraph.labelling.BitStreamArcLabelledImmutableGraph;
-import it.unimi.dsi.fastutil.BigArrays;
 import it.unimi.dsi.fastutil.Size64;
 import it.unimi.dsi.fastutil.bytes.ByteArrays;
-import it.unimi.dsi.fastutil.io.BinIO;
 import it.unimi.dsi.fastutil.io.FastBufferedInputStream;
-import it.unimi.dsi.fastutil.longs.LongBigArrays;
 import it.unimi.dsi.fastutil.objects.Object2LongFunction;
 import it.unimi.dsi.io.OutputBitStream;
 import it.unimi.dsi.logging.ProgressLogger;
 import it.unimi.dsi.big.webgraph.BVGraph;
 import it.unimi.dsi.big.webgraph.ImmutableGraph;
 import it.unimi.dsi.big.webgraph.NodeIterator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.softwareheritage.graph.labels.DirEntry;
 import org.softwareheritage.graph.labels.SwhLabel;
 
 import java.io.*;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
 public class LabelMapBuilder {
     final static String SORT_BUFFER_SIZE = "40%";
     final static Logger logger = LoggerFactory.getLogger(LabelMapBuilder.class);
 
     String graphPath;
     String outputGraphPath;
     String debugPath;
     String tmpDir;
     ImmutableGraph graph;
     long numNodes;
     long numArcs;
 
     NodeIdMap nodeIdMap;
     Object2LongFunction<byte[]> filenameMph;
     long numFilenames;
     int totalLabelWidth;
 
-    public LabelMapBuilder(String graphPath, String debugPath, String outputGraphPath, String tmpDir) throws IOException {
+    public LabelMapBuilder(String graphPath, String debugPath, String outputGraphPath, String tmpDir)
+            throws IOException {
         this.graphPath = graphPath;
         if (outputGraphPath == null) {
             this.outputGraphPath = graphPath;
         } else {
             this.outputGraphPath = outputGraphPath;
         }
         this.debugPath = debugPath;
         this.tmpDir = tmpDir;
 
         // Load the graph in offline mode to retrieve the number of nodes/edges,
         // then immediately destroy it. XXX: not even needed?
         // ImmutableGraph graphOffline = BVGraph.loadMapped(graphPath);
 
         graph = BVGraph.loadMapped(graphPath);
         numArcs = graph.numArcs();
         numNodes = graph.numNodes();
 
         nodeIdMap = new NodeIdMap(graphPath, numNodes);
 
         filenameMph = NodeIdMap.loadMph(graphPath + "-labels.mph");
         numFilenames = getMPHSize(filenameMph);
         totalLabelWidth = DirEntry.labelWidth(numFilenames);
     }
 
     private static JSAPResult parse_args(String[] args) {
         JSAPResult config = null;
         try {
             SimpleJSAP jsap = new SimpleJSAP(LabelMapBuilder.class.getName(), "", new Parameter[]{
                     new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'g', "graph",
                             "Basename of the compressed graph"),
                     new FlaggedOption("debugPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.NOT_REQUIRED, 'd',
                             "debug-path", "Store the intermediate representation here for debug"),
                     new FlaggedOption("outputGraphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.NOT_REQUIRED, 'o',
                             "output-graph", "Basename of the output graph, same as --graph if not specified"),
 
                     new FlaggedOption("tmpDir", JSAP.STRING_PARSER, "tmp", JSAP.NOT_REQUIRED, 't', "tmp",
                             "Temporary directory path"),});
 
             config = jsap.parse(args);
             if (jsap.messagePrinted()) {
                 System.exit(1);
             }
         } catch (JSAPException e) {
             e.printStackTrace();
         }
         return config;
     }
 
     public static void main(String[] args) throws IOException, InterruptedException {
         JSAPResult config = parse_args(args);
         String graphPath = config.getString("graphPath");
         String outputGraphPath = config.getString("outputGraphPath");
         String tmpDir = config.getString("tmpDir");
         String debugPath = config.getString("debugPath");
 
         LabelMapBuilder builder = new LabelMapBuilder(graphPath, debugPath, outputGraphPath, tmpDir);
 
         logger.info("Loading graph and MPH functions...");
         builder.computeLabelMap();
     }
 
     static long getMPHSize(Object2LongFunction<byte[]> mph) {
         return (mph instanceof Size64) ? ((Size64) mph).size64() : mph.size();
     }
 
     void computeLabelMap() throws IOException, InterruptedException {
         this.loadGraph();
         // this.computeLabelMapSort();
         this.computeLabelMapBsort();
     }
 
     void computeLabelMapSort() throws IOException {
         // Pass the intermediate representation to sort(1) so that we see the labels in the order they will
         // appear in the label file.
         ProcessBuilder processBuilder = new ProcessBuilder();
         processBuilder.command("sort", "-k1,1n", "-k2,2n", // Numerical sort
                 "--numeric-sort", "--buffer-size", SORT_BUFFER_SIZE, "--temporary-directory", tmpDir);
         Process sort = processBuilder.start();
         BufferedOutputStream sort_stdin = new BufferedOutputStream(sort.getOutputStream());
         // BufferedInputStream sort_stdout = new BufferedInputStream(sort.getInputStream());
         FastBufferedInputStream sort_stdout = new FastBufferedInputStream(sort.getInputStream());
 
         final FastBufferedInputStream fbis = new FastBufferedInputStream(System.in);
         hashLabelStream(fbis, new EdgeLabelLineWriter() {
             @Override
             public void writeLine(long src, long dst, long filenameId, int permission) throws IOException {
                 sort_stdin.write((src + "\t" + dst + "\t" + filenameId + "\t" + permission + "\n")
                         .getBytes(StandardCharsets.US_ASCII));
             }
         });
         sort_stdin.close();
 
         EdgeLabelLineIterator mapLines = new TextualEdgeLabelLineIterator(sort_stdout);
         writeLabels(mapLines);
         logger.info("Done");
     }
 
     void computeLabelMapBsort() throws IOException, InterruptedException {
         // Pass the intermediate representation to bsort(1) so that we see the labels in the order they will
         // appear in the label file.
 
         String tmpFile = tmpDir + "/labelsToSort.bin";
         final FastBufferedInputStream fbis = new FastBufferedInputStream(System.in);
         final DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(tmpFile)));
 
         // Number of bytes to represent a node.
         final int nodeBytes = (Long.SIZE - Long.numberOfLeadingZeros(graph.numNodes())) / 8 + 1;
         ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
         logger.info("Writing labels to a packed binary files (node bytes: {})", nodeBytes);
 
         hashLabelStream(fbis, new EdgeLabelLineWriter() {
             @Override
             public void writeLine(long src, long dst, long filenameId, int permission) throws IOException {
                 buffer.putLong(0, src);
                 out.write(buffer.array(), Long.BYTES - nodeBytes, nodeBytes);
                 buffer.putLong(0, dst);
                 out.write(buffer.array(), Long.BYTES - nodeBytes, nodeBytes);
                 out.writeLong(filenameId);
                 out.writeInt(permission);
             }
         });
 
         ProcessBuilder processBuilder = new ProcessBuilder();
         processBuilder.command("/home/seirl/bsort/src/bsort", "-v", "-r",
                 String.valueOf(nodeBytes * 2 + Long.BYTES + Integer.BYTES), "-k", String.valueOf(nodeBytes * 2),
                 tmpFile);
         Process sort = processBuilder.start();
         sort.waitFor();
 
         final DataInputStream sortedLabels = new DataInputStream(new BufferedInputStream(new FileInputStream(tmpFile)));
         BinaryEdgeLabelLineIterator mapLines = new BinaryEdgeLabelLineIterator(sortedLabels, nodeBytes);
         writeLabels(mapLines);
 
         logger.info("Done");
     }
 
     void loadGraph() throws IOException {
     }
 
     void hashLabelStream(FastBufferedInputStream input, EdgeLabelLineWriter writer) throws IOException {
         // Compute intermediate representation and write it on :
         // "<src node id> <dst node id> <label ids>\n"
         ProgressLogger plInter = new ProgressLogger(logger, 10, TimeUnit.SECONDS);
         plInter.itemsName = "edges";
         plInter.expectedUpdates = this.numArcs;
         plInter.start("Hashing the label stream");
 
         var charset = StandardCharsets.US_ASCII;
         byte[] array = new byte[1024];
         for (long line = 0;; line++) {
             int start = 0, len;
             while ((len = input.readLine(array, start, array.length - start,
                     FastBufferedInputStream.ALL_TERMINATORS)) == array.length - start) {
                 start += len;
                 array = ByteArrays.grow(array, array.length + 1);
             }
             if (len == -1)
                 break; // EOF
             final int lineLength = start + len;
 
             // Skip whitespace at the start of the line.
             int offset = 0;
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
             if (offset == lineLength) {
                 continue;
             }
             if (array[0] == '#')
                 continue;
 
             // Scan source id.
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             final byte[] ss = Arrays.copyOfRange(array, start, offset);
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
             if (offset == lineLength) {
                 logger.error("Error at line " + line + ": no target");
                 continue;
             }
 
             // Scan target ID
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             final byte[] ts = Arrays.copyOfRange(array, start, offset);
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
             if (offset == lineLength)
                 continue; // No label, skip
 
             // Scan label
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             final byte[] ls = Arrays.copyOfRange(array, start, offset);
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
             // Scan permission
             int permission = 0;
             if (offset < lineLength) {
                 start = offset;
                 while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                     offset++;
                 permission = Integer.parseInt(new String(array, start, offset - start, charset));
             }
 
             // System.err.format("DEBUG: read %s %s %s %d\n", ss, ts, ls, permission);
 
             long srcNode = nodeIdMap.getNodeId(ss);
             long dstNode = nodeIdMap.getNodeId(ts);
             long filenameId = filenameMph.getLong(ls);
 
             writer.writeLine(srcNode, dstNode, filenameId, permission);
             plInter.lightUpdate();
         }
         plInter.done();
     }
 
     void writeLabels(EdgeLabelLineIterator mapLines) throws IOException {
         // Get the sorted output and write the labels and label offsets
         ProgressLogger plLabels = new ProgressLogger(logger, 10, TimeUnit.SECONDS);
         plLabels.itemsName = "edges";
         plLabels.expectedUpdates = this.numArcs;
         plLabels.start("Writing the labels to the label file.");
 
         FileWriter debugFile = null;
         if (debugPath != null) {
             debugFile = new FileWriter(debugPath);
         }
 
         OutputBitStream labels = new OutputBitStream(
                 new File(outputGraphPath + "-labelled" + BitStreamArcLabelledImmutableGraph.LABELS_EXTENSION));
         OutputBitStream offsets = new OutputBitStream(
                 new File(outputGraphPath + "-labelled" + BitStreamArcLabelledImmutableGraph.LABEL_OFFSETS_EXTENSION));
         offsets.writeGamma(0);
 
         EdgeLabelLine line = new EdgeLabelLine(-1, -1, -1, -1);
 
         NodeIterator it = graph.nodeIterator();
         boolean started = false;
 
         ArrayList<DirEntry> labelBuffer = new ArrayList<>(128);
         while (it.hasNext()) {
             long srcNode = it.nextLong();
 
             int bits = 0;
             LazyLongIterator s = it.successors();
             long dstNode;
             while ((dstNode = s.nextLong()) >= 0) {
                 while (line != null && line.srcNode <= srcNode && line.dstNode <= dstNode) {
                     if (line.srcNode == srcNode && line.dstNode == dstNode) {
                         labelBuffer.add(new DirEntry(line.filenameId, line.permission));
 
                         if (debugFile != null) {
                             debugFile.write(line.srcNode + " " + line.dstNode + " " + line.filenameId + " "
                                     + line.permission + "\n");
                         }
                     }
 
                     if (!mapLines.hasNext())
                         break;
 
                     line = mapLines.next();
                     if (!started) {
                         plLabels.start("Writing label map to file...");
                         started = true;
                     }
                 }
 
                 SwhLabel l = new SwhLabel("edgelabel", totalLabelWidth, labelBuffer.toArray(new DirEntry[0]));
                 labelBuffer.clear();
                 bits += l.toBitStream(labels, -1);
                 plLabels.lightUpdate();
             }
             offsets.writeGamma(bits);
         }
 
         labels.close();
         offsets.close();
         plLabels.done();
         if (debugFile != null) {
             debugFile.close();
         }
 
         PrintWriter pw = new PrintWriter(
                 new FileWriter((new File(outputGraphPath)).getName() + "-labelled.properties"));
         pw.println(ImmutableGraph.GRAPHCLASS_PROPERTY_KEY + " = " + BitStreamArcLabelledImmutableGraph.class.getName());
         pw.println(BitStreamArcLabelledImmutableGraph.LABELSPEC_PROPERTY_KEY + " = " + SwhLabel.class.getName()
                 + "(DirEntry," + totalLabelWidth + ")");
         pw.println(ArcLabelledImmutableGraph.UNDERLYINGGRAPH_PROPERTY_KEY + " = " + outputGraphPath);
         pw.close();
     }
 
     public abstract static class EdgeLabelLineWriter {
         public abstract void writeLine(long src, long dst, long filenameId, int permission) throws IOException;
     }
 
     public static class EdgeLabelLine {
         public long srcNode;
         public long dstNode;
         public long filenameId;
         public int permission;
 
         public EdgeLabelLine(long labelSrcNode, long labelDstNode, long labelFilenameId, int labelPermission) {
             this.srcNode = labelSrcNode;
             this.dstNode = labelDstNode;
             this.filenameId = labelFilenameId;
             this.permission = labelPermission;
         }
     }
 
     public abstract static class EdgeLabelLineIterator implements Iterator<EdgeLabelLine> {
         @Override
         public abstract boolean hasNext();
         @Override
         public abstract EdgeLabelLine next();
     }
 
     public static class ScannerEdgeLabelLineIterator extends EdgeLabelLineIterator {
         private final Scanner scanner;
 
         public ScannerEdgeLabelLineIterator(InputStream input) {
             this.scanner = new Scanner(input);
         }
 
         @Override
         public boolean hasNext() {
             return this.scanner.hasNext();
         }
 
         @Override
         public EdgeLabelLine next() {
             String line = scanner.nextLine();
             String[] parts = line.split("\\t");
             return new EdgeLabelLine(Long.parseLong(parts[0]), Long.parseLong(parts[1]), Long.parseLong(parts[2]),
                     Integer.parseInt(parts[3]));
 
             /*
              * String line = scanner.nextLine(); long src = scanner.nextLong(); long dst = scanner.nextLong();
              * long label = scanner.nextLong(); int permission = scanner.nextInt(); return new
              * EdgeLabelLine(src, dst, label, permission);
              */
         }
     }
 
     public static class TextualEdgeLabelLineIterator extends EdgeLabelLineIterator {
         private final FastBufferedInputStream input;
         private final Charset charset;
         private byte[] array;
         boolean finished;
 
         public TextualEdgeLabelLineIterator(FastBufferedInputStream input) {
             this.input = input;
             this.finished = false;
             this.charset = StandardCharsets.US_ASCII;
             this.array = new byte[1024];
         }
 
         @Override
         public boolean hasNext() {
             return !this.finished;
         }
 
         @Override
         public EdgeLabelLine next() {
             int start = 0, len;
             try {
                 while ((len = input.readLine(array, start, array.length - start,
                         FastBufferedInputStream.ALL_TERMINATORS)) == array.length - start) {
                     start += len;
                     array = ByteArrays.grow(array, array.length + 1);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
                 return null;
             }
             if (len == -1) {
                 finished = true;
                 return null;
             }
             final int lineLength = start + len;
 
             int offset = 0;
 
             // Scan source id.
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             long src = Long.parseLong(new String(array, start, offset - start, charset));
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
 
             // Scan target ID
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             long dst = Long.parseLong(new String(array, start, offset - start, charset));
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
 
             // Scan label
             start = offset;
             while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                 offset++;
             long label = Long.parseLong(new String(array, start, offset - start, charset));
 
             // Skip whitespace between identifiers.
             while (offset < lineLength && array[offset] >= 0 && array[offset] <= ' ')
                 offset++;
 
             // Scan permission
             int permission = 0;
             if (offset < lineLength) {
                 start = offset;
                 while (offset < lineLength && (array[offset] < 0 || array[offset] > ' '))
                     offset++;
                 permission = Integer.parseInt(new String(array, start, offset - start, charset));
             }
 
             return new EdgeLabelLine(src, dst, label, permission);
         }
     }
 
     public static class BinaryEdgeLabelLineIterator extends EdgeLabelLineIterator {
         private final int nodeBytes;
         DataInputStream stream;
         boolean finished;
         ByteBuffer buffer;
 
         public BinaryEdgeLabelLineIterator(DataInputStream stream, int nodeBytes) {
             this.stream = stream;
             this.nodeBytes = nodeBytes;
             this.buffer = ByteBuffer.allocate(Long.BYTES);
             this.finished = false;
         }
 
         @Override
         public boolean hasNext() {
             return !finished;
         }
 
         @Override
         public EdgeLabelLine next() {
             try {
                 // long src = stream.readLong();
                 // long dst = stream.readLong();
                 stream.readFully(this.buffer.array(), Long.BYTES - nodeBytes, nodeBytes);
                 this.buffer.position(0);
                 long src = this.buffer.getLong();
                 this.buffer.clear();
 
                 stream.readFully(this.buffer.array(), Long.BYTES - nodeBytes, nodeBytes);
                 this.buffer.position(0);
                 long dst = this.buffer.getLong();
                 this.buffer.clear();
 
                 long label = stream.readLong();
                 int perm = stream.readInt();
                 return new EdgeLabelLine(src, dst, label, perm);
             } catch (EOFException e) {
                 finished = true;
                 return null;
             } catch (IOException e) {
                 e.printStackTrace();
                 return null;
             }
         }
     }
 }
diff --git a/java/src/main/java/org/softwareheritage/graph/maps/NodeIdMap.java b/java/src/main/java/org/softwareheritage/graph/maps/NodeIdMap.java
index a895daf..46a566b 100644
--- a/java/src/main/java/org/softwareheritage/graph/maps/NodeIdMap.java
+++ b/java/src/main/java/org/softwareheritage/graph/maps/NodeIdMap.java
@@ -1,188 +1,188 @@
 package org.softwareheritage.graph.maps;
 
 import it.unimi.dsi.fastutil.Size64;
 import it.unimi.dsi.fastutil.io.BinIO;
 import it.unimi.dsi.fastutil.longs.LongBigList;
 import it.unimi.dsi.fastutil.objects.Object2LongFunction;
 import it.unimi.dsi.util.ByteBufferLongBigList;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.SWHID;
 
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 
 /**
  * Mapping between internal long node id and external SWHID.
  * <p>
  * The SWHID -> node mapping is obtained from hashing the SWHID with a MPH, then permuting it using
  * an mmap()-ed .order file containing the graph permutation.
  *
  * The node -> SWHID reverse mapping is pre-computed and dumped on disk in the
  * {@link NodeMapBuilder} class, then it is loaded here using mmap().
  *
  * @author The Software Heritage developers
  * @see NodeMapBuilder
  */
 
 public class NodeIdMap {
     /** Fixed length of binary SWHID buffer */
     public static final int SWHID_BIN_SIZE = 22;
 
     /** Graph path and basename */
     String graphPath;
     /** Number of ids to map */
     long nbIds;
 
     /** mmap()-ed NODE_TO_SWHID file */
     MapFile nodeToSwhMap;
 
     /** Minimal perfect hash (MPH) function SWHID -> initial order */
     Object2LongFunction<byte[]> mph;
     /** mmap()-ed long list with the permutation initial order -> graph order */
     LongBigList orderMap;
     /** FileInputStream containing the permutation */
     FileInputStream orderInputStream;
 
     /**
      * Constructor.
      *
      * @param graphPath full graph path
      * @param nbNodes number of nodes in the graph
      */
     public NodeIdMap(String graphPath, long nbNodes) throws IOException {
         this.graphPath = graphPath;
         this.nbIds = nbNodes;
 
         // node -> SWHID
         this.nodeToSwhMap = new MapFile(graphPath + Graph.NODE_TO_SWHID, SWHID_BIN_SIZE);
 
         // SWHID -> node
         this.mph = loadMph(graphPath + ".mph");
         this.orderInputStream = new FileInputStream(graphPath + ".order");
         this.orderMap = ByteBufferLongBigList.map(orderInputStream.getChannel());
     }
 
     @SuppressWarnings("unchecked")
     public static Object2LongFunction<byte[]> loadMph(String path) throws IOException {
         Object obj;
         try {
             obj = BinIO.loadObject(path);
         } catch (ClassNotFoundException e) {
             throw new IOException(e.getMessage());
         }
 
         Object2LongFunction<byte[]> res = (Object2LongFunction<byte[]>) obj;
 
         // Backward-compatibility for old maps parametrized with <String>.
         // New maps should be parametrized with <byte[]>, which is faster.
         try {
             // Try to call it with bytes, will fail if it's a O2LF<String>.
             res.getLong("42".getBytes(StandardCharsets.UTF_8));
         } catch (ClassCastException e) {
             class StringCompatibleByteFunction implements Object2LongFunction<byte[]>, Size64 {
                 private final Object2LongFunction<String> legacyFunction;
 
                 public StringCompatibleByteFunction(Object2LongFunction<String> legacyFunction) {
                     this.legacyFunction = legacyFunction;
                 }
 
                 @Override
                 public long getLong(Object o) {
                     byte[] bi = (byte[]) o;
                     return legacyFunction.getLong(new String(bi, StandardCharsets.UTF_8));
                 }
 
                 @Override
                 public int size() {
                     return legacyFunction.size();
                 }
 
                 @Override
                 public long size64() {
                     return (legacyFunction instanceof Size64)
                             ? ((Size64) legacyFunction).size64()
                             : legacyFunction.size();
                 }
             }
 
             Object2LongFunction<String> mphLegacy = (Object2LongFunction<String>) obj;
             return new StringCompatibleByteFunction(mphLegacy);
             /*
              * res = (o -> { byte[] bi = (byte[]) o; return mphLegacy.getLong(new String(bi,
              * StandardCharsets.UTF_8)); });
              */
         }
         // End of backward-compatibility block
 
         return res;
     }
 
     /**
-     * Converts byte-form SWHID to corresponding long node id.
-     * Low-level function, does not check if the SWHID is valid.
+     * Converts byte-form SWHID to corresponding long node id. Low-level function, does not check if the
+     * SWHID is valid.
      *
      * @param swhid node represented as bytes
      * @return corresponding node as a long id
      */
     public long getNodeId(byte[] swhid) {
         // 1. Hash the SWHID with the MPH to get its original ID
         long origNodeId = mph.getLong(swhid);
 
         // 2. Use the order permutation to get the position in the permuted graph
         return this.orderMap.getLong(origNodeId);
     }
 
     /**
      * Converts SWHID to corresponding long node id.
      *
      * @param swhid node represented as a {@link SWHID}
      * @param checkExists if true, error if the SWHID is not present in the graph, if false the check
      *            will be skipped and invalid data will be returned for non-existing SWHIDs.
      * @return corresponding node as a long id
      * @see SWHID
      */
     public long getNodeId(SWHID swhid, boolean checkExists) {
         // Convert the SWHID to bytes and call getNodeId()
         long nodeId = getNodeId(swhid.toString().getBytes(StandardCharsets.US_ASCII));
 
         // Check that the position effectively corresponds to a real node using the reverse map.
         // This is necessary because the MPH makes no guarantees on whether the input SWHID is valid.
         if (!checkExists || getSWHID(nodeId).equals(swhid)) {
             return nodeId;
         } else {
             throw new IllegalArgumentException("Unknown SWHID: " + swhid);
         }
     }
 
     public long getNodeId(SWHID swhid) {
         return getNodeId(swhid, true);
     }
 
     /**
      * Converts a node long id to corresponding SWHID.
      *
      * @param nodeId node as a long id
      * @return corresponding node as a {@link SWHID}
      * @see SWHID
      */
     public SWHID getSWHID(long nodeId) {
         /*
          * Each line in NODE_TO_SWHID is formatted as: swhid The file is ordered by nodeId, meaning node0's
          * swhid is at line 0, hence we can read the nodeId-th line to get corresponding swhid
          */
         if (nodeId < 0 || nodeId >= nbIds) {
             throw new IllegalArgumentException("Node id " + nodeId + " should be between 0 and " + nbIds);
         }
 
         return SWHID.fromBytes(nodeToSwhMap.readAtLine(nodeId));
     }
 
     /**
      * Closes the mapping files.
      */
     public void close() throws IOException {
         orderInputStream.close();
         nodeToSwhMap.close();
     }
 }