diff --git a/CHANGES b/CHANGES
index 19e8512..cf1954d 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,16 @@
+2.7.0
+
+- New MappedFrontCodedStringBigList makes it possible to access
+  a list of string using memory mapping.
+
+- TransformationStrategies.fixedLong() now is truly lexicographical, even
+  on negative numbers. Unfortunately, this change made it necessary to
+  bump the serial version of the class, which is the same of
+  TransformationStrategies.rawFixedLong(), which means that structures
+  serialized using both strategies will not be deserializable.
+
+- Fixed wrong indexing in LongSet views of subvectors in AbstractBitVector.
+
 2.6.17
 
 - New FileLines*Iterable classes replacing older FileLines*Collection
diff --git a/README.md b/README.md
index ec7216c..ea2d605 100644
--- a/README.md
+++ b/README.md
@@ -7,4 +7,10 @@ the DSI (Dipartimento di Scienze dell'Informazione, i.e., Information
 Sciences Department), now DI (Dipartimento di Informatica, i.e.,
 Informatics Department), of the Università degli Studi di Milano.
 
+Building
+--------
+
+You need [Ant](https://ant.apache.org/) and [Ivy](https://ant.apache.org/ivy/).
+Then, run `ant ivy-setupjars jar`.
+
 seba (<mailto:sebastiano.vigna@unimi.it>)
diff --git a/bnd/biz.aQute.bnd-5.2.0.jar b/bnd/biz.aQute.bnd-5.2.0.jar
new file mode 100644
index 0000000..b1e2a04
Binary files /dev/null and b/bnd/biz.aQute.bnd-5.2.0.jar differ
diff --git a/build.properties b/build.properties
index 46eb7db..99b5609 100644
--- a/build.properties
+++ b/build.properties
@@ -1,4 +1,4 @@
-version=2.6.17
+version=2.7.0
 
 build.sysclasspath=ignore
 
@@ -17,14 +17,14 @@ build=build
 instrumented=instr
 
 j2se.apiurl=https://docs.oracle.com/javase/8/docs/api/
-fastutil.apiurl=http://fastutil.di.unimi.it/docs/
+fastutil.apiurl=https://fastutil.di.unimi.it/docs/
 jsap.apiurl=http://www.martiansoftware.com/jsap/doc/javadoc/
 junit.apiurl=https://junit.org/junit4/javadoc/latest/
-log4j.apiurl=http://logging.apache.org/log4j/1.2/apidocs/
-slf4j.apiurl=http://www.slf4j.org/apidocs/
+log4j.apiurl=https://logging.apache.org/log4j/1.2/apidocs/
+slf4j.apiurl=https://www.slf4j.org/apidocs/
 commons-configuration2.apiurl=https://commons.apache.org/proper/commons-configuration/apidocs/
-commons-io.apiurl=http://commons.apache.org/proper/commons-io/javadocs/api-release/
-commons-lang3.apiurl=http://commons.apache.org/proper/commons-lang/javadocs/api-release/
+commons-io.apiurl=https://commons.apache.org/proper/commons-io/javadocs/api-release/
+commons-lang3.apiurl=https://commons.apache.org/proper/commons-lang/javadocs/api-release/
 commons-collections4.apiurl=https://commons.apache.org/proper/commons-collections/javadocs/api-4.4/
 commons-math3.apiurl=https://commons.apache.org/proper/commons-math/javadocs/api-3.6.1/
 guava.apiurl=https://javadoc.io/doc/com.google.guava/guava/latest/index.html
diff --git a/build.xml b/build.xml
index 7624ef6..1e39541 100644
--- a/build.xml
+++ b/build.xml
@@ -62,7 +62,7 @@
 	</target>
 
 	<target name="osgi" depends="resolve,compile">
-		<taskdef resource="aQute/bnd/ant/taskdef.properties" classpath="bnd/bnd-2.4.0.jar"/>
+		<taskdef resource="aQute/bnd/ant/taskdef.properties" classpath="bnd/biz.aQute.bnd-5.2.0.jar"/>
 		<bnd
 			classpath="${build}"
 			eclipse="false"
diff --git a/ivy.xml b/ivy.xml
index 1f14170..595d296 100644
--- a/ivy.xml
+++ b/ivy.xml
@@ -14,16 +14,16 @@
 	</publications>
 
 	<dependencies>
+		<dependency org="org.slf4j" name="slf4j-api" rev="1.7.30" force="true"/>
+		<dependency org="ch.qos.logback" name="logback-core" rev="1.2.3" conf="runtime" force="true"/>
+		<dependency org="ch.qos.logback" name="logback-classic" rev="1.2.3" conf="runtime" force="true"/>
+
 		<dependency org="it.unimi.dsi" name="fastutil" rev="latest.release" />
 		<dependency org="it.unimi.di" name="jsap" rev="20210129"/>
 		<dependency org="junit" name="junit" rev="latest.release" conf="test"/>
 		<dependency org="org.apache.commons" name="commons-configuration2" rev="latest.release"/>
 		<dependency org="org.apache.commons" name="commons-math3" rev="latest.release"/>
 		<dependency org="com.google.guava" name="guava" rev="latest.release"/>
-		<dependency org="org.slf4j" name="slf4j-api" rev="1.7.30" force="true"/>
-
-		<dependency org="ch.qos.logback" name="logback-core" rev="1.2.3" conf="runtime" force="true"/>
-		<dependency org="ch.qos.logback" name="logback-classic" rev="1.2.3" conf="runtime" force="true"/>
 
 		<dependency org="org.apache.commons" name="commons-collections4" rev="latest.release" conf="test"/>
 		<dependency org="com.github.luben" name="zstd-jni" rev="latest.release" conf="test"/>
diff --git a/slow/it/unimi/dsi/big/util/FrontCodedStringBigListSlowTest.java b/slow/it/unimi/dsi/big/util/FrontCodedStringBigListSlowTest.java
new file mode 100644
index 0000000..d63491d
--- /dev/null
+++ b/slow/it/unimi/dsi/big/util/FrontCodedStringBigListSlowTest.java
@@ -0,0 +1,63 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2010-2022 Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.big.util;
+
+import static org.junit.Assert.assertEquals;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Iterator;
+import java.util.SplittableRandom;
+
+import org.junit.Test;
+
+import it.unimi.dsi.lang.MutableString;
+
+public class FrontCodedStringBigListSlowTest {
+	@Test
+	public void testLarge() {
+		final long size = (1L << 31) + 10000;
+		final FrontCodedStringBigList byteArrayFrontCodedBigList = new FrontCodedStringBigList(new Iterator<String>() {
+			SplittableRandom r = new SplittableRandom(0);
+			long i = 0;
+
+			@Override
+			public boolean hasNext() {
+				return i < size;
+			}
+
+			@Override
+			public String next() {
+				i++;
+				return new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1);
+			}
+		}, 10, true);
+		SplittableRandom r = new SplittableRandom(0);
+		for (long i = 0; i < size; i++) {
+			assertEquals(new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1), byteArrayFrontCodedBigList.get(i));
+		}
+		r = new SplittableRandom(0);
+		final MutableString s = new MutableString();
+		for (long i = 0; i < size; i++) {
+			byteArrayFrontCodedBigList.get(i, s);
+			assertEquals(new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1), s);
+		}
+	}
+
+}
diff --git a/slow/it/unimi/dsi/big/util/ImmutableExternalPrefixMapSlowTest.java b/slow/it/unimi/dsi/big/util/ImmutableExternalPrefixMapSlowTest.java
index 4f3b0a4..48d7f5c 100644
--- a/slow/it/unimi/dsi/big/util/ImmutableExternalPrefixMapSlowTest.java
+++ b/slow/it/unimi/dsi/big/util/ImmutableExternalPrefixMapSlowTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/slow/it/unimi/dsi/big/util/LiterallySignedStringMapSlowTest.java b/slow/it/unimi/dsi/big/util/LiterallySignedStringMapSlowTest.java
new file mode 100644
index 0000000..d0049cb
--- /dev/null
+++ b/slow/it/unimi/dsi/big/util/LiterallySignedStringMapSlowTest.java
@@ -0,0 +1,82 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2002-2022 Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.big.util;
+
+import org.junit.Test;
+
+import it.unimi.dsi.fastutil.Size64;
+import it.unimi.dsi.fastutil.objects.AbstractObject2LongFunction;
+import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
+import it.unimi.dsi.lang.MutableString;
+
+public class LiterallySignedStringMapSlowTest {
+	private final class LargeFunction extends AbstractObject2LongFunction<String> implements Size64 {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public long getLong(final Object key) {
+			try {
+				final long l = Long.parseLong(key.toString());
+				return l < 1L << 31 ? l : -1;
+			}
+			catch(final Exception e) {
+				return -1;
+			}
+		}
+
+		@Override
+		public boolean containsKey(final Object key) {
+			try {
+				final long l = Long.parseLong(key.toString());
+				return l < 1L << 31;
+			}
+			catch(final Exception e) {
+				return false;
+			}
+		}
+
+		@Override
+		@Deprecated
+		public int size() {
+			return Integer.MAX_VALUE;
+		}
+
+		@Override
+		public long size64() {
+			return 1L << 31;
+		}
+	}
+
+	@Test
+	public void testLarge() {
+		new LiterallySignedStringMap(new LargeFunction(), new AbstractObjectBigList<MutableString>() {
+
+			@Override
+			public MutableString get(final long index) {
+				return new MutableString(Long.toString(index));
+			}
+
+			@Override
+			public long size64() {
+				return 1L << 31;
+			}
+		});
+	}
+}
diff --git a/slow/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapSlowTest.java b/slow/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapSlowTest.java
new file mode 100644
index 0000000..e1331f1
--- /dev/null
+++ b/slow/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapSlowTest.java
@@ -0,0 +1,83 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2002-2022 Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.big.util;
+
+import org.junit.Test;
+
+import it.unimi.dsi.fastutil.Size64;
+import it.unimi.dsi.fastutil.objects.AbstractObject2LongFunction;
+import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
+
+public class ShiftAddXorSignedStringMapSlowTest {
+	private final class LargeFunction extends AbstractObject2LongFunction<String> implements Size64 {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public long getLong(final Object key) {
+			try {
+				final long l = Long.parseLong((String)key);
+				return l < 1L << 31 ? l : -1;
+			}
+			catch(final Exception e) {
+				return -1;
+			}
+		}
+
+		@Override
+		public boolean containsKey(final Object key) {
+			try {
+				final long l = Long.parseLong((String)key);
+				return l < 1L << 31;
+			}
+			catch(final Exception e) {
+				return false;
+			}
+		}
+
+		@Override
+		@Deprecated
+		public int size() {
+			return Integer.MAX_VALUE;
+		}
+
+		@Override
+		public long size64() {
+			return 1L << 31;
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	@Test
+	public void testLarge() {
+		new ShiftAddXorSignedStringMap(new AbstractObjectBigList<String>() {
+
+			@Override
+			public String get(final long index) {
+				return Long.toString(index);
+			}
+
+			@Override
+			public long size64() {
+				return 1L << 31;
+			}
+		}.iterator(), new LargeFunction(), 1);
+	}
+
+}
diff --git a/slow/it/unimi/dsi/util/HyperLogLogCounterArraySlowTest.java b/slow/it/unimi/dsi/util/HyperLogLogCounterArraySlowTest.java
new file mode 100644
index 0000000..42dc619
--- /dev/null
+++ b/slow/it/unimi/dsi/util/HyperLogLogCounterArraySlowTest.java
@@ -0,0 +1,118 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2010-2022 Paolo Boldi and Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.util;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import it.unimi.dsi.logging.ProgressLogger;
+
+public class HyperLogLogCounterArraySlowTest {
+	@Test
+	public void testLarge() {
+		final int numTrials = 10;
+
+		for(final long size: new long[] { 1000000000, 4000000000L })
+			for(final int log2m: new int[] { 6, 8, 12 }) {
+				final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
+				int correct = 0;
+				for (int trial = 0; trial < numTrials; trial++) {
+					final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
+					final long incr = (1L << 60) / size;
+					long x = Long.MIN_VALUE;
+					for(long i = size; i-- != 0;) {
+						a.add(0, x);
+						x += incr;
+					}
+
+					//System.err.println("Trial " + trial + ", size " + size + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
+					if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
+				}
+
+				//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
+				assertTrue(correct + " < " + 9, correct >= 9);
+			}
+	}
+
+
+	@Test
+	public void testExtreme() {
+		final int numTrials = 20, mustBeCorrect = 18;
+		final ProgressLogger pl = new ProgressLogger();
+
+		for(final int log2m: new int[] { 6, 8, 12 }) {
+			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
+			int correct = 0;
+			final long size = 3L * 1024 * 1024 * 1024;
+			for (int trial = 0; trial < numTrials; trial++) {
+				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
+				pl.start();
+				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 4 != 0) a.add(0, i);
+				pl.stop();
+				pl.count = size;
+				//System.err.println(pl);
+				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
+				if (Math.abs(size - a.count(0)) < 2 * rsd * size) correct++;
+			}
+
+			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
+			assertTrue(correct + " < " + mustBeCorrect, correct >= mustBeCorrect);
+		}
+
+		for(final int log2m: new int[] { 6, 8, 12 }) {
+			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
+			int correct = 0;
+			final long size = 7L * 512 * 1024 * 1024;
+			for (int trial = 0; trial < numTrials; trial++) {
+				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
+				pl.start();
+				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 8 != 0) a.add(0, i);
+				pl.stop();
+				pl.count = size;
+				//System.err.println(pl);
+				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
+				if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
+			}
+
+			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
+			assertTrue(correct + " < " + mustBeCorrect, mustBeCorrect >= 9);
+		}
+
+		for(final int log2m: new int[] { 6, 8, 12 }) {
+			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
+			int correct = 0;
+			final long size = 8L * 1024 * 1024 * 1024;
+			for (int trial = 0; trial < numTrials; trial++) {
+				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
+				pl.start();
+				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 8 != 0) a.add(0, i);
+				pl.stop();
+				pl.count = size;
+				//System.err.println(pl);
+				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
+				if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
+			}
+
+			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
+			assertTrue(correct + " < " + mustBeCorrect, mustBeCorrect >= 9);
+		}
+	}
+}
diff --git a/src/it/unimi/dsi/Util.java b/src/it/unimi/dsi/Util.java
index 4ddd4f7..3d79386 100644
--- a/src/it/unimi/dsi/Util.java
+++ b/src/it/unimi/dsi/Util.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/io/FileLinesByteArrayCollection.java b/src/it/unimi/dsi/big/io/FileLinesByteArrayCollection.java
index 05df136..0253c8f 100644
--- a/src/it/unimi/dsi/big/io/FileLinesByteArrayCollection.java
+++ b/src/it/unimi/dsi/big/io/FileLinesByteArrayCollection.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/io/FileLinesCollection.java b/src/it/unimi/dsi/big/io/FileLinesCollection.java
index 0b35981..d3ae901 100644
--- a/src/it/unimi/dsi/big/io/FileLinesCollection.java
+++ b/src/it/unimi/dsi/big/io/FileLinesCollection.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/AbstractPrefixMap.java b/src/it/unimi/dsi/big/util/AbstractPrefixMap.java
index e3dab0a..fd8dff3 100644
--- a/src/it/unimi/dsi/big/util/AbstractPrefixMap.java
+++ b/src/it/unimi/dsi/big/util/AbstractPrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -38,8 +38,11 @@ import it.unimi.dsi.util.LongIntervals;
 
 public abstract class AbstractPrefixMap extends AbstractObject2LongFunction<CharSequence> implements PrefixMap<MutableString>, Serializable {
 	private static final long serialVersionUID = 1L;
+	/** A cached view of the map as a range map. */
 	protected Object2ObjectFunction<CharSequence, LongInterval> rangeMap;
+	/** A cached view of the map as a prefix map. */
 	protected AbstractObject2ObjectFunction<LongInterval, MutableString> prefixMap;
+	/** A cached view of the map as a list of mutable strings. */
 	protected ObjectBigList<MutableString> list;
 
 	// We must guarantee that, unless the user says otherwise, the default return value is -1.
diff --git a/src/it/unimi/dsi/big/util/FrontCodedStringBigList.java b/src/it/unimi/dsi/big/util/FrontCodedStringBigList.java
index d8c8670..1441d03 100644
--- a/src/it/unimi/dsi/big/util/FrontCodedStringBigList.java
+++ b/src/it/unimi/dsi/big/util/FrontCodedStringBigList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -19,6 +19,8 @@
 
 package it.unimi.dsi.big.util;
 
+import java.io.DataOutputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Serializable;
@@ -28,6 +30,7 @@ import java.util.Iterator;
 import java.util.RandomAccess;
 import java.util.zip.GZIPInputStream;
 
+import org.apache.commons.configuration2.ex.ConfigurationException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -46,6 +49,7 @@ import com.martiansoftware.jsap.stringparsers.IntSizeStringParser;
 import it.unimi.dsi.fastutil.bytes.ByteArrayFrontCodedBigList;
 import it.unimi.dsi.fastutil.chars.CharArrayFrontCodedBigList;
 import it.unimi.dsi.fastutil.io.BinIO;
+import it.unimi.dsi.fastutil.io.FastBufferedOutputStream;
 import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
 import it.unimi.dsi.fastutil.objects.ObjectBigListIterator;
 import it.unimi.dsi.fastutil.objects.ObjectIterator;
@@ -54,10 +58,11 @@ import it.unimi.dsi.io.LineIterator;
 import it.unimi.dsi.lang.MutableString;
 import it.unimi.dsi.logging.ProgressLogger;
 import it.unimi.dsi.util.FrontCodedStringList;
+import it.unimi.dsi.util.Properties;
 
 /**
- * Compact storage of strings using front-coding compression (a&#46;k&#46;a&#46; compression by
- * prefix omission).
+ * Compact storage of strings using front-coding compression (also known as compression by prefix
+ * omission).
  *
  * <P>
  * This class is functionally identical to {@link FrontCodedStringList}, except for the larger size
@@ -157,7 +162,8 @@ public class FrontCodedStringBigList extends AbstractObjectBigList<MutableString
 	}
 
 	/**
-	 * Returns the element at the specified position in this front-coded as a mutable string.
+	 * Returns the element at the specified position in this front-coded string big list as a mutable
+	 * string.
 	 *
 	 * @param index an index in the list.
 	 * @return a {@link MutableString} that will contain the string at the specified position. The
@@ -169,8 +175,8 @@ public class FrontCodedStringBigList extends AbstractObjectBigList<MutableString
 	}
 
 	/**
-	 * Returns the element at the specified position in this front-coded list by storing it in a mutable
-	 * string.
+	 * Returns the element at the specified position in this front-coded string big list by storing it
+	 * in a mutable string.
 	 *
 	 * @param index an index in the list.
 	 * @param s a mutable string that will contain the string at the specified position.
@@ -290,6 +296,19 @@ public class FrontCodedStringBigList extends AbstractObjectBigList<MutableString
 		return utf8 ? byteFrontCodedBigList.size64() : charFrontCodedBigList.size64();
 	}
 
+	public void dump(final String basename) throws ConfigurationException, IOException {
+		if (!utf8) throw new IllegalStateException("You can dump UTF-8-based lists, only");
+		final Properties properties = new Properties();
+		properties.setProperty(MappedFrontCodedStringBigList.PropertyKeys.N, byteFrontCodedBigList.size64());
+		properties.setProperty(MappedFrontCodedStringBigList.PropertyKeys.RATIO, byteFrontCodedBigList.ratio());
+		properties.save(basename + MappedFrontCodedStringBigList.PROPERTIES_EXTENSION);
+		final DataOutputStream arrayDos = new DataOutputStream(new FastBufferedOutputStream(new FileOutputStream(basename + MappedFrontCodedStringBigList.BYTE_ARRAY_EXTENSION)));
+		final DataOutputStream pointerDos = new DataOutputStream(new FastBufferedOutputStream(new FileOutputStream(basename + MappedFrontCodedStringBigList.POINTERS_EXTENSION)));
+		byteFrontCodedBigList.dump(arrayDos, pointerDos);
+		arrayDos.close();
+		pointerDos.close();
+	}
+
 	public static void main(final String[] arg) throws IOException, JSAPException, NoSuchMethodException {
 
 		final SimpleJSAP jsap = new SimpleJSAP(FrontCodedStringBigList.class.getName(), "Builds a front-coded string list reading from standard input a newline-separated ordered list of strings.", new Parameter[] {
diff --git a/src/it/unimi/dsi/big/util/ImmutableBinaryTrie.java b/src/it/unimi/dsi/big/util/ImmutableBinaryTrie.java
index 69bbf84..fb9887f 100644
--- a/src/it/unimi/dsi/big/util/ImmutableBinaryTrie.java
+++ b/src/it/unimi/dsi/big/util/ImmutableBinaryTrie.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/ImmutableExternalPrefixMap.java b/src/it/unimi/dsi/big/util/ImmutableExternalPrefixMap.java
index c164efa..87cf161 100644
--- a/src/it/unimi/dsi/big/util/ImmutableExternalPrefixMap.java
+++ b/src/it/unimi/dsi/big/util/ImmutableExternalPrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/LiterallySignedStringMap.java b/src/it/unimi/dsi/big/util/LiterallySignedStringMap.java
index 9340569..4130e47 100644
--- a/src/it/unimi/dsi/big/util/LiterallySignedStringMap.java
+++ b/src/it/unimi/dsi/big/util/LiterallySignedStringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2009-2021 Sebastiano Vigna
+ * Copyright (C) 2009-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/LongBigListSignedStringMap.java b/src/it/unimi/dsi/big/util/LongBigListSignedStringMap.java
index 1bc95f5..87fd748 100644
--- a/src/it/unimi/dsi/big/util/LongBigListSignedStringMap.java
+++ b/src/it/unimi/dsi/big/util/LongBigListSignedStringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -52,6 +52,7 @@ import it.unimi.dsi.fastutil.io.BinIO;
 import it.unimi.dsi.fastutil.io.FastBufferedOutputStream;
 import it.unimi.dsi.fastutil.longs.LongBigArrays;
 import it.unimi.dsi.fastutil.longs.LongBigList;
+import it.unimi.dsi.fastutil.longs.LongMappedBigList;
 import it.unimi.dsi.fastutil.objects.AbstractObject2LongFunction;
 import it.unimi.dsi.fastutil.objects.Object2LongFunction;
 import it.unimi.dsi.fastutil.objects.ObjectBigList;
@@ -59,29 +60,38 @@ import it.unimi.dsi.io.FastBufferedReader;
 import it.unimi.dsi.io.LineIterator;
 import it.unimi.dsi.lang.MutableString;
 import it.unimi.dsi.logging.ProgressLogger;
-import it.unimi.dsi.util.ByteBufferLongBigList;
 
-/** A string map based on a function signed using a big list of longs.
+/**
+ * A string map based on a function signed using a big list of longs.
  *
- * <p>The purpose of this map is identical to that of a {@link ShiftAddXorSignedStringMap}, but
- * Shift-Add-Xor signatures are 64-bit and stored in a {@link LongBigList}. This approach makes it possible to
- * store the signatures in a file and read them by memory mapping using a {@link ByteBufferLongBigList}.
- * If the map has a very large number of keys but the access pattern is strongly skewed towards a relatively
- * small number of entries, using memory mapping might be advantageous.
+ * <p>
+ * The purpose of this map is identical to that of a {@link ShiftAddXorSignedStringMap}, but
+ * Shift-Add-Xor signatures are 64-bit and stored in a {@link LongBigList}. This approach makes it
+ * possible to store the signatures in a file and read them by memory mapping using a
+ * {@link LongMappedBigList}. If the map has a very large number of keys but the access pattern is
+ * strongly skewed towards a relatively small number of entries, using memory mapping might be
+ * advantageous.
  *
- * <p>The intended usage pattern is as follows:
+ * <p>
+ * The intended usage pattern is as follows:
  *
  * <ul>
  *
- * <li>first, you {@linkplain #sign(Iterator, Object2LongFunction) generate a file of signatures} (note that
- * for this phase it might be necessary to keep the signatures in main memory; see {@link #sign(Iterator, String)} for some elaboration);
+ * <li>first, you {@linkplain #sign(Iterator, Object2LongFunction) generate a file of signatures}
+ * (note that for this phase it might be necessary to keep the signatures in main memory; see
+ * {@link #sign(Iterator, String)} for some elaboration);
  *
- * <li>then, when you want to use the signed map you map the file using {@link ByteBufferLongBigList#map(java.nio.channels.FileChannel)}
- * and {@linkplain #LongBigListSignedStringMap(Object2LongFunction, LongBigList) create on the fly a signed map}.
+ * <li>then, when you want to use the signed map you map the file using
+ * {@link LongMappedBigList#map(java.nio.channels.FileChannel)} and
+ * {@linkplain #LongBigListSignedStringMap(Object2LongFunction, LongBigList) create on the fly a
+ * signed map}.
  *
  * </ul>
  *
- * <p>To simplify the process, there is a {@linkplain #LongBigListSignedStringMap(Object2LongFunction, String) constructor} that will do the mapping for you.
+ * <p>
+ * To simplify the process, there is a
+ * {@linkplain #LongBigListSignedStringMap(Object2LongFunction, String) constructor} that will do
+ * the mapping for you.
  *
  * @author Sebastiano Vigna
  * @since 2.0.13
@@ -218,7 +228,7 @@ public class LongBigListSignedStringMap extends AbstractObject2LongFunction<Char
 		final long signatureSize = new File(signatures).length() / Long.BYTES;
 		if (n != signatureSize) throw new IllegalStateException("The size of the function differs from that of the signature list: " + n + " != " + signatureSize);
 		this.function = function;
-		this.signatures = ByteBufferLongBigList.map(new FileInputStream(signatures).getChannel());
+		this.signatures = LongMappedBigList.map(new FileInputStream(signatures).getChannel());
 		defaultReturnValue(-1);
 	}
 
diff --git a/src/it/unimi/dsi/big/util/MappedFrontCodedStringBigList.java b/src/it/unimi/dsi/big/util/MappedFrontCodedStringBigList.java
new file mode 100644
index 0000000..a5afeea
--- /dev/null
+++ b/src/it/unimi/dsi/big/util/MappedFrontCodedStringBigList.java
@@ -0,0 +1,464 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2002-2022 Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.big.util;
+
+import java.io.Closeable;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.util.Iterator;
+import java.util.RandomAccess;
+
+import org.apache.commons.configuration2.ex.ConfigurationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Charsets;
+import com.martiansoftware.jsap.FlaggedOption;
+import com.martiansoftware.jsap.JSAP;
+import com.martiansoftware.jsap.JSAPException;
+import com.martiansoftware.jsap.JSAPResult;
+import com.martiansoftware.jsap.Parameter;
+import com.martiansoftware.jsap.SimpleJSAP;
+import com.martiansoftware.jsap.Switch;
+import com.martiansoftware.jsap.UnflaggedOption;
+import com.martiansoftware.jsap.stringparsers.IntSizeStringParser;
+
+import it.unimi.dsi.fastutil.BigList;
+import it.unimi.dsi.fastutil.bytes.ByteBigList;
+import it.unimi.dsi.fastutil.bytes.ByteMappedBigList;
+import it.unimi.dsi.fastutil.io.BinIO;
+import it.unimi.dsi.fastutil.io.FastBufferedOutputStream;
+import it.unimi.dsi.fastutil.longs.LongBigList;
+import it.unimi.dsi.fastutil.longs.LongMappedBigList;
+import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
+import it.unimi.dsi.io.FileLinesByteArrayIterable;
+import it.unimi.dsi.lang.MutableString;
+import it.unimi.dsi.util.Properties;
+
+/**
+ * A memory-mapped version of {@link FrontCodedStringBigList}.
+ *
+ * <P>
+ * This class is functionally identical to {@link FrontCodedStringBigList}, but its data is
+ * memory-mapped from disk. Only {@linkplain FrontCodedStringBigList#utf8() UTF-8 encoding} is
+ * supported.
+ *
+ * <P>
+ * To use this class, one first invokes the {@link #build(String, int, Iterator)} method to generate
+ * a {@linkplain #PROPERTIES_EXTENSION property file} containing metadata, and two files containing
+ * {@linkplain #BYTE_ARRAY_EXTENSION strings} and string {@linkplain #POINTERS_EXTENSION pointers},
+ * respectively. Then, the {@link #load(String)} method (invoked with the same basename) will return
+ * an instance of this class accessing strings and pointers by memory mapping.
+ *
+ * <P>
+ * Note that for consistency with other classes in this package this class implements a
+ * {@linkplain BigList big list} of {@linkplain MutableString mutable strings}; however, for greater
+ * flexibility it also implements a {@link #getString(long)} method and a {@link #getArray(long)}
+ * method.
+ *
+ * <p>
+ * If you need to build an instance from a (possibly compressed) stream, we suggest to adapt it
+ * using {@link FileLinesByteArrayIterable#iterator()}.
+ *
+ * @see FrontCodedStringBigList
+ */
+
+public class MappedFrontCodedStringBigList extends AbstractObjectBigList<MutableString> implements RandomAccess, Closeable {
+	public static final long serialVersionUID = 1;
+	public static final String PROPERTIES_EXTENSION = ".properties";
+	public static final String BYTE_ARRAY_EXTENSION = ".bytearray";
+	public static final String POINTERS_EXTENSION = ".pointers";
+
+	public static enum PropertyKeys {
+		/** The {@linkplain #size64() number} of strings. */
+		N,
+		/** The compression {@linkplain FrontCodedStringBigList#ratio() ratio}. */
+		RATIO
+	}
+
+	/** The number of strings in the list. */
+	protected final long n;
+	/** The ratio of this front-coded list. */
+	protected final int ratio;
+	/** The underlying byte array. */
+	protected ByteBigList byteList;
+	/** The pointers to entire arrays in the list. */
+	protected LongBigList pointers;
+	/** The file channel used for memory-mapping. */
+	private final FileChannel fileChannel;
+
+	protected MappedFrontCodedStringBigList(final long n, final int ratio, final String byteBigList, final String pointers) throws IOException {
+		this.n = n;
+		this.ratio = ratio;
+		this.pointers = LongMappedBigList.map(FileChannel.open(new File(pointers).toPath()));
+		fileChannel = FileChannel.open(new File(byteBigList).toPath());
+		this.byteList = ByteMappedBigList.map(fileChannel);
+	}
+
+	/**
+	 * Writes a length.
+	 *
+	 * @param bytes the data array.
+	 * @param length the length to be written.
+	 * @return the number of elements coding {@code length}.
+	 */
+	static int writeInt(final FastBufferedOutputStream bytes, final int length) throws IOException {
+		final int count = count(length);
+		for (int i = count; i-- != 1;) bytes.write(-(length >>> i * 7 & 0x7F) - 1);
+		bytes.write(length & 0x7F);
+		return count;
+	}
+
+	/**
+	 * Builds and stores a new memory-mapped front-coded big string list.
+	 *
+	 * <p>
+	 * Given a basename, three file with extensions {@link #PROPERTIES_EXTENSION},
+	 * {@link #BYTE_ARRAY_EXTENSION} and {@link #POINTERS_EXTENSION} will be generated.
+	 *
+	 * <p>
+	 * After building a list, you can {@linkplain #load(String) load it} using the same basename.
+	 *
+	 * @param basename the basename of the list.
+	 * @param ratio the ratio.
+	 * @param arrays an iterator over byte arrays containing UTF-8 encoded-strings.
+	 */
+	public static void build(final String basename, final int ratio, final Iterator<byte[]> arrays) throws IOException, ConfigurationException {
+		if (ratio < 1) throw new IllegalArgumentException("Illegal ratio (" + ratio + ")");
+		final DataOutputStream pointers = new DataOutputStream(new FastBufferedOutputStream(new FileOutputStream(basename + POINTERS_EXTENSION)));
+		final FastBufferedOutputStream bytes = new FastBufferedOutputStream(new FileOutputStream(basename + BYTE_ARRAY_EXTENSION));
+
+		long curSize = 0, n = 0;
+		int b = 0;
+		final byte[][] array = new byte[2][];
+		while(arrays.hasNext()) {
+			array[b] = arrays.next();
+			int len = array[b].length;
+
+			if (n % ratio == 0) {
+				pointers.writeLong(curSize);
+				curSize += writeInt(bytes, len);
+				bytes.write(array[b], 0, len);
+				curSize += len;
+			} else {
+				final int minLength = Math.min(len, array[1 - b].length);
+				int common;
+				for (common = 0; common < minLength; common++) if (array[0][common] != array[1][common]) break;
+				len -= common;
+
+				curSize += writeInt(bytes, len);
+				curSize += writeInt(bytes, common);
+				bytes.write(array[b], common, len);
+				curSize += len;
+			}
+
+			b = 1 - b;
+			n++;
+		}
+		bytes.close();
+		pointers.close();
+		final Properties properties = new Properties();
+		properties.setProperty(MappedFrontCodedStringBigList.PropertyKeys.N, n);
+		properties.setProperty(MappedFrontCodedStringBigList.PropertyKeys.RATIO, ratio);
+		properties.save(basename + MappedFrontCodedStringBigList.PROPERTIES_EXTENSION);
+	}
+
+	/**
+	 * Maps in memory a front-coded string big list starting from a basename.
+	 *
+	 * @param basename the basename of a memory-mapped front-coded string big list.
+	 * @return a memory-mapped front-coded string big list.
+	 */
+	public static MappedFrontCodedStringBigList load(final String basename) throws ConfigurationException, IOException {
+		final Properties properties = new Properties(basename + PROPERTIES_EXTENSION);
+		return new MappedFrontCodedStringBigList(properties.getLong(PropertyKeys.N), properties.getInt(PropertyKeys.RATIO), basename + BYTE_ARRAY_EXTENSION, basename + POINTERS_EXTENSION);
+	}
+
+	/**
+	 * Returns the element at the specified position in this front-coded big list as a mutable string.
+	 *
+	 * @param index an index in the list.
+	 * @return a {@link MutableString} that will contain the string at the specified position. The
+	 *         string may be freely modified.
+	 */
+	@Override
+	public MutableString get(final long index) {
+		return MutableString.wrap(byte2Char(getArray(index), null));
+	}
+
+	/**
+	 * Returns the element at the specified position in this front-coded big list by storing it in a
+	 * mutable string.
+	 *
+	 * @param index an index in the list.
+	 * @param s a mutable string that will contain the string at the specified position.
+	 */
+	public void get(final long index, final MutableString s) {
+		final byte[] a = getArray(index);
+		s.length(countUTF8Chars(a));
+		byte2Char(a, s.array());
+	}
+
+	/**
+	 * Returns the element at the specified position in this front-coded big list as a string.
+	 *
+	 * @param index an index in the list.
+	 * @return a {@link String} that will contain the string at the specified position.
+	 */
+	public String getString(final long index) {
+		return new String(getArray(index), StandardCharsets.UTF_8);
+	}
+
+	/**
+	 * Returns the element at the specified position in this front-coded big list as an UTF-8-coded byte
+	 * array.
+	 *
+	 * @param index an index in the list.
+	 * @return a byte array representing in UTF-8 encoding the string at the specified position.
+	 */
+	public byte[] getArray(final long index) {
+		ensureRestrictedIndex(index);
+		final int length = length(index);
+		final byte a[] = new byte[length];
+		extract(index, a, 0, length);
+		return a;
+	}
+
+
+	/**
+	 * Computes the number of elements coding a given length.
+	 *
+	 * @param length the length to be coded.
+	 * @return the number of elements coding {@code length}.
+	 */
+	static int count(final int length) {
+		if (length < (1 << 7)) return 1;
+		if (length < (1 << 14)) return 2;
+		if (length < (1 << 21)) return 3;
+		if (length < (1 << 28)) return 4;
+		return 5;
+	}
+
+	/**
+	 * Reads a coded length.
+	 *
+	 * @param a the data big array.
+	 * @param pos the starting position.
+	 * @return the length coded at {@code pos}.
+	 */
+	static int readInt(final ByteBigList a, final long pos) {
+		final byte b0 = a.getByte(pos);
+		if (b0 >= 0) return b0;
+		final byte b1 = a.getByte(pos + 1);
+		if (b1 >= 0) return (-b0 - 1) << 7 | b1;
+		final byte b2 = a.getByte(pos + 2);
+		if (b2 >= 0) return (-b0 - 1) << 14 | (-b1 - 1) << 7 | b2;
+		final byte b3 = a.getByte(pos + 3);
+		if (b3 >= 0) return (-b0 - 1) << 21 | (-b1 - 1) << 14 | (-b2 - 1) << 7 | b3;
+		return (-b0 - 1) << 28 | (-b1 - 1) << 21 | (-b2 - 1) << 14 | (-b3 - 1) << 7 | a.getByte(pos + 4);
+	}
+
+	/**
+	 * Computes the length of the array at the given index.
+	 *
+	 * <p>
+	 * This private version of {@link #arrayLength(int)} does not check its argument.
+	 *
+	 * @param array the data array.
+	 * @param index an index.
+	 * @return the length of the {@code index}-th array.
+	 */
+	private int length(final long index) {
+		final ByteBigList array = this.byteList;
+		final int delta = (int)(index % ratio); // The index into the p array, and the delta inside the block.
+
+		long pos = pointers.getLong(index / ratio); // The position into the array of the first entire word before the
+													// index-th.
+		int length = readInt(array, pos);
+
+		if (delta == 0) return length;
+
+		// First of all, we recover the array length and the maximum amount of copied elements.
+		int common;
+		pos += count(length) + length;
+		length = readInt(array, pos);
+		common = readInt(array, pos + count(length));
+
+		for (int i = 0; i < delta - 1; i++) {
+			pos += count(length) + count(common) + length;
+			length = readInt(array, pos);
+			common = readInt(array, pos + count(length));
+		}
+
+		return length + common;
+	}
+
+	/**
+	 * Extracts the array at the given index.
+	 *
+	 * @param index an index.
+	 * @param a the array that will store the result (we assume that it can hold the result).
+	 * @param offset an offset into {@code a} where elements will be store.
+	 * @param length a maximum number of elements to store in {@code a}.
+	 * @return the length of the extracted array.
+	 */
+	private int extract(final long index, final byte a[], final int offset, final int length) {
+		final ByteBigList array = this.byteList;
+		final int delta = (int)(index % ratio); // The delta inside the block.
+		final long startPos = pointers.getLong(index / ratio); // The position into the array of the first entire word
+																// before the
+		// index-th.
+		long pos, prevArrayPos;
+		int arrayLength = readInt(array, pos = startPos), currLen = 0, actualCommon;
+
+		if (delta == 0) {
+			pos = pointers.getLong(index / ratio) + count(arrayLength);
+			final long pos1 = pos;
+			array.getElements(pos1, a, offset, Math.min(length, arrayLength));
+			return arrayLength;
+		}
+
+		int common = 0;
+
+		for (int i = 0; i < delta; i++) {
+			prevArrayPos = pos + count(arrayLength) + (i != 0 ? count(common) : 0);
+			pos = prevArrayPos + arrayLength;
+
+			arrayLength = readInt(array, pos);
+			common = readInt(array, pos + count(arrayLength));
+
+			actualCommon = Math.min(common, length);
+			if (actualCommon <= currLen) currLen = actualCommon;
+			else {
+				final long pos1 = prevArrayPos;
+				array.getElements(pos1, a, currLen + offset, actualCommon - currLen);
+				currLen = actualCommon;
+			}
+		}
+
+		if (currLen < length) array.getElements(pos + count(arrayLength) + count(common), a, currLen + offset, Math.min(arrayLength, length - currLen));
+
+		return arrayLength + common;
+	}
+
+	/*
+	 * The following methods are highly optimized UTF-8 converters exploiting the fact that since it was
+	 * ourselves in the first place who created the coding, we can be sure it is correct.
+	 */
+
+	protected static int countUTF8Chars(final byte[] a) {
+		final int length = a.length;
+		int result = 0, b;
+		for (int i = 0; i < length; i++) {
+			b = (a[i] & 0xFF) >> 4;
+			if (b < 8) result++;
+			else if (b < 14) {
+				result++;
+				i++;
+			} else if (b < 15) {
+				result++;
+				i += 2;
+			} else {
+				// Surrogate pair (yuck!)
+				result += 2;
+				i += 4;
+			}
+		}
+
+		return result;
+	}
+
+	char[] byte2Char(final byte[] a, char[] s) {
+		final int length = a.length;
+		if (s == null) s = new char[countUTF8Chars(a)];
+		int b, c, d, t;
+
+		for (int i = 0, j = 0; i < length; i++) {
+			b = a[i] & 0xFF;
+			t = b >> 4;
+
+			if (t < 8) s[j++] = (char)b;
+			else if (t < 14) {
+				c = a[++i] & 0xFF;
+				if ((c & 0xC0) != 0x80) throw new IllegalStateException("Malformed internal UTF-8 encoding");
+				s[j++] = (char)(((b & 0x1F) << 6) | (c & 0x3F));
+			} else if (t < 15) {
+				c = a[++i] & 0xFF;
+				d = a[++i];
+				if ((c & 0xC0) != 0x80 || (d & 0xC0) != 0x80) throw new IllegalStateException("Malformed internal UTF-8 encoding");
+				s[j++] = (char)(((b & 0x0F) << 12) | ((c & 0x3F) << 6) | ((d & 0x3F) << 0));
+			} else {
+				// Surrogate pair (yuck!)
+				final String surrogatePair = new String(a, i, 4, Charsets.UTF_8);
+				s[j++] = surrogatePair.charAt(0);
+				s[j++] = surrogatePair.charAt(1);
+				i += 3;
+			}
+		}
+
+		return s;
+	}
+
+
+	@Override
+	public long size64() {
+		return n;
+	}
+
+	@Override
+	public void close() throws IOException {
+		fileChannel.close();
+	}
+
+	public static void main(final String[] arg) throws IOException, JSAPException, ConfigurationException, ClassNotFoundException, IllegalArgumentException, SecurityException {
+
+		final SimpleJSAP jsap = new SimpleJSAP(MappedFrontCodedStringBigList.class.getName(), "Dumps the files of a memory-mapped front-coded string big list reading from standard input a newline-separated list of UTF-8-encoded strings or a serialized FrontCodedStringBigList.", new Parameter[] {
+				new Switch("object", 'o', "object", "Read a serialized FrontCodedStringBigList from standard input instead of a list of strings."),
+				new FlaggedOption("ratio", IntSizeStringParser.getParser(), "4", JSAP.NOT_REQUIRED, 'r', "ratio", "The compression ratio."),
+				new FlaggedOption("decompressor", JSAP.CLASS_PARSER, JSAP.NO_DEFAULT, JSAP.NOT_REQUIRED, 'd', "decompressor", "Use this extension of InputStream to decompress the strings (e.g., java.util.zip.GZIPInputStream)."),
+				new UnflaggedOption("basename", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, JSAP.NOT_GREEDY, "The basename of the files associated with the memory-mapped front-coded string list.") });
+
+		final JSAPResult jsapResult = jsap.parse(arg);
+		if (jsap.messagePrinted()) return;
+
+		final String basename = jsapResult.getString("basename");
+
+		final FrontCodedStringBigList frontCodedStringBigList;
+		final Logger logger = LoggerFactory.getLogger(FrontCodedStringBigList.class);
+		if (jsapResult.userSpecified("object")) {
+			logger.info("Reading front-coded string big list...");
+			frontCodedStringBigList = (FrontCodedStringBigList)BinIO.loadObject(System.in);
+			logger.info("Dumping files...");
+			frontCodedStringBigList.dump(basename);
+		}
+		else {
+			final int ratio = jsapResult.getInt("ratio");
+			final Class<? extends InputStream> decompressor = jsapResult.getClass("decompressor");
+			logger.info("Reading strings...");
+			build(basename, ratio, FileLinesByteArrayIterable.iterator(System.in, decompressor));
+		}
+		logger.info("Completed.");
+	}
+}
diff --git a/src/it/unimi/dsi/big/util/PermutedFrontCodedStringBigList.java b/src/it/unimi/dsi/big/util/PermutedFrontCodedStringBigList.java
index 640aa64..c2e7f38 100644
--- a/src/it/unimi/dsi/big/util/PermutedFrontCodedStringBigList.java
+++ b/src/it/unimi/dsi/big/util/PermutedFrontCodedStringBigList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/PrefixMap.java b/src/it/unimi/dsi/big/util/PrefixMap.java
index 79157d3..cf03f69 100644
--- a/src/it/unimi/dsi/big/util/PrefixMap.java
+++ b/src/it/unimi/dsi/big/util/PrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2004-2021 Sebastiano Vigna
+ * Copyright (C) 2004-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/SemiExternalGammaBigList.java b/src/it/unimi/dsi/big/util/SemiExternalGammaBigList.java
index 2675650..b7a53b8 100644
--- a/src/it/unimi/dsi/big/util/SemiExternalGammaBigList.java
+++ b/src/it/unimi/dsi/big/util/SemiExternalGammaBigList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/ShiftAddXorSignedStringMap.java b/src/it/unimi/dsi/big/util/ShiftAddXorSignedStringMap.java
index 4854b89..7ed6490 100644
--- a/src/it/unimi/dsi/big/util/ShiftAddXorSignedStringMap.java
+++ b/src/it/unimi/dsi/big/util/ShiftAddXorSignedStringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/StringMap.java b/src/it/unimi/dsi/big/util/StringMap.java
index e376d80..10759cc 100644
--- a/src/it/unimi/dsi/big/util/StringMap.java
+++ b/src/it/unimi/dsi/big/util/StringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/StringMaps.java b/src/it/unimi/dsi/big/util/StringMaps.java
index 843b266..a83dd41 100644
--- a/src/it/unimi/dsi/big/util/StringMaps.java
+++ b/src/it/unimi/dsi/big/util/StringMaps.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/TernaryIntervalSearchTree.java b/src/it/unimi/dsi/big/util/TernaryIntervalSearchTree.java
index c08b320..923ac0e 100644
--- a/src/it/unimi/dsi/big/util/TernaryIntervalSearchTree.java
+++ b/src/it/unimi/dsi/big/util/TernaryIntervalSearchTree.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/big/util/package-info.java b/src/it/unimi/dsi/big/util/package-info.java
index a6b440e..2c72391 100644
--- a/src/it/unimi/dsi/big/util/package-info.java
+++ b/src/it/unimi/dsi/big/util/package-info.java
@@ -1,6 +1,10 @@
-/** Collections and similar big classes
+/**
+ * Collections and similar big classes
  *
- * <p>Classes in this package are big versions of classes in {@link it.unimi.dsi.util}.
+ * <p>
+ * Some classes in this package are big versions of classes in {@link it.unimi.dsi.util}. Other
+ * classes exists only in the big versions (e.g.,
+ * {@link it.unimi.dsi.big.util.MappedFrontCodedStringBigList}).
  */
 
 package it.unimi.dsi.big.util;
diff --git a/src/it/unimi/dsi/bits/AbstractBitVector.java b/src/it/unimi/dsi/bits/AbstractBitVector.java
index ec43160..c9b99d4 100644
--- a/src/it/unimi/dsi/bits/AbstractBitVector.java
+++ b/src/it/unimi/dsi/bits/AbstractBitVector.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -20,8 +20,8 @@
 package it.unimi.dsi.bits;
 
 import static it.unimi.dsi.bits.LongArrayBitVector.bit;
-import static it.unimi.dsi.bits.LongArrayBitVector.words;
 import static it.unimi.dsi.bits.LongArrayBitVector.word;
+import static it.unimi.dsi.bits.LongArrayBitVector.words;
 
 import java.io.Serializable;
 import java.util.NoSuchElementException;
@@ -68,8 +68,13 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		if (index > length()) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than length (" + (length()) + ")");
 	}
 
+	/** @implSpec This implementation delegates to {@link #set(long, boolean)}. */
 	public void set(final int index) { set(index, true); }
+
+	/** @implSpec This implementation delegates to {@link #set(long, boolean)}. */
 	public void clear(final int index) { set(index, false); }
+
+	/** @implSpec This implementation delegates to {@link #flip(long)}. */
 	public void flip(final int index) { set(index, ! getBoolean(index)); }
 
 	@Override
@@ -102,10 +107,17 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		for(long i = from; i < to; i++) if (getBoolean(i)) result |= 1L << i - from;
 		return result;
 	}
+
+	/** @implSpec This implementation delegates to {@link #getBoolean(long)}. */
 	public boolean getBoolean(final int index) { return getBoolean((long)index); }
 
+	/** @implSpec This implementation delegates to {@link #removeBoolean(long)}. */
 	public boolean removeBoolean(final int index) { return removeBoolean((long)index); }
+
+	/** @implSpec This implementation delegates to {@link #set(long, boolean)}. */
 	public boolean set(final int index, final boolean value) { return set((long)index, value); }
+
+	/** @implSpec This implementation delegates to {@link #add(long, boolean)}. */
 	public void add(final int index, final boolean value) { add((long)index, value); }
 
 	@Override
@@ -246,7 +258,7 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 
 	@Override
 	public boolean isProperPrefix(final BitVector v) {
-		return isPrefix(v) && length() < v.length();
+		return length() < v.length() && isPrefix(v);
 	}
 
 	@Override
@@ -275,19 +287,23 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		return (int)length;
 	}
 
-	/** {@inheritDoc}
-	 * <p>This implementation just returns {@link #length()}.
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @implSpec This implementation just returns {@link #length()}.
 	 */
 	@Override
 	public long size64() {
 		return length();
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void clear() {
 		length(0);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public BitVector replace(final BitVector bv) {
 		clear();
@@ -351,20 +367,37 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		return bits;
 	}
 
-	/** An integer sorted set view of a bit vector.
+	/**
+	 * A view of a bit vector as a sorted set of long integers.
+	 *
+	 * <p>
+	 * This class implements a view of a subvector as a sorted set of long integers using the subvector
+	 * as a bit mask. If the end position is {@link Long#MAX_VALUE}, the vector is enlarged as needed
+	 * (i.e., when a one beyond the current size is set), but it is never shrunk.
 	 *
-	 * <P>This class implements in the obvious way an integer set view
-	 * of a bit vector. The vector is enlarged as needed (i.e., when
-	 * a one beyond the current size is set), but it is never shrunk.
+	 * <p>
+	 * Outside of the specified range {{@link #contains(long)} will return false and {@link #add(long)}
+	 * will cause an {@link UnsupportedOperationException}.
 	 */
 
 	public static class LongSetView extends AbstractLongSortedSet implements LongSet, Serializable, Size64 {
-
-		protected final BitVector bitVector;
 		private static final long serialVersionUID = 1L;
+		/** The underlying bit vector. */
+		protected final BitVector bitVector;
+		/** The starting position (included). */
 		private final long from;
+		/**
+		 * The ending position (not included); use {@link Long#MAX_VALUE} to get an extendable bit vector.
+		 */
 		private final long to;
 
+		/**
+		 * Creates a new view on a subvector.
+		 *
+		 * @param bitVector the underlying bit vector.
+		 * @param from the first index (inclusive).
+		 * @param to the last index (not inclusive).
+		 */
 		public LongSetView(final BitVector bitVector, final long from, final long to) {
 			if (from > to) throw new IllegalArgumentException("Start index (" + from + ") is greater than end index (" + to + ")");
 			this.bitVector = bitVector;
@@ -372,7 +405,6 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 			this.to = to;
 		}
 
-
 		@Override
 		public boolean contains(final long index) {
 			if (index < 0) throw new IllegalArgumentException("The provided index (" + index + ") is negative");
@@ -383,7 +415,7 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		@Override
 		public boolean add(final long index) {
 			if (index < 0) throw new IllegalArgumentException("The provided index (" + index + ") is negative");
-			if (index < from || index >= to) return false;
+			if (index < from || index >= to) throw new UnsupportedOperationException();
 
 			final long length = bitVector.length();
 			if (index >= length) bitVector.length(index + 1);
@@ -523,6 +555,12 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		/** A bit mask containing {@link #width} bits set to one. */
 		protected final long fullMask;
 
+		/**
+		 * Returns a list-of-integers view of a bit vector.
+		 *
+		 * @param bitVector a bit vector.
+		 * @param width the bit width of the integers.
+		 */
 		public LongBigListView(final BitVector bitVector, final int width) {
 			this.width = width;
 			this.bitVector = bitVector;
@@ -542,18 +580,26 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 			return width == 0 ? 0 : bitVector.length() / width;
 		}
 
-		/* @deprecated Please use {@link #size64()}. */
+		/**
+		 * @return {@link #size64()}
+		 * @deprecated Please use {@link #size64()}.
+		 */
 		@Deprecated
 		public long length() {
 			return size64();
 		}
 
+		/**
+		 * Resizes this list, enlarging the underying bit vector as necessary.
+		 *
+		 * @param newSize the new size.
+		 */
 		@Override
 		public void size(final long newSize) {
 			bitVector.length(newSize * width);
 		}
 
-		/* @deprecated Please use {@link #size(long)}. */
+		/** @deprecated Please use {@link #size(long)}. */
 		@Deprecated
 		public LongBigList length(final long newSize) {
 			size(newSize);
@@ -596,6 +642,7 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 			return new LongBigListIteratorView();
 		}
 
+		/** @implSpec This implementation delegates to {@link #add(long, long)}. */
 		public void add(final int index, final long value) {
 			add((long)index, value);
 		}
@@ -612,6 +659,7 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 			return bitVector.getLong(start, start + width);
 		}
 
+		/** @implSpec This implementation delegates to {@link #getLong(long)}. */
 		public long getLong(final int index) {
 			return getLong((long)index);
 		}
@@ -676,6 +724,15 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 		return super.compareTo(list);
 	}
 
+	/**
+	 * Compares lexicographically this bit vector with another bit vector.
+	 *
+	 * @implNote This method compares the two bit vectors by extracting a 64-bit word at a time using
+	 *           {@link BitVector#getLong(long, long)}.
+	 *
+	 * @param v another bit vector.
+	 * @return -1, 0, or 1, depending on the lexicographical order of the two vectors.
+	 */
 	public int compareTo(final BitVector v) {
 		final long minLength = Math.min(length(), v.length());
 		final long l = minLength & -Long.SIZE;
@@ -716,8 +773,11 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 	/** A subvector of a given bit vector, specified by an initial and a final bit. */
 
 	public static class SubBitVector extends AbstractBitVector implements BitVector {
-		final protected BitVector bitVector;
-		protected long from;
+		/** The underlying bit vector. */
+		protected final BitVector bitVector;
+		/** The initial bit (inclusive). */
+		protected final long from;
+		/** The final bit (not inclusive). */
 		protected long to;
 
 		public SubBitVector(final BitVector l, final long from, final long to) {
@@ -781,6 +841,11 @@ public abstract class AbstractBitVector extends AbstractBooleanBigList implement
 			return bitVector.getLong(from + this.from, to + this.from);
 		}
 
+		@Override
+		public LongSortedSet asLongSet() {
+			return new LongSetView(this, 0, length());
+		}
+
 		@Override
 		public long length() {
 			return to - from;
diff --git a/src/it/unimi/dsi/bits/BitVector.java b/src/it/unimi/dsi/bits/BitVector.java
index b8c0a04..f4ee77d 100644
--- a/src/it/unimi/dsi/bits/BitVector.java
+++ b/src/it/unimi/dsi/bits/BitVector.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -154,14 +154,16 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	 *
 	 * @param from the first index (inclusive).
 	 * @param to the last index (not inclusive).
+	 * @return a subvector view specified by initial and final index.
 	 */
 	BitVector subVector(long from, long to);
 
 	/**
-	 * Returns a subvector view specified by initial index and running up to the end of this vector.
+	 * Returns a subvector view specified by initial index and running up to the end of this bit vector.
 	 *
 	 * @param from the first index (inclusive).
 	 * @see #subVector(long, long)
+	 * @return a subvector view specified by initial index and running up to the end of this bit vector.
 	 */
 	BitVector subVector(long from);
 
@@ -177,6 +179,10 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	 * Note that, in particular, the resulting string representation is exactly that of a
 	 * {@link java.util.BitSet}.
 	 *
+	 * @apiNote Implementations are allowed to prohibit modifications outside of the current size of the
+	 *          bit vector.
+	 *
+	 * @return a view of this bit vector as a sorted set of long integers.
 	 */
 	LongSortedSet asLongSet();
 
@@ -189,6 +195,7 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	 * <code>(p + 1) * width</code> (bit <code>width</code> &minus; 1, exclusive).
 	 *
 	 * @param width a bit width.
+	 * @return a view of this bit vector as a list of nonnegative integers of specified width.
 	 */
 	LongBigList asLongBigList(int width);
 
@@ -278,8 +285,8 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	 * Returns the number of bits in this bit vector.
 	 *
 	 * <p>
-	 * If the number of bits in this vector is smaller than or equal to {@link Integer#MAX_VALUE}, this
-	 * method is semantically equivalent to {@link List#size()}. In any case, this method is
+	 * If the number of bits in this bit vector is smaller than or equal to {@link Integer#MAX_VALUE},
+	 * this method is semantically equivalent to {@link List#size()}. In any case, this method is
 	 * semantically equivalent to {@link BooleanBigList#size64()}, but it is prefererred.
 	 *
 	 * @return the number of bits in this bit vector.
@@ -320,7 +327,8 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	BitVector and(BitVector v);
 
 	/**
-	 * Performs a logical or between this bit vector and another one, leaving the result in this vector.
+	 * Performs a logical or between this bit vector and another one, leaving the result in this bit
+	 * vector.
 	 *
 	 * @param v a bit vector.
 	 * @return this bit vector.
@@ -337,14 +345,14 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	BitVector xor(BitVector v);
 
 	/**
-	 * Returns the position of the first bit set in this vector.
+	 * Returns the position of the first bit set in this bit vector.
 	 *
 	 * @return the first bit set, or -1 for a vector of zeroes.
 	 */
 	long firstOne();
 
 	/**
-	 * Returns the position of the last bit set in this vector.
+	 * Returns the position of the last bit set in this bit vector.
 	 *
 	 * @return the last bit set, or -1 for a vector of zeroes.
 	 */
@@ -369,14 +377,14 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	long previousOne(long index);
 
 	/**
-	 * Returns the position of the first bit unset in this vector.
+	 * Returns the position of the first bit unset in this bit vector.
 	 *
 	 * @return the first bit unset, or -1 for a vector of ones.
 	 */
 	long firstZero();
 
 	/**
-	 * Returns the position of the last bit unset in this vector.
+	 * Returns the position of the last bit unset in this bit vector.
 	 *
 	 * @return the last bit unset, or -1 for a vector of ones.
 	 */
@@ -400,7 +408,7 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	long previousZero(long index);
 
 	/**
-	 * Returns the length of the greatest common prefix between this and the specified vector.
+	 * Returns the length of the greatest common prefix between this and the specified bit vector.
 	 *
 	 * @param v a bit vector.
 	 * @return the length of the greatest common prefix.
@@ -408,19 +416,19 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	long longestCommonPrefixLength(BitVector v);
 
 	/**
-	 * Returns true if this vector is a prefix of the specified vector.
+	 * Returns true if this bit vector is a prefix of the specified bit vector.
 	 *
 	 * @param v a bit vector.
-	 * @return true if this vector is a prefix of <code>v</code>.
+	 * @return true if this bit vector is a prefix of <code>v</code>.
 	 */
 	boolean isPrefix(BitVector v);
 
 	/**
-	 * Returns true if this vector is a proper prefix of the specified vector.
+	 * Returns true if this bit vector is a proper prefix of the specified bit vector.
 	 *
 	 * @param v a bit vector.
-	 * @return true if this vector is a proper prefix of <code>v</code> (i.e., it is a prefix but not
-	 *         equal).
+	 * @return true if this bit vector is a proper prefix of <code>v</code> (i.e., it is a prefix but
+	 *         not equal).
 	 */
 	boolean isProperPrefix(BitVector v);
 
@@ -430,7 +438,7 @@ public interface BitVector extends RandomAccess, BooleanBigList {
 	 * @param v a bit vector.
 	 * @param from the starting bit, inclusive.
 	 * @param to the ending bit, not inclusive.
-	 * @return true if this vector and v are equal in the range of positions
+	 * @return true if this bit vector and v are equal in the range of positions
 	 *         [<code>from</code>..<code>to</code>).
 	 */
 	boolean equals(final BitVector v, final long from, final long to);
diff --git a/src/it/unimi/dsi/bits/BitVectors.java b/src/it/unimi/dsi/bits/BitVectors.java
index 2851126..197c897 100644
--- a/src/it/unimi/dsi/bits/BitVectors.java
+++ b/src/it/unimi/dsi/bits/BitVectors.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/bits/BooleanListBitVector.java b/src/it/unimi/dsi/bits/BooleanListBitVector.java
index 38f4dff..59dbe55 100644
--- a/src/it/unimi/dsi/bits/BooleanListBitVector.java
+++ b/src/it/unimi/dsi/bits/BooleanListBitVector.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -26,12 +26,12 @@ import it.unimi.dsi.fastutil.booleans.BooleanBigList;
 import it.unimi.dsi.fastutil.booleans.BooleanBigLists;
 import it.unimi.dsi.fastutil.booleans.BooleanList;
 
-/** A boolean-list based implementation of {@link BitVector}.
+/**
+ * A boolean-list based implementation of {@link BitVector}.
  *
- * <P>This implementation of a bit vector is based on a backing
- * list of booleans. It is rather inefficient, but useful for
- * wrapping purposes, for covering completely the code in
- * {@link AbstractBitVector} and for creating mock objects.
+ * @implNote This implementation of a bit vector is based on a backing list of booleans. It is
+ *           rather inefficient, but useful for wrapping purposes, for covering completely the code
+ *           in {@link AbstractBitVector} and for creating mock objects.
  */
 public class BooleanListBitVector extends AbstractBitVector implements Serializable {
 	private static final long serialVersionUID = 1L;
diff --git a/src/it/unimi/dsi/bits/Fast.java b/src/it/unimi/dsi/bits/Fast.java
index d93032b..50b13e5 100644
--- a/src/it/unimi/dsi/bits/Fast.java
+++ b/src/it/unimi/dsi/bits/Fast.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -169,9 +169,11 @@ public final class Fast {
 		return Math.log(x) / 0.6931471805599453;
 	}
 
-	/** Computes the ceiling of the base-two logarithm of the argument.
+	/**
+	 * Computes the ceiling of the base-two logarithm of the argument.
 	 *
-	 * <p>This method relies on {@link #mostSignificantBit(int)}, and thus is pretty fast.
+	 * <p>
+	 * This method relies on {@link Integer#numberOfLeadingZeros(int)}, and thus is pretty fast.
 	 *
 	 * @param x an integer.
 	 * @return the ceiling of the base-two logarithm of the argument, or -1 if <code>x</code> is zero.
@@ -181,9 +183,11 @@ public final class Fast {
 		return Integer.SIZE - Integer.numberOfLeadingZeros(x - 1);
 	}
 
-	/** Computes the ceiling of the base-two logarithm of the argument.
+	/**
+	 * Computes the ceiling of the base-two logarithm of the argument.
 	 *
-	 * <p>This method relies on {@link #mostSignificantBit(long)}, and thus is pretty fast.
+	 * <p>
+	 * This method relies on {@link Long#numberOfLeadingZeros(long)}, and thus is pretty fast.
 	 *
 	 * @param x an integer.
 	 * @return the ceiling of the base-two logarithm of the argument, or -1 if <code>x</code> is zero.
diff --git a/src/it/unimi/dsi/bits/HuTuckerTransformationStrategy.java b/src/it/unimi/dsi/bits/HuTuckerTransformationStrategy.java
index e0b7cd1..2b18a78 100644
--- a/src/it/unimi/dsi/bits/HuTuckerTransformationStrategy.java
+++ b/src/it/unimi/dsi/bits/HuTuckerTransformationStrategy.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/bits/LongArrayBitVector.java b/src/it/unimi/dsi/bits/LongArrayBitVector.java
index 613d239..8df6f66 100644
--- a/src/it/unimi/dsi/bits/LongArrayBitVector.java
+++ b/src/it/unimi/dsi/bits/LongArrayBitVector.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/bits/LongBigArrayBitVector.java b/src/it/unimi/dsi/bits/LongBigArrayBitVector.java
index 5934d56..37c424b 100644
--- a/src/it/unimi/dsi/bits/LongBigArrayBitVector.java
+++ b/src/it/unimi/dsi/bits/LongBigArrayBitVector.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/bits/PrefixCoderTransformationStrategy.java b/src/it/unimi/dsi/bits/PrefixCoderTransformationStrategy.java
index f40202f..9063c71 100644
--- a/src/it/unimi/dsi/bits/PrefixCoderTransformationStrategy.java
+++ b/src/it/unimi/dsi/bits/PrefixCoderTransformationStrategy.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/bits/TransformationStrategies.java b/src/it/unimi/dsi/bits/TransformationStrategies.java
index a76a00e..0cf509d 100644
--- a/src/it/unimi/dsi/bits/TransformationStrategies.java
+++ b/src/it/unimi/dsi/bits/TransformationStrategies.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -1401,17 +1401,29 @@ public class TransformationStrategies {
 
 	private static final FixedLongTransformationStrategy FIXED_LONG = new FixedLongTransformationStrategy(true);
 
-	/** A transformation from longs to bit vectors that returns a fixed-size {@link Long#SIZE}-bit vector. Note that the
-	 * bit vectors have as first bit the <em>most</em> significant bit of the underlying long integer, so
-	 * lexicographical and numerical order do coincide for positive numbers. */
+	/**
+	 * A transformation from longs to bit vectors that returns a fixed-size {@link Long#SIZE}-bit
+	 * vector. Note that the bit vectors have as first bit the <em>most</em> significant bit of the
+	 * underlying long integer, and that the first bit of the representation is flipped, so
+	 * lexicographical and numerical order coincide.
+	 *
+	 * @implNote The flipping of the most significant bit was implemented in 2.6.18 to match
+	 *           lexicographical and numerical order for negative numbers, too, and made it necessary to
+	 *           bump the serial version of the strategy.
+	 */
 	public static TransformationStrategy<Long> fixedLong() {
 		return FIXED_LONG;
 	}
 
 	private static final FixedLongTransformationStrategy RAW_FIXED_LONG = new FixedLongTransformationStrategy(false);
 
-	/** A trivial, high-performance, raw transformation from longs to bit vectors that returns a fixed-size
-	 * {@link Long#SIZE}-bit vector. */
+	/**
+	 * A trivial, high-performance, raw transformation from longs to bit vectors that returns a
+	 * fixed-size {@link Long#SIZE}-bit vector.
+	 *
+	 * @implNote Implementing {@link #fixedLong()} lexicographical order for all numbers in 2.6.18 made
+	 *           it necessary to bump the serial version of this strategy, too.
+	 */
 	public static TransformationStrategy<Long> rawFixedLong() {
 		return RAW_FIXED_LONG;
 	}
@@ -1419,7 +1431,7 @@ public class TransformationStrategies {
 	/** A transformation from longs to bit vectors that returns a fixed-size {@link Long#SIZE}-bit vector, possibly reversed
 	 * to maintain lexicographical order. */
 	private static class FixedLongTransformationStrategy implements TransformationStrategy<Long>, Serializable {
-		private static final long serialVersionUID = 0L;
+		private static final long serialVersionUID = 1L;
 		private final boolean lexicographical;
 
 		public FixedLongTransformationStrategy(final boolean lexicographical) {
@@ -1443,7 +1455,7 @@ public class TransformationStrategies {
 			@Override
 			public long getLong(final long from, final long to) {
 				if (from == 0 && to == Long.SIZE) return v;
-				return (v >> from) & (1L << to - from) - 1;
+				return (v >>> from) & (1L << to - from) - 1;
 			}
 
 			@Override
@@ -1454,7 +1466,7 @@ public class TransformationStrategies {
 
 		@Override
 		public BitVector toBitVector(final Long v) {
-			return new FixedLongBitVector(lexicographical ? Long.reverse(v.longValue()) : v.longValue());
+			return new FixedLongBitVector(lexicographical ? Long.reverse(v.longValue()) ^ 1 : v.longValue());
 		}
 
 		@Override
diff --git a/src/it/unimi/dsi/bits/TransformationStrategy.java b/src/it/unimi/dsi/bits/TransformationStrategy.java
index 4de5ecc..cd62ed6 100644
--- a/src/it/unimi/dsi/bits/TransformationStrategy.java
+++ b/src/it/unimi/dsi/bits/TransformationStrategy.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/CanonicalFast64CodeWordDecoder.java b/src/it/unimi/dsi/compression/CanonicalFast64CodeWordDecoder.java
index 6db793a..102672c 100644
--- a/src/it/unimi/dsi/compression/CanonicalFast64CodeWordDecoder.java
+++ b/src/it/unimi/dsi/compression/CanonicalFast64CodeWordDecoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/CodeWordCoder.java b/src/it/unimi/dsi/compression/CodeWordCoder.java
index 0cb689c..48e381c 100644
--- a/src/it/unimi/dsi/compression/CodeWordCoder.java
+++ b/src/it/unimi/dsi/compression/CodeWordCoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/Codec.java b/src/it/unimi/dsi/compression/Codec.java
index 623a7b7..a36569b 100644
--- a/src/it/unimi/dsi/compression/Codec.java
+++ b/src/it/unimi/dsi/compression/Codec.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/Coder.java b/src/it/unimi/dsi/compression/Coder.java
index b435e9d..667ad2b 100644
--- a/src/it/unimi/dsi/compression/Coder.java
+++ b/src/it/unimi/dsi/compression/Coder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/Decoder.java b/src/it/unimi/dsi/compression/Decoder.java
index 533db92..f54d59b 100644
--- a/src/it/unimi/dsi/compression/Decoder.java
+++ b/src/it/unimi/dsi/compression/Decoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/Fast64CodeWordCoder.java b/src/it/unimi/dsi/compression/Fast64CodeWordCoder.java
index 5b4eaf4..b3a4a8c 100644
--- a/src/it/unimi/dsi/compression/Fast64CodeWordCoder.java
+++ b/src/it/unimi/dsi/compression/Fast64CodeWordCoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/HuTuckerCodec.java b/src/it/unimi/dsi/compression/HuTuckerCodec.java
index 3106e99..abdd157 100644
--- a/src/it/unimi/dsi/compression/HuTuckerCodec.java
+++ b/src/it/unimi/dsi/compression/HuTuckerCodec.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/HuffmanCodec.java b/src/it/unimi/dsi/compression/HuffmanCodec.java
index ad1d93c..b481d0d 100644
--- a/src/it/unimi/dsi/compression/HuffmanCodec.java
+++ b/src/it/unimi/dsi/compression/HuffmanCodec.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/PrefixCodec.java b/src/it/unimi/dsi/compression/PrefixCodec.java
index 508cc40..14b7bee 100644
--- a/src/it/unimi/dsi/compression/PrefixCodec.java
+++ b/src/it/unimi/dsi/compression/PrefixCodec.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/PrefixCoder.java b/src/it/unimi/dsi/compression/PrefixCoder.java
index 86098e3..a7556c0 100644
--- a/src/it/unimi/dsi/compression/PrefixCoder.java
+++ b/src/it/unimi/dsi/compression/PrefixCoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/compression/TreeDecoder.java b/src/it/unimi/dsi/compression/TreeDecoder.java
index 327615c..4d106f3 100644
--- a/src/it/unimi/dsi/compression/TreeDecoder.java
+++ b/src/it/unimi/dsi/compression/TreeDecoder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/ByteBufferInputStream.java b/src/it/unimi/dsi/io/ByteBufferInputStream.java
index cb70cc9..3329726 100644
--- a/src/it/unimi/dsi/io/ByteBufferInputStream.java
+++ b/src/it/unimi/dsi/io/ByteBufferInputStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/ByteDiskQueue.java b/src/it/unimi/dsi/io/ByteDiskQueue.java
index a125510..059189c 100644
--- a/src/it/unimi/dsi/io/ByteDiskQueue.java
+++ b/src/it/unimi/dsi/io/ByteDiskQueue.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/DebugInputBitStream.java b/src/it/unimi/dsi/io/DebugInputBitStream.java
index b29626b..862e32f 100644
--- a/src/it/unimi/dsi/io/DebugInputBitStream.java
+++ b/src/it/unimi/dsi/io/DebugInputBitStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Sebastiano Vigna
+ * Copyright (C) 2006-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/DebugOutputBitStream.java b/src/it/unimi/dsi/io/DebugOutputBitStream.java
index a168f0e..103af1e 100644
--- a/src/it/unimi/dsi/io/DebugOutputBitStream.java
+++ b/src/it/unimi/dsi/io/DebugOutputBitStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2006-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/DelimitedWordReader.java b/src/it/unimi/dsi/io/DelimitedWordReader.java
index 7a31164..5d43b11 100644
--- a/src/it/unimi/dsi/io/DelimitedWordReader.java
+++ b/src/it/unimi/dsi/io/DelimitedWordReader.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2009-2021 Sebastiano Vigna
+ * Copyright (C) 2009-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/FastBufferedReader.java b/src/it/unimi/dsi/io/FastBufferedReader.java
index 7d3e24f..5891151 100644
--- a/src/it/unimi/dsi/io/FastBufferedReader.java
+++ b/src/it/unimi/dsi/io/FastBufferedReader.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/FileLinesByteArrayIterable.java b/src/it/unimi/dsi/io/FileLinesByteArrayIterable.java
index a2096cd..b6b06bd 100644
--- a/src/it/unimi/dsi/io/FileLinesByteArrayIterable.java
+++ b/src/it/unimi/dsi/io/FileLinesByteArrayIterable.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2020-2021 Sebastiano Vigna
+ * Copyright (C) 2020-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/FileLinesCollection.java b/src/it/unimi/dsi/io/FileLinesCollection.java
index 8e8a8f1..e7b31c0 100644
--- a/src/it/unimi/dsi/io/FileLinesCollection.java
+++ b/src/it/unimi/dsi/io/FileLinesCollection.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/FileLinesMutableStringIterable.java b/src/it/unimi/dsi/io/FileLinesMutableStringIterable.java
index 554e758..4ef66d4 100644
--- a/src/it/unimi/dsi/io/FileLinesMutableStringIterable.java
+++ b/src/it/unimi/dsi/io/FileLinesMutableStringIterable.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2020-2021 Sebastiano Vigna
+ * Copyright (C) 2020-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/InputBitStream.java b/src/it/unimi/dsi/io/InputBitStream.java
index 1b9ee31..61178d5 100644
--- a/src/it/unimi/dsi/io/InputBitStream.java
+++ b/src/it/unimi/dsi/io/InputBitStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/LineIterator.java b/src/it/unimi/dsi/io/LineIterator.java
index fb685b7..ba305a5 100644
--- a/src/it/unimi/dsi/io/LineIterator.java
+++ b/src/it/unimi/dsi/io/LineIterator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/LineWordReader.java b/src/it/unimi/dsi/io/LineWordReader.java
index d51cf2e..a91f8d9 100644
--- a/src/it/unimi/dsi/io/LineWordReader.java
+++ b/src/it/unimi/dsi/io/LineWordReader.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Sebastiano Vigna
+ * Copyright (C) 2006-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/MultipleInputStream.java b/src/it/unimi/dsi/io/MultipleInputStream.java
index fd4bb62..4ddbf7d 100644
--- a/src/it/unimi/dsi/io/MultipleInputStream.java
+++ b/src/it/unimi/dsi/io/MultipleInputStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Sebastiano Vigna
+ * Copyright (C) 2003-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/NullInputStream.java b/src/it/unimi/dsi/io/NullInputStream.java
index 0dfb0d2..813709f 100644
--- a/src/it/unimi/dsi/io/NullInputStream.java
+++ b/src/it/unimi/dsi/io/NullInputStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Sebastiano Vigna
+ * Copyright (C) 2003-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/NullOutputStream.java b/src/it/unimi/dsi/io/NullOutputStream.java
index 136b8f5..b293e10 100644
--- a/src/it/unimi/dsi/io/NullOutputStream.java
+++ b/src/it/unimi/dsi/io/NullOutputStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Sebastiano Vigna
+ * Copyright (C) 2003-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/NullReader.java b/src/it/unimi/dsi/io/NullReader.java
index 54cb95c..caaebd6 100644
--- a/src/it/unimi/dsi/io/NullReader.java
+++ b/src/it/unimi/dsi/io/NullReader.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Sebastiano Vigna
+ * Copyright (C) 2003-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/OfflineIterable.java b/src/it/unimi/dsi/io/OfflineIterable.java
index acf3764..09aadff 100644
--- a/src/it/unimi/dsi/io/OfflineIterable.java
+++ b/src/it/unimi/dsi/io/OfflineIterable.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/OutputBitStream.java b/src/it/unimi/dsi/io/OutputBitStream.java
index f36f610..7f292b4 100644
--- a/src/it/unimi/dsi/io/OutputBitStream.java
+++ b/src/it/unimi/dsi/io/OutputBitStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/SafelyCloseable.java b/src/it/unimi/dsi/io/SafelyCloseable.java
index 16c8558..d6133c8 100644
--- a/src/it/unimi/dsi/io/SafelyCloseable.java
+++ b/src/it/unimi/dsi/io/SafelyCloseable.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Sebastiano Vigna
+ * Copyright (C) 2006-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/SegmentedInputStream.java b/src/it/unimi/dsi/io/SegmentedInputStream.java
index eec40e3..d03aa32 100644
--- a/src/it/unimi/dsi/io/SegmentedInputStream.java
+++ b/src/it/unimi/dsi/io/SegmentedInputStream.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Sebastiano Vigna
+ * Copyright (C) 2006-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/io/WordReader.java b/src/it/unimi/dsi/io/WordReader.java
index edb3178..0d2ca5c 100644
--- a/src/it/unimi/dsi/io/WordReader.java
+++ b/src/it/unimi/dsi/io/WordReader.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2005-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/lang/EnumStringParser.java b/src/it/unimi/dsi/lang/EnumStringParser.java
index f5a1487..e2fe25d 100644
--- a/src/it/unimi/dsi/lang/EnumStringParser.java
+++ b/src/it/unimi/dsi/lang/EnumStringParser.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2016-2021 Sebastiano Vigna
+ * Copyright (C) 2016-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/lang/FlyweightPrototype.java b/src/it/unimi/dsi/lang/FlyweightPrototype.java
index 2079e0e..40c68d9 100644
--- a/src/it/unimi/dsi/lang/FlyweightPrototype.java
+++ b/src/it/unimi/dsi/lang/FlyweightPrototype.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Sebastiano Vigna
+ * Copyright (C) 2006-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/lang/FlyweightPrototypes.java b/src/it/unimi/dsi/lang/FlyweightPrototypes.java
index 6f167a6..37df027 100644
--- a/src/it/unimi/dsi/lang/FlyweightPrototypes.java
+++ b/src/it/unimi/dsi/lang/FlyweightPrototypes.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2006-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/lang/MutableString.java b/src/it/unimi/dsi/lang/MutableString.java
index b1db4fc..4b9f06f 100644
--- a/src/it/unimi/dsi/lang/MutableString.java
+++ b/src/it/unimi/dsi/lang/MutableString.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2002-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/lang/ObjectParser.java b/src/it/unimi/dsi/lang/ObjectParser.java
index ee25d29..baded43 100644
--- a/src/it/unimi/dsi/lang/ObjectParser.java
+++ b/src/it/unimi/dsi/lang/ObjectParser.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2006-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/logging/ProgressLogger.java b/src/it/unimi/dsi/logging/ProgressLogger.java
index 9fdf42b..7890848 100644
--- a/src/it/unimi/dsi/logging/ProgressLogger.java
+++ b/src/it/unimi/dsi/logging/ProgressLogger.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/Attribute.java b/src/it/unimi/dsi/parser/Attribute.java
index 8e20ca8..be2cd10 100644
--- a/src/it/unimi/dsi/parser/Attribute.java
+++ b/src/it/unimi/dsi/parser/Attribute.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/BulletParser.java b/src/it/unimi/dsi/parser/BulletParser.java
index cbb1dc8..b6fe783 100644
--- a/src/it/unimi/dsi/parser/BulletParser.java
+++ b/src/it/unimi/dsi/parser/BulletParser.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/Element.java b/src/it/unimi/dsi/parser/Element.java
index 941a353..50c5dda 100644
--- a/src/it/unimi/dsi/parser/Element.java
+++ b/src/it/unimi/dsi/parser/Element.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/Entity.java b/src/it/unimi/dsi/parser/Entity.java
index bf3e127..0a1331b 100644
--- a/src/it/unimi/dsi/parser/Entity.java
+++ b/src/it/unimi/dsi/parser/Entity.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/HTMLFactory.java b/src/it/unimi/dsi/parser/HTMLFactory.java
index 807d365..5ba798a 100644
--- a/src/it/unimi/dsi/parser/HTMLFactory.java
+++ b/src/it/unimi/dsi/parser/HTMLFactory.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/ParsingFactory.java b/src/it/unimi/dsi/parser/ParsingFactory.java
index 3c9b225..6884cb7 100644
--- a/src/it/unimi/dsi/parser/ParsingFactory.java
+++ b/src/it/unimi/dsi/parser/ParsingFactory.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/WellFormedXmlFactory.java b/src/it/unimi/dsi/parser/WellFormedXmlFactory.java
index c41183f..4191340 100644
--- a/src/it/unimi/dsi/parser/WellFormedXmlFactory.java
+++ b/src/it/unimi/dsi/parser/WellFormedXmlFactory.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/Callback.java b/src/it/unimi/dsi/parser/callback/Callback.java
index 0cf112e..cb55fa3 100644
--- a/src/it/unimi/dsi/parser/callback/Callback.java
+++ b/src/it/unimi/dsi/parser/callback/Callback.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/ComposedCallbackBuilder.java b/src/it/unimi/dsi/parser/callback/ComposedCallbackBuilder.java
index c1fd6ef..f36d8bb 100644
--- a/src/it/unimi/dsi/parser/callback/ComposedCallbackBuilder.java
+++ b/src/it/unimi/dsi/parser/callback/ComposedCallbackBuilder.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/DebugCallbackDecorator.java b/src/it/unimi/dsi/parser/callback/DebugCallbackDecorator.java
index 181e61a..c1d1697 100644
--- a/src/it/unimi/dsi/parser/callback/DebugCallbackDecorator.java
+++ b/src/it/unimi/dsi/parser/callback/DebugCallbackDecorator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/DefaultCallback.java b/src/it/unimi/dsi/parser/callback/DefaultCallback.java
index f03df55..2248dce 100644
--- a/src/it/unimi/dsi/parser/callback/DefaultCallback.java
+++ b/src/it/unimi/dsi/parser/callback/DefaultCallback.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/LinkExtractor.java b/src/it/unimi/dsi/parser/callback/LinkExtractor.java
index da3fa52..e3736b9 100644
--- a/src/it/unimi/dsi/parser/callback/LinkExtractor.java
+++ b/src/it/unimi/dsi/parser/callback/LinkExtractor.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/parser/callback/TextExtractor.java b/src/it/unimi/dsi/parser/callback/TextExtractor.java
index 5988706..eca835a 100644
--- a/src/it/unimi/dsi/parser/callback/TextExtractor.java
+++ b/src/it/unimi/dsi/parser/callback/TextExtractor.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/stat/Jackknife.java b/src/it/unimi/dsi/stat/Jackknife.java
index 3685f25..f5a8cbf 100644
--- a/src/it/unimi/dsi/stat/Jackknife.java
+++ b/src/it/unimi/dsi/stat/Jackknife.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/stat/SummaryStats.java b/src/it/unimi/dsi/stat/SummaryStats.java
index abe7289..88037a2 100644
--- a/src/it/unimi/dsi/stat/SummaryStats.java
+++ b/src/it/unimi/dsi/stat/SummaryStats.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/stat/Ziggurat.java b/src/it/unimi/dsi/stat/Ziggurat.java
index db4f9db..959e10e 100644
--- a/src/it/unimi/dsi/stat/Ziggurat.java
+++ b/src/it/unimi/dsi/stat/Ziggurat.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/GeneratePrecomputedCodes.java b/src/it/unimi/dsi/test/GeneratePrecomputedCodes.java
index 25f2dc7..990ec25 100644
--- a/src/it/unimi/dsi/test/GeneratePrecomputedCodes.java
+++ b/src/it/unimi/dsi/test/GeneratePrecomputedCodes.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/GeneratePrecomputedOutputCodes.java b/src/it/unimi/dsi/test/GeneratePrecomputedOutputCodes.java
index b860ecd..07d66b6 100644
--- a/src/it/unimi/dsi/test/GeneratePrecomputedOutputCodes.java
+++ b/src/it/unimi/dsi/test/GeneratePrecomputedOutputCodes.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/InputBitStreamSpeedTest.java b/src/it/unimi/dsi/test/InputBitStreamSpeedTest.java
index dc1a2a8..2d54db3 100644
--- a/src/it/unimi/dsi/test/InputBitStreamSpeedTest.java
+++ b/src/it/unimi/dsi/test/InputBitStreamSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/LeastSignificantBitSpeedTest.java b/src/it/unimi/dsi/test/LeastSignificantBitSpeedTest.java
index 0a1685d..a36686e 100644
--- a/src/it/unimi/dsi/test/LeastSignificantBitSpeedTest.java
+++ b/src/it/unimi/dsi/test/LeastSignificantBitSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/MutableStringLengthSpeedTest.java b/src/it/unimi/dsi/test/MutableStringLengthSpeedTest.java
index 752a1da..1a88bc5 100644
--- a/src/it/unimi/dsi/test/MutableStringLengthSpeedTest.java
+++ b/src/it/unimi/dsi/test/MutableStringLengthSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/MutableStringRegressionTest.java b/src/it/unimi/dsi/test/MutableStringRegressionTest.java
index 7fbad91..0967b47 100644
--- a/src/it/unimi/dsi/test/MutableStringRegressionTest.java
+++ b/src/it/unimi/dsi/test/MutableStringRegressionTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/MutableStringReplaceSpeedTest.java b/src/it/unimi/dsi/test/MutableStringReplaceSpeedTest.java
index f797c08..402be97 100644
--- a/src/it/unimi/dsi/test/MutableStringReplaceSpeedTest.java
+++ b/src/it/unimi/dsi/test/MutableStringReplaceSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/RandomSpeed.java b/src/it/unimi/dsi/test/RandomSpeed.java
index 29df475..58d5400 100644
--- a/src/it/unimi/dsi/test/RandomSpeed.java
+++ b/src/it/unimi/dsi/test/RandomSpeed.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/StringMapSpeedTest.java b/src/it/unimi/dsi/test/StringMapSpeedTest.java
index 89f8717..9c1ddf2 100644
--- a/src/it/unimi/dsi/test/StringMapSpeedTest.java
+++ b/src/it/unimi/dsi/test/StringMapSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/TextPatternSpeedTest.java b/src/it/unimi/dsi/test/TextPatternSpeedTest.java
index 0d37f0b..bed1884 100644
--- a/src/it/unimi/dsi/test/TextPatternSpeedTest.java
+++ b/src/it/unimi/dsi/test/TextPatternSpeedTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/WTF.java b/src/it/unimi/dsi/test/WTF.java
index 287e858..2969893 100644
--- a/src/it/unimi/dsi/test/WTF.java
+++ b/src/it/unimi/dsi/test/WTF.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/XorShift.java b/src/it/unimi/dsi/test/XorShift.java
index ddea34a..656eb6d 100644
--- a/src/it/unimi/dsi/test/XorShift.java
+++ b/src/it/unimi/dsi/test/XorShift.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/XorShiftPoly.java b/src/it/unimi/dsi/test/XorShiftPoly.java
index 6111bca..c240da5 100644
--- a/src/it/unimi/dsi/test/XorShiftPoly.java
+++ b/src/it/unimi/dsi/test/XorShiftPoly.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/XorShiftPoly116.java b/src/it/unimi/dsi/test/XorShiftPoly116.java
index ec35af0..a040f73 100644
--- a/src/it/unimi/dsi/test/XorShiftPoly116.java
+++ b/src/it/unimi/dsi/test/XorShiftPoly116.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/test/XorShiftPoly928.java b/src/it/unimi/dsi/test/XorShiftPoly928.java
index 46d4eef..3c0ad4f 100644
--- a/src/it/unimi/dsi/test/XorShiftPoly928.java
+++ b/src/it/unimi/dsi/test/XorShiftPoly928.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/AbstractPrefixMap.java b/src/it/unimi/dsi/util/AbstractPrefixMap.java
index 3624381..6803461 100644
--- a/src/it/unimi/dsi/util/AbstractPrefixMap.java
+++ b/src/it/unimi/dsi/util/AbstractPrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -28,16 +28,21 @@ import it.unimi.dsi.fastutil.objects.Object2ObjectFunction;
 import it.unimi.dsi.fastutil.objects.ObjectList;
 import it.unimi.dsi.lang.MutableString;
 
-/** An abstract implementation of a prefix map.
+/**
+ * An abstract implementation of a prefix map.
  *
- * <p>This class provides the full serives of a {@link PrefixMap} by implementing just
+ * <p>
+ * This class provides the full services of a {@link PrefixMap} by implementing just
  * {@link #getInterval(CharSequence)} and {@link #getTerm(int, MutableString)}
  */
 
 public abstract class AbstractPrefixMap extends AbstractObject2LongFunction<CharSequence> implements PrefixMap<MutableString>, Serializable {
 	private static final long serialVersionUID = 1L;
+	/** A cached view of the map as a range map. */
 	protected Object2ObjectFunction<CharSequence, Interval> rangeMap;
+	/** A cached view of the map as a prefix map. */
 	protected Object2ObjectFunction<Interval, MutableString> prefixMap;
+	/** A cached view of the map as a list of mutable strings. */
 	protected ObjectList<MutableString> list;
 
 	// We must guarantee that, unless the user says otherwise, the default return value is -1.
diff --git a/src/it/unimi/dsi/util/BloomFilter.java b/src/it/unimi/dsi/util/BloomFilter.java
index 5bd2643..71544e8 100644
--- a/src/it/unimi/dsi/util/BloomFilter.java
+++ b/src/it/unimi/dsi/util/BloomFilter.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2004-2021 Sebastiano Vigna
+ * Copyright (C) 2004-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/ByteBufferLongBigList.java b/src/it/unimi/dsi/util/ByteBufferLongBigList.java
index 2013d31..fc86519 100644
--- a/src/it/unimi/dsi/util/ByteBufferLongBigList.java
+++ b/src/it/unimi/dsi/util/ByteBufferLongBigList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -33,22 +33,27 @@ import it.unimi.dsi.fastutil.longs.LongBigList;
 import it.unimi.dsi.lang.FlyweightPrototype;
 
 
-/** A bridge between byte {@linkplain ByteBuffer buffers} and {@linkplain LongBigList long big lists}.
+/**
+ * A bridge between byte {@linkplain ByteBuffer buffers} and {@linkplain LongBigList long big
+ * lists}.
  *
- * <p>Java's {@linkplain FileChannel#map(MapMode, long, long) memory-mapping facilities} have
- * the severe limitation of mapping at most {@link Integer#MAX_VALUE} bytes, as they
- * expose the content of a file using a {@link MappedByteBuffer}. This class can {@linkplain #map(FileChannel, ByteOrder, FileChannel.MapMode) expose
- * a file of longs of arbitrary length} as a {@linkplain LongBigList}
- * that is actually based on an array of {@link MappedByteBuffer}s, each mapping
- * a <em>chunk</em> of {@link #CHUNK_SIZE} longs.
+ * <p>
+ * Java's {@linkplain FileChannel#map(MapMode, long, long) memory-mapping facilities} have the
+ * severe limitation of mapping at most {@link Integer#MAX_VALUE} bytes, as they expose the content
+ * of a file using a {@link MappedByteBuffer}. This class can
+ * {@linkplain #map(FileChannel, ByteOrder, FileChannel.MapMode) expose a file of longs of arbitrary
+ * length} as a {@link LongBigList} that is actually based on an array of {@link MappedByteBuffer}s,
+ * each mapping a <em>chunk</em> of {@link #CHUNK_SIZE} longs.
  *
- * <p>Instances of this class are not thread safe, but the {@link #copy()} method provides a lightweight
- * duplicate that can be accessed independently by another thread.
- * Only chunks that are actually used will be {@linkplain ByteBuffer#duplicate() duplicated} lazily.
+ * <p>
+ * Instances of this class are not thread safe, but the {@link #copy()} method provides a
+ * lightweight duplicate that can be accessed independently by another thread. Only chunks that are
+ * actually used will be {@linkplain ByteBuffer#duplicate() duplicated} lazily.
  *
  * @author Sebastiano Vigna
+ * @deprecated Use {@link MappedLongBigList} instead.
  */
-
+@Deprecated
 public class ByteBufferLongBigList extends AbstractLongBigList implements FlyweightPrototype <ByteBufferLongBigList> {
 	private static int CHUNK_SHIFT = 27;
 
diff --git a/src/it/unimi/dsi/util/CircularCharArrayBuffer.java b/src/it/unimi/dsi/util/CircularCharArrayBuffer.java
index f9645fa..10c6e34 100644
--- a/src/it/unimi/dsi/util/CircularCharArrayBuffer.java
+++ b/src/it/unimi/dsi/util/CircularCharArrayBuffer.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2006-2021 Paolo Boldi
+ * Copyright (C) 2006-2022 Paolo Boldi
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/FrontCodedStringList.java b/src/it/unimi/dsi/util/FrontCodedStringList.java
index e6ab5ae..e72ec3c 100644
--- a/src/it/unimi/dsi/util/FrontCodedStringList.java
+++ b/src/it/unimi/dsi/util/FrontCodedStringList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -54,31 +54,30 @@ import it.unimi.dsi.io.LineIterator;
 import it.unimi.dsi.lang.MutableString;
 import it.unimi.dsi.logging.ProgressLogger;
 
-/** Compact storage of strings using front-coding compression (a&#46;k&#46;a&#46; compression by prefix omission).
+/**
+ * Compact storage of strings using front-coding compression (also known as compression by prefix
+ * omission).
  *
- * <P>This class stores a list of strings using front-coding
- * (a.k.a. prefix-omission) compression;
- * the compression will be reasonable only if the list is sorted, but you could
- * also use instances of this class just as a handy way to manage a large
- * amount of strings. It implements an immutable {@link
- * it.unimi.dsi.fastutil.objects.ObjectList} that returns the <var>i</var>-th
- * string (as a {@link MutableString}) when the {@link #get(int)} method is
- * called with argument <var>i</var>. The returned mutable string may be freely
- * modified.
+ * <P>
+ * This class stores a list of strings using front-coding (also known as prefix-omission)
+ * compression; the compression will be reasonable only if the list is sorted, but you could also
+ * use instances of this class just as a handy way to manage a large amount of strings. It
+ * implements an immutable {@link it.unimi.dsi.fastutil.objects.ObjectList} that returns the
+ * <var>i</var>-th string (as a {@link MutableString}) when the {@link #get(int)} method is called
+ * with argument <var>i</var>. The returned mutable string may be freely modified.
  *
- * <P>As a commodity, this class provides a main method that reads from
- * standard input a sequence of newline-separated strings, and
- * writes a corresponding serialized front-coded string list.
+ * <P>
+ * As a commodity, this class provides a main method that reads from standard input a sequence of
+ * newline-separated strings, and writes a corresponding serialized front-coded string list.
  *
  * <H2>Implementation Details</H2>
  *
- * <P>To store the list of strings, we use either a UTF-8 coded {@link
- * ByteArrayFrontCodedList}, or a {@link CharArrayFrontCodedList}, depending on
- * the value of the {@link #FrontCodedStringList(Iterator,int,boolean)
- * utf8} parameter at creation time. In the first case, if the
- * strings are ASCII-oriented the resulting array will be much smaller, but
- * access times will increase manifold, as each string must be UTF-8 decoded
- * before being returned.
+ * <P>
+ * To store the list of strings, we use either a UTF-8 coded {@link ByteArrayFrontCodedList}, or a
+ * {@link CharArrayFrontCodedList}, depending on the value of the
+ * {@link #FrontCodedStringList(Iterator,int,boolean) utf8} parameter at creation time. In the first
+ * case, if the strings are ASCII-oriented the resulting array will be much smaller, but access
+ * times will increase manifold, as each string must be UTF-8 decoded before being returned.
  */
 
 public class FrontCodedStringList extends AbstractObjectList<MutableString> implements RandomAccess, Serializable {
@@ -165,10 +164,13 @@ public class FrontCodedStringList extends AbstractObjectList<MutableString> impl
 		return utf8 ? byteFrontCodedList.ratio() : charFrontCodedList.ratio();
 	}
 
-	/** Returns the element at the specified position in this front-coded as a mutable string.
+	/**
+	 * Returns the element at the specified position in this front-coded string list as a mutable
+	 * string.
 	 *
 	 * @param index an index in the list.
-	 * @return a {@link MutableString} that will contain the string at the specified position. The string may be freely modified.
+	 * @return a {@link MutableString} that will contain the string at the specified position. The
+	 *         string may be freely modified.
 	 */
 	@Override
 	public MutableString get(final int index) {
@@ -177,7 +179,9 @@ public class FrontCodedStringList extends AbstractObjectList<MutableString> impl
 						: charFrontCodedList.getArray(index));
 	}
 
-	/** Returns the element at the specified position in this front-coded list by storing it in a mutable string.
+	/**
+	 * Returns the element at the specified position in this front-coded string list by storing it in a
+	 * mutable string.
 	 *
 	 * @param index an index in the list.
 	 * @param s a mutable string that will contain the string at the specified position.
diff --git a/src/it/unimi/dsi/util/HyperLogLogCounterArray.java b/src/it/unimi/dsi/util/HyperLogLogCounterArray.java
index c8d9b3c..e33018f 100644
--- a/src/it/unimi/dsi/util/HyperLogLogCounterArray.java
+++ b/src/it/unimi/dsi/util/HyperLogLogCounterArray.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2010-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/ImmutableBinaryTrie.java b/src/it/unimi/dsi/util/ImmutableBinaryTrie.java
index cc1f909..116465e 100644
--- a/src/it/unimi/dsi/util/ImmutableBinaryTrie.java
+++ b/src/it/unimi/dsi/util/ImmutableBinaryTrie.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/ImmutableExternalPrefixMap.java b/src/it/unimi/dsi/util/ImmutableExternalPrefixMap.java
index 22abf0a..f1b5cb5 100644
--- a/src/it/unimi/dsi/util/ImmutableExternalPrefixMap.java
+++ b/src/it/unimi/dsi/util/ImmutableExternalPrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/IntParallelCounterArray.java b/src/it/unimi/dsi/util/IntParallelCounterArray.java
index e234bb1..6baf3f0 100644
--- a/src/it/unimi/dsi/util/IntParallelCounterArray.java
+++ b/src/it/unimi/dsi/util/IntParallelCounterArray.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2010-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/Interval.java b/src/it/unimi/dsi/util/Interval.java
index 4ad0eeb..05d9de8 100644
--- a/src/it/unimi/dsi/util/Interval.java
+++ b/src/it/unimi/dsi/util/Interval.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2003-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/Intervals.java b/src/it/unimi/dsi/util/Intervals.java
index 42af173..a6a8217 100644
--- a/src/it/unimi/dsi/util/Intervals.java
+++ b/src/it/unimi/dsi/util/Intervals.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2003-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/KahanSummation.java b/src/it/unimi/dsi/util/KahanSummation.java
index 114318f..6186bdf 100644
--- a/src/it/unimi/dsi/util/KahanSummation.java
+++ b/src/it/unimi/dsi/util/KahanSummation.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/LiterallySignedStringMap.java b/src/it/unimi/dsi/util/LiterallySignedStringMap.java
index 1c478f5..0d91b29 100644
--- a/src/it/unimi/dsi/util/LiterallySignedStringMap.java
+++ b/src/it/unimi/dsi/util/LiterallySignedStringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2009-2021 Sebastiano Vigna
+ * Copyright (C) 2009-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/LongInterval.java b/src/it/unimi/dsi/util/LongInterval.java
index 4882d04..2e09614 100644
--- a/src/it/unimi/dsi/util/LongInterval.java
+++ b/src/it/unimi/dsi/util/LongInterval.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2003-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/LongIntervals.java b/src/it/unimi/dsi/util/LongIntervals.java
index 9b00117..6d2c226 100644
--- a/src/it/unimi/dsi/util/LongIntervals.java
+++ b/src/it/unimi/dsi/util/LongIntervals.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2003-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/PermutedFrontCodedStringList.java b/src/it/unimi/dsi/util/PermutedFrontCodedStringList.java
index 3beb921..08048d0 100644
--- a/src/it/unimi/dsi/util/PermutedFrontCodedStringList.java
+++ b/src/it/unimi/dsi/util/PermutedFrontCodedStringList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/PrefixMap.java b/src/it/unimi/dsi/util/PrefixMap.java
index 89e79b5..c390688 100644
--- a/src/it/unimi/dsi/util/PrefixMap.java
+++ b/src/it/unimi/dsi/util/PrefixMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2004-2021 Sebastiano Vigna
+ * Copyright (C) 2004-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/Properties.java b/src/it/unimi/dsi/util/Properties.java
index ae7a820..737fbca 100644
--- a/src/it/unimi/dsi/util/Properties.java
+++ b/src/it/unimi/dsi/util/Properties.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/SemiExternalGammaList.java b/src/it/unimi/dsi/util/SemiExternalGammaList.java
index 970a80a..4abd663 100644
--- a/src/it/unimi/dsi/util/SemiExternalGammaList.java
+++ b/src/it/unimi/dsi/util/SemiExternalGammaList.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/ShiftAddXorSignedStringMap.java b/src/it/unimi/dsi/util/ShiftAddXorSignedStringMap.java
index 4d99830..67c4828 100644
--- a/src/it/unimi/dsi/util/ShiftAddXorSignedStringMap.java
+++ b/src/it/unimi/dsi/util/ShiftAddXorSignedStringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/SplitMix64Random.java b/src/it/unimi/dsi/util/SplitMix64Random.java
index d0bbcdc..4116547 100644
--- a/src/it/unimi/dsi/util/SplitMix64Random.java
+++ b/src/it/unimi/dsi/util/SplitMix64Random.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2015-2021 Sebastiano Vigna
+ * Copyright (C) 2015-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/SplitMix64RandomGenerator.java b/src/it/unimi/dsi/util/SplitMix64RandomGenerator.java
index d4beac2..c319c40 100644
--- a/src/it/unimi/dsi/util/SplitMix64RandomGenerator.java
+++ b/src/it/unimi/dsi/util/SplitMix64RandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2015-2021 Sebastiano Vigna
+ * Copyright (C) 2015-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/StringMap.java b/src/it/unimi/dsi/util/StringMap.java
index fc97a35..17860e9 100644
--- a/src/it/unimi/dsi/util/StringMap.java
+++ b/src/it/unimi/dsi/util/StringMap.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/StringMaps.java b/src/it/unimi/dsi/util/StringMaps.java
index 8cc354d..cff0679 100644
--- a/src/it/unimi/dsi/util/StringMaps.java
+++ b/src/it/unimi/dsi/util/StringMaps.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2008-2021 Sebastiano Vigna
+ * Copyright (C) 2008-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/TernaryIntervalSearchTree.java b/src/it/unimi/dsi/util/TernaryIntervalSearchTree.java
index 71c1c81..e4a6e0c 100644
--- a/src/it/unimi/dsi/util/TernaryIntervalSearchTree.java
+++ b/src/it/unimi/dsi/util/TernaryIntervalSearchTree.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2005-2021 Sebastiano Vigna
+ * Copyright (C) 2005-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/TextPattern.java b/src/it/unimi/dsi/util/TextPattern.java
index 5a13947..11750c4 100644
--- a/src/it/unimi/dsi/util/TextPattern.java
+++ b/src/it/unimi/dsi/util/TextPattern.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2003-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2003-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandom.java b/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandom.java
index b8af468..164d0db 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandom.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -28,27 +28,37 @@ import org.apache.commons.math3.random.RandomGenerator;
 import it.unimi.dsi.Util;
 import it.unimi.dsi.logging.ProgressLogger;
 
-/** A fast, all-purpose, rock-solid, small-state {@linkplain Random pseudorandom number generator}. It has excellent speed,
- * but its state space (128 bits) that is large enough for
- * mild parallelism only; it passes all tests we are aware of.
- * In Java, it is slightly faster than a {@link XoRoShiRo128StarStarRandom}.
- * More information can be found at our <a href="http://prng.di.unimi.it/">PRNG page</a>.
+/**
+ * A fast, all-purpose, rock-solid, small-state {@linkplain Random pseudorandom number generator}.
+ * It has excellent speed, but its state space (128 bits) that is large enough for mild parallelism
+ * only; it passes all tests we are aware of. In Java, it is slightly faster than a
+ * {@link XoRoShiRo128StarStarRandom}. More information can be found at our
+ * <a href="http://prng.di.unimi.it/">PRNG page</a>.
  *
- * <p>If you need to generate just floating-point numbers, {@link XoRoShiRo128PlusRandom} is slightly faster. If you can use more space,
- * you might try {@link XoShiRo256PlusPlusRandom}.
+ * <p>
+ * Note that starting with Java 17 you can find this generator in <a href=
+ * "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html"><code>java.util.random</code></a>.
  *
- * <p>By using the supplied {@link #jump()} method it is possible to generate non-overlapping long sequences
- * for parallel computations; {@link #longJump()} makes it possible to create several
- * starting points, each providing several non-overlapping sequences, for distributed computations. This class provides also a {@link #split()} method to support recursive parallel computations, in the spirit of
- * {@link SplittableRandom}.
+ * <p>
+ * If you need to generate just floating-point numbers, {@link XoRoShiRo128PlusRandom} is slightly
+ * faster. If you can use more space, you might try {@link XoShiRo256PlusPlusRandom}.
  *
- * <p><strong>Warning</strong>: before release 2.6.3, the {@link #split()} method
- * would not alter the state of the caller, and it would return instances initialized in the same
- * way if called multiple times. This was a major mistake in the implementation and it has been fixed,
- * but as a consequence the output of the caller after a call to {@link #split()} is
- * now different, and the result of {@link #split()} is initialized in a different way.
+ * <p>
+ * By using the supplied {@link #jump()} method it is possible to generate non-overlapping long
+ * sequences for parallel computations; {@link #longJump()} makes it possible to create several
+ * starting points, each providing several non-overlapping sequences, for distributed computations.
+ * This class provides also a {@link #split()} method to support recursive parallel computations, in
+ * the spirit of {@link SplittableRandom}.
  *
- * <p>Note that this is not a {@linkplain SecureRandom secure generator}.
+ * <p>
+ * <strong>Warning</strong>: before release 2.6.3, the {@link #split()} method would not alter the
+ * state of the caller, and it would return instances initialized in the same way if called multiple
+ * times. This was a major mistake in the implementation and it has been fixed, but as a consequence
+ * the output of the caller after a call to {@link #split()} is now different, and the result of
+ * {@link #split()} is initialized in a different way.
+ *
+ * <p>
+ * Note that this is not a {@linkplain SecureRandom secure generator}.
  *
  * @version 1.0
  * @see it.unimi.dsi.util
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGenerator.java b/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGenerator.java
index 3d4619d..8ed3455 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -30,27 +30,38 @@ import org.apache.commons.math3.random.RandomGenerator;
 import it.unimi.dsi.Util;
 import it.unimi.dsi.logging.ProgressLogger;
 
-/** A fast, all-purpose, rock-solid, small-state {@linkplain RandomGenerator pseudorandom number generator}. It has excellent speed,
- * but its state space (128 bits) that is large enough for
- * mild parallelism only; it passes all tests we are aware of.
- * In Java, it is slightly faster than a {@link XoRoShiRo128StarStarRandomGenerator}.
- * More information can be found at our <a href="http://prng.di.unimi.it/">PRNG page</a>.
+/**
+ * A fast, all-purpose, rock-solid, small-state {@linkplain RandomGenerator pseudorandom number
+ * generator}. It has excellent speed, but its state space (128 bits) that is large enough for mild
+ * parallelism only; it passes all tests we are aware of. In Java, it is slightly faster than a
+ * {@link XoRoShiRo128StarStarRandomGenerator}. More information can be found at our
+ * <a href="http://prng.di.unimi.it/">PRNG page</a>.
  *
- * <p>If you need to generate just floating-point numbers, {@link XoRoShiRo128PlusRandomGenerator} is slightly faster. If you can use more space,
- * you might try {@link XoShiRo256PlusPlusRandomGenerator}.
+ * <p>
+ * Note that starting with Java 17 you can find this generator in <a href=
+ * "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html"><code>java.util.random</code></a>.
  *
- * <p>By using the supplied {@link #jump()} method it is possible to generate non-overlapping long sequences
- * for parallel computations; {@link #longJump()} makes it possible to create several
- * starting points, each providing several non-overlapping sequences, for distributed computations. This class provides also a {@link #split()} method to support recursive parallel computations, in the spirit of
- * {@link SplittableRandom}.
+ * <p>
+ * If you need to generate just floating-point numbers, {@link XoRoShiRo128PlusRandomGenerator} is
+ * slightly faster. If you can use more space, you might try
+ * {@link XoShiRo256PlusPlusRandomGenerator}.
  *
- * <p><strong>Warning</strong>: before release 2.6.3, the {@link #split()} method
- * would not alter the state of the caller, and it would return instances initialized in the same
- * way if called multiple times. This was a major mistake in the implementation and it has been fixed,
- * but as a consequence the output of the caller after a call to {@link #split()} is
- * now different, and the result of {@link #split()} is initialized in a different way.
+ * <p>
+ * By using the supplied {@link #jump()} method it is possible to generate non-overlapping long
+ * sequences for parallel computations; {@link #longJump()} makes it possible to create several
+ * starting points, each providing several non-overlapping sequences, for distributed computations.
+ * This class provides also a {@link #split()} method to support recursive parallel computations, in
+ * the spirit of {@link SplittableRandom}.
  *
- * <p>Note that this is not a {@linkplain SecureRandom secure generator}.
+ * <p>
+ * <strong>Warning</strong>: before release 2.6.3, the {@link #split()} method would not alter the
+ * state of the caller, and it would return instances initialized in the same way if called multiple
+ * times. This was a major mistake in the implementation and it has been fixed, but as a consequence
+ * the output of the caller after a call to {@link #split()} is now different, and the result of
+ * {@link #split()} is initialized in a different way.
+ *
+ * <p>
+ * Note that this is not a {@linkplain SecureRandom secure generator}.
  *
  * @version 1.0
  * @see it.unimi.dsi.util
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128PlusRandom.java b/src/it/unimi/dsi/util/XoRoShiRo128PlusRandom.java
index 984f988..0c4c5fc 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128PlusRandom.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128PlusRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128PlusRandomGenerator.java b/src/it/unimi/dsi/util/XoRoShiRo128PlusRandomGenerator.java
index 0e59f0a..2f9247b 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128PlusRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128PlusRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandom.java b/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandom.java
index ec9f591..b04e347 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandom.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGenerator.java b/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGenerator.java
index f67e1d2..b67fca5 100644
--- a/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandom.java b/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandom.java
index abbf49f..4e9e22b 100644
--- a/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandom.java
+++ b/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -28,26 +28,37 @@ import org.apache.commons.math3.random.RandomGenerator;
 import it.unimi.dsi.Util;
 import it.unimi.dsi.logging.ProgressLogger;
 
-/** A fast, all-purpose, rock-solid {@linkplain Random pseudorandom number generator}. It has excellent speed, a state space (256 bits) that is large enough for
- * any parallel application, and it passes all tests we are aware of.
- * In Java, it is slightly faster than a {@link XoShiRo256StarStarRandom}.
- * More information can be found at our <a href="http://prng.di.unimi.it/">PRNG page</a>.
+/**
+ * A fast, all-purpose, rock-solid {@linkplain Random pseudorandom number generator}. It has
+ * excellent speed, a state space (256 bits) that is large enough for any parallel application, and
+ * it passes all tests we are aware of. In Java, it is slightly faster than a
+ * {@link XoShiRo256StarStarRandom}. More information can be found at our
+ * <a href="http://prng.di.unimi.it/">PRNG page</a>.
  *
- * <p>If you need to generate just floating-point numbers, {@link XoShiRo256PlusRandom} is slightly faster. If you are tight on space,
- * you might try {@link XoRoShiRo128PlusPlusRandom}.
+ * <p>
+ * Note that starting with Java 17 you can find this generator in <a href=
+ * "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html"><code>java.util.random</code></a>.
  *
- * <p>By using the supplied {@link #jump()} method it is possible to generate non-overlapping long sequences
- * for parallel computations; {@link #longJump()} makes it possible to create several
- * starting points, each providing several non-overlapping sequences, for distributed computations. This class provides also a {@link #split()} method to support recursive parallel computations, in the spirit of
- * {@link SplittableRandom}.
+ * <p>
+ * If you need to generate just floating-point numbers, {@link XoShiRo256PlusRandom} is slightly
+ * faster. If you are tight on space, you might try {@link XoRoShiRo128PlusPlusRandom}.
  *
- * <p><strong>Warning</strong>: before release 2.6.3, the {@link #split()} method
- * would not alter the state of the caller, and it would return instances initialized in the same
- * way if called multiple times. This was a major mistake in the implementation and it has been fixed,
- * but as a consequence the output of the caller after a call to {@link #split()} is
- * now different, and the result of {@link #split()} is initialized in a different way.
+ * <p>
+ * By using the supplied {@link #jump()} method it is possible to generate non-overlapping long
+ * sequences for parallel computations; {@link #longJump()} makes it possible to create several
+ * starting points, each providing several non-overlapping sequences, for distributed computations.
+ * This class provides also a {@link #split()} method to support recursive parallel computations, in
+ * the spirit of {@link SplittableRandom}.
  *
- * <p>Note that this is not a {@linkplain SecureRandom secure generator}.
+ * <p>
+ * <strong>Warning</strong>: before release 2.6.3, the {@link #split()} method would not alter the
+ * state of the caller, and it would return instances initialized in the same way if called multiple
+ * times. This was a major mistake in the implementation and it has been fixed, but as a consequence
+ * the output of the caller after a call to {@link #split()} is now different, and the result of
+ * {@link #split()} is initialized in a different way.
+ *
+ * <p>
+ * Note that this is not a {@linkplain SecureRandom secure generator}.
  *
  * @version 1.0
  * @see it.unimi.dsi.util
diff --git a/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGenerator.java b/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGenerator.java
index 98a6012..f0926fe 100644
--- a/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -29,26 +29,39 @@ import org.apache.commons.math3.random.RandomGenerator;
 import it.unimi.dsi.Util;
 import it.unimi.dsi.logging.ProgressLogger;
 
-/** A fast, all-purpose, rock-solid {@linkplain RandomGenerator pseudorandom number generator}. It has excellent speed, a state space (256 bits) that is large enough for
- * any parallel application, and it passes all tests we are aware of.
- * In Java, it is slightly faster than a {@link XoShiRo256StarStarRandomGenerator}.
- * More information can be found at our <a href="http://prng.di.unimi.it/">PRNG page</a>.
+/**
+ * A fast, all-purpose, rock-solid {@linkplain RandomGenerator pseudorandom number generator}. It
+ * has excellent speed, a state space (256 bits) that is large enough for any parallel application,
+ * and it passes all tests we are aware of. In Java, it is slightly faster than a
+ * {@link XoShiRo256StarStarRandomGenerator}. More information can be found at our
+ * <a href="http://prng.di.unimi.it/">PRNG page</a>.
  *
- * <p>If you need to generate just floating-point numbers, {@link XoShiRo256PlusRandomGenerator} is slightly faster. If you are tight on space,
- * you might try {@link XoRoShiRo128PlusPlusRandomGenerator}.
+ * *
+ * <p>
+ * Note that starting with Java 17 you can find this generator in <a href=
+ * "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html"><code>java.util.random</code></a>.
  *
- * <p>By using the supplied {@link #jump()} method it is possible to generate non-overlapping long sequences
- * for parallel computations; {@link #longJump()} makes it possible to create several
- * starting points, each providing several non-overlapping sequences, for distributed computations. This class provides also a {@link #split()} method to support recursive parallel computations, in the spirit of
- * {@link SplittableRandom}.
+ * <p>
+ * If you need to generate just floating-point numbers, {@link XoShiRo256PlusRandomGenerator} is
+ * slightly faster. If you are tight on space, you might try
+ * {@link XoRoShiRo128PlusPlusRandomGenerator}.
  *
- * <p><strong>Warning</strong>: before release 2.6.3, the {@link #split()} method
- * would not alter the state of the caller, and it would return instances initialized in the same
- * way if called multiple times. This was a major mistake in the implementation and it has been fixed,
- * but as a consequence the output of the caller after a call to {@link #split()} is
- * now different, and the result of {@link #split()} is initialized in a different way.
+ * <p>
+ * By using the supplied {@link #jump()} method it is possible to generate non-overlapping long
+ * sequences for parallel computations; {@link #longJump()} makes it possible to create several
+ * starting points, each providing several non-overlapping sequences, for distributed computations.
+ * This class provides also a {@link #split()} method to support recursive parallel computations, in
+ * the spirit of {@link SplittableRandom}.
  *
- * <p>Note that this is not a {@linkplain SecureRandom secure generator}.
+ * <p>
+ * <strong>Warning</strong>: before release 2.6.3, the {@link #split()} method would not alter the
+ * state of the caller, and it would return instances initialized in the same way if called multiple
+ * times. This was a major mistake in the implementation and it has been fixed, but as a consequence
+ * the output of the caller after a call to {@link #split()} is now different, and the result of
+ * {@link #split()} is initialized in a different way.
+ *
+ * <p>
+ * Note that this is not a {@linkplain SecureRandom secure generator}.
  *
  * @version 1.0
  * @see it.unimi.dsi.util
diff --git a/src/it/unimi/dsi/util/XoShiRo256PlusRandom.java b/src/it/unimi/dsi/util/XoShiRo256PlusRandom.java
index 70664cb..53c7261 100644
--- a/src/it/unimi/dsi/util/XoShiRo256PlusRandom.java
+++ b/src/it/unimi/dsi/util/XoShiRo256PlusRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoShiRo256PlusRandomGenerator.java b/src/it/unimi/dsi/util/XoShiRo256PlusRandomGenerator.java
index 588d6c7..8220a52 100644
--- a/src/it/unimi/dsi/util/XoShiRo256PlusRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoShiRo256PlusRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoShiRo256StarStarRandom.java b/src/it/unimi/dsi/util/XoShiRo256StarStarRandom.java
index 5a75cd1..6f554a3 100644
--- a/src/it/unimi/dsi/util/XoShiRo256StarStarRandom.java
+++ b/src/it/unimi/dsi/util/XoShiRo256StarStarRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XoShiRo256StarStarRandomGenerator.java b/src/it/unimi/dsi/util/XoShiRo256StarStarRandomGenerator.java
index d40b911..2c1a532 100644
--- a/src/it/unimi/dsi/util/XoShiRo256StarStarRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XoShiRo256StarStarRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorGensRandomGenerator.java b/src/it/unimi/dsi/util/XorGensRandomGenerator.java
index 0d139d9..d7524ef 100644
--- a/src/it/unimi/dsi/util/XorGensRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XorGensRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift1024StarPhiRandom.java b/src/it/unimi/dsi/util/XorShift1024StarPhiRandom.java
index a976170..03c6473 100644
--- a/src/it/unimi/dsi/util/XorShift1024StarPhiRandom.java
+++ b/src/it/unimi/dsi/util/XorShift1024StarPhiRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift1024StarPhiRandomGenerator.java b/src/it/unimi/dsi/util/XorShift1024StarPhiRandomGenerator.java
index 31409f4..f8db403 100644
--- a/src/it/unimi/dsi/util/XorShift1024StarPhiRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XorShift1024StarPhiRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift1024StarRandom.java b/src/it/unimi/dsi/util/XorShift1024StarRandom.java
index 6e37fb2..61061d3 100644
--- a/src/it/unimi/dsi/util/XorShift1024StarRandom.java
+++ b/src/it/unimi/dsi/util/XorShift1024StarRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift1024StarRandomGenerator.java b/src/it/unimi/dsi/util/XorShift1024StarRandomGenerator.java
index 2d6c907..459f9a2 100644
--- a/src/it/unimi/dsi/util/XorShift1024StarRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XorShift1024StarRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift128PlusRandom.java b/src/it/unimi/dsi/util/XorShift128PlusRandom.java
index 7c8e588..9994b93 100644
--- a/src/it/unimi/dsi/util/XorShift128PlusRandom.java
+++ b/src/it/unimi/dsi/util/XorShift128PlusRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift128PlusRandomGenerator.java b/src/it/unimi/dsi/util/XorShift128PlusRandomGenerator.java
index d6250bc..1f92d3a 100644
--- a/src/it/unimi/dsi/util/XorShift128PlusRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XorShift128PlusRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift64StarRandom.java b/src/it/unimi/dsi/util/XorShift64StarRandom.java
index 6ce8972..8dd04bf 100644
--- a/src/it/unimi/dsi/util/XorShift64StarRandom.java
+++ b/src/it/unimi/dsi/util/XorShift64StarRandom.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/XorShift64StarRandomGenerator.java b/src/it/unimi/dsi/util/XorShift64StarRandomGenerator.java
index 46defaf..a8e0c3a 100644
--- a/src/it/unimi/dsi/util/XorShift64StarRandomGenerator.java
+++ b/src/it/unimi/dsi/util/XorShift64StarRandomGenerator.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/concurrent/ReorderingBlockingQueue.java b/src/it/unimi/dsi/util/concurrent/ReorderingBlockingQueue.java
index 3a8d1ed..6206c5f 100644
--- a/src/it/unimi/dsi/util/concurrent/ReorderingBlockingQueue.java
+++ b/src/it/unimi/dsi/util/concurrent/ReorderingBlockingQueue.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2017-2021 Sebastiano Vigna
+ * Copyright (C) 2017-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/src/it/unimi/dsi/util/package-info.java b/src/it/unimi/dsi/util/package-info.java
index e66df09..0deba90 100644
--- a/src/it/unimi/dsi/util/package-info.java
+++ b/src/it/unimi/dsi/util/package-info.java
@@ -3,54 +3,112 @@
  *
  * <h2>Pseudorandom number generators</h2>
  *
- * <p><strong>Warning</strong>: before release 2.6.3, the {@code split()} method of all generators
+ * <p>
+ * <strong>Warning</strong>: before release 2.6.3, the {@code split()} method of all generators
  * would not alter the state of the caller, and it would return instances initialized in the same
- * way if called multiple times. This was a major mistake in the implementation and it has been fixed,
- * but as a consequence the output of the caller after a call to {@code split()} is
- * now different, and the result of {@code split()} is initialized in a different way.
+ * way if called multiple times. This was a major mistake in the implementation and it has been
+ * fixed, but as a consequence the output of the caller after a call to {@code split()} is now
+ * different, and the result of {@code split()} is initialized in a different way.
  *
- * <p>We provide a number of fast, high-quality PRNGs with different features. You can get detailed
- * information about the generators at our <a href="http://prng.di.unimi.it/">PRNG page</a>, together
- * with a reasoned guide to the choice of the generator that's right for you.
+ * <p>
+ * We provide a number of fast, high-quality PRNGs with different features. You can get detailed
+ * information about the generators at our <a href="http://prng.di.unimi.it/">PRNG page</a>,
+ * together with a reasoned guide to the choice of the generator that's right for you.
  *
- * <p>A table summarizing timings is provided below. The timings were measured on an
- * Intel&reg; Core&trade; i7-8700B CPU @3.20GHz using
- * <a href="http://openjdk.java.net/projects/code-tools/jmh/">JMH</a> microbenchmarks. The JMH timings were decreased by 1ns, as
- * using the low-level {@code perfasm} profiler the JMH overhead was estimated at &approx;1ns per call.
+ * <p>
+ * Note that starting with Java 17 <code>xoroshiro128++</code> and <code>xoshiro256++</code> are
+ * part of the package <a href=
+ * "https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html"><code>java.util.random</code></a>.
+ *
+ * <p>
+ * A table summarizing timings is provided below. The timings were measured on an Intel&reg;
+ * Core&trade; i7-8700B CPU @3.20GHz using
+ * <a href="http://openjdk.java.net/projects/code-tools/jmh/">JMH</a> microbenchmarks. The JMH
+ * timings were decreased by 1ns, as using the low-level {@code perfasm} profiler the JMH overhead
+ * was estimated at &approx;1ns per call.
  *
  * <TABLE BORDER=1>
  * <caption>Timings in nanoseconds for a few generators</caption>
- * <TR><TH>
+ * <TR>
+ * <TH>
  * <TH>{@link java.util.Random Random}
  * <TH>{@link java.util.concurrent.ThreadLocalRandom ThreadLocalRandom}
  * <TH>{@link java.util.SplittableRandom SplittableRandom}
- * <TH>{@link it.unimi.dsi.util.SplitMix64RandomGenerator <span style='font-variant: small-caps'>SplitMix64</span>}
- * <TH>{@link it.unimi.dsi.util.XoRoShiRo128PlusPlusRandom <code>xoroshiro128++</code>}
- * <TH>{@link it.unimi.dsi.util.XoRoShiRo128StarStarRandom <code>xoroshiro128**</code>}
- * <TH>{@link it.unimi.dsi.util.XoRoShiRo128PlusRandom <code>xoroshiro128+</code>}
- * <TH>{@link it.unimi.dsi.util.XoShiRo256PlusPlusRandom <code>xoshiro256++</code>}
- * <TH>{@link it.unimi.dsi.util.XoShiRo256StarStarRandom <code>xoshiro256**</code>}
- * <TH>{@link it.unimi.dsi.util.XoShiRo256PlusRandom <code>xoshiro256+</code>}
- * <TH>{@link it.unimi.dsi.util.XorShift1024StarPhiRandom <code>xorshift1024*&phi;</code>}
- *
- * <TR><TH STYLE='text-align: left'>nextLong()                                 <TD STYLE='text-align: right'>14.419<TD STYLE='text-align: right'>1.252<TD STYLE='text-align: right'>1.283<TD STYLE='text-align: right'>1.241<TD STYLE='text-align: right'>1.428<TD STYLE='text-align: right'>1.574<TD STYLE='text-align: right'>1.295<TD STYLE='text-align: right'>1.738<TD STYLE='text-align: right'>1.884<TD STYLE='text-align: right'>1.653<TD STYLE='text-align: right'>1.901
- * <TR><TH STYLE='text-align: left'>nextInt(100000)                            <TD STYLE='text-align: right'>6.715<TD STYLE='text-align: right'>2.045<TD STYLE='text-align: right'>2.499<TD STYLE='text-align: right'>2.543<TD STYLE='text-align: right'>2.336<TD STYLE='text-align: right'>2.594<TD STYLE='text-align: right'>1.202<TD STYLE='text-align: right'>2.607<TD STYLE='text-align: right'>2.954<TD STYLE='text-align: right'>2.367<TD STYLE='text-align: right'>3.119
- * <TR><TH STYLE='text-align: left'>nextDouble()                               <TD STYLE='text-align: right'>14.458<TD STYLE='text-align: right'>1.876<TD STYLE='text-align: right'>2.161<TD STYLE='text-align: right'>2.176<TD STYLE='text-align: right'>1.918<TD STYLE='text-align: right'>2.219<TD STYLE='text-align: right'>1.853<TD STYLE='text-align: right'>2.304<TD STYLE='text-align: right'>2.503<TD STYLE='text-align: right'>2.112<TD STYLE='text-align: right'>2.755
+ * <TH>{@link it.unimi.dsi.util.SplitMix64RandomGenerator
+ * <span style='font-variant: small-caps'>SplitMix64</span>}
+ * <TH><code>{@link it.unimi.dsi.util.XoRoShiRo128PlusPlusRandom xoroshiro128++}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XoRoShiRo128StarStarRandom xoroshiro128**}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XoRoShiRo128PlusRandom xoroshiro128+}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XoShiRo256PlusPlusRandom xoshiro256++}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XoShiRo256StarStarRandom xoshiro256**}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XoShiRo256PlusRandom xoshiro256+}</code>
+ * <TH><code>{@link it.unimi.dsi.util.XorShift1024StarPhiRandom xorshift1024*&phi;}</code>
+ *
+ * <TR>
+ * <TH STYLE='text-align: left'>nextLong()
+ * <TD STYLE='text-align: right'>14.419
+ * <TD STYLE='text-align: right'>1.252
+ * <TD STYLE='text-align: right'>1.283
+ * <TD STYLE='text-align: right'>1.241
+ * <TD STYLE='text-align: right'>1.428
+ * <TD STYLE='text-align: right'>1.574
+ * <TD STYLE='text-align: right'>1.295
+ * <TD STYLE='text-align: right'>1.738
+ * <TD STYLE='text-align: right'>1.884
+ * <TD STYLE='text-align: right'>1.653
+ * <TD STYLE='text-align: right'>1.901
+ * <TR>
+ * <TH STYLE='text-align: left'>nextInt(100000)
+ * <TD STYLE='text-align: right'>6.715
+ * <TD STYLE='text-align: right'>2.045
+ * <TD STYLE='text-align: right'>2.499
+ * <TD STYLE='text-align: right'>2.543
+ * <TD STYLE='text-align: right'>2.336
+ * <TD STYLE='text-align: right'>2.594
+ * <TD STYLE='text-align: right'>1.202
+ * <TD STYLE='text-align: right'>2.607
+ * <TD STYLE='text-align: right'>2.954
+ * <TD STYLE='text-align: right'>2.367
+ * <TD STYLE='text-align: right'>3.119
+ * <TR>
+ * <TH STYLE='text-align: left'>nextDouble()
+ * <TD STYLE='text-align: right'>14.458
+ * <TD STYLE='text-align: right'>1.876
+ * <TD STYLE='text-align: right'>2.161
+ * <TD STYLE='text-align: right'>2.176
+ * <TD STYLE='text-align: right'>1.918
+ * <TD STYLE='text-align: right'>2.219
+ * <TD STYLE='text-align: right'>1.853
+ * <TD STYLE='text-align: right'>2.304
+ * <TD STYLE='text-align: right'>2.503
+ * <TD STYLE='text-align: right'>2.112
+ * <TD STYLE='text-align: right'>2.755
  * </TABLE>
  *
- * <p>Note that generators that are <a href="http://prng.di.unimi.it/">extremely fast in C</a>, such as <code>xoshiro256+</code>, do not perform particularly well in Java, most likely
- * because of the cost of accessing variables, which rises as the size of the state space grows. Indeed,
- * smaller-state generators are faster. Moreover, generators based on the <code>++</code>
- * scrambler are slightly faster than those based on the <code>**</code> scrambler, contrarily to what happens in C.
+ * <p>
+ * Note that generators that are <a href="http://prng.di.unimi.it/">extremely fast in C</a>, such as
+ * <code>xoshiro256+</code>, do not perform particularly well in Java, most likely because of the
+ * cost of accessing variables, which rises as the size of the state space grows. Indeed,
+ * smaller-state generators are faster. Moreover, generators based on the <code>++</code> scrambler
+ * are slightly faster than those based on the <code>**</code> scrambler, contrarily to what happens
+ * in C.
  *
- * <p>For each generator, we provide a version that extends {@link java.util.Random}, overriding (as usual) the {@link java.util.Random#next(int) next(int)} method. Nonetheless,
- * since the generators are all inherently 64-bit also {@link java.util.Random#nextInt() nextInt()}, {@link java.util.Random#nextFloat() nextFloat()},
- * {@link java.util.Random#nextLong() nextLong()}, {@link java.util.Random#nextDouble() nextDouble()}, {@link java.util.Random#nextBoolean() nextBoolean()}
- * and {@link java.util.Random#nextBytes(byte[]) nextBytes(byte[])} have been overridden for speed (preserving, of course, {@link java.util.Random}'s semantics).
+ * <p>
+ * For each generator, we provide a version that extends {@link java.util.Random}, overriding (as
+ * usual) the {@link java.util.Random#next(int) next(int)} method. Nonetheless, since the generators
+ * are all inherently 64-bit also {@link java.util.Random#nextInt() nextInt()},
+ * {@link java.util.Random#nextFloat() nextFloat()}, {@link java.util.Random#nextLong() nextLong()},
+ * {@link java.util.Random#nextDouble() nextDouble()}, {@link java.util.Random#nextBoolean()
+ * nextBoolean()} and {@link java.util.Random#nextBytes(byte[]) nextBytes(byte[])} have been
+ * overridden for speed (preserving, of course, {@link java.util.Random}'s semantics).
  *
- * <p>If you do not need an instance of {@link java.util.Random}, or if you need a {@link org.apache.commons.math3.random.RandomGenerator} to use
- * with <a href="http://commons.apache.org/math/">Commons Math</a>, there is for each generator a corresponding {@link org.apache.commons.math3.random.RandomGenerator RandomGenerator}
- * implementation, which indeed we suggest to use in general if you do not need a generator implementing {@link java.util.Random}.
+ * <p>
+ * If you do not need an instance of {@link java.util.Random}, or if you need a
+ * {@link org.apache.commons.math3.random.RandomGenerator} to use with
+ * <a href="http://commons.apache.org/math/">Commons Math</a>, there is for each generator a
+ * corresponding {@link org.apache.commons.math3.random.RandomGenerator RandomGenerator}
+ * implementation, which indeed we suggest to use in general if you do not need a generator
+ * implementing {@link java.util.Random}.
  */
 
 package it.unimi.dsi.util;
diff --git a/src/overview.html b/src/overview.html
index 8645f11..5ecb6ac 100644
--- a/src/overview.html
+++ b/src/overview.html
@@ -40,6 +40,7 @@
 	<li>The {@link it.unimi.dsi.stat} package, containing a lightweight class for {@linkplain it.unimi.dsi.stat.SummaryStats computing basic statistics} and
 	{@linkplain it.unimi.dsi.stat.Jackknife an arbitrary-precision implementation of the Jackknife method}.</li>
 	<li>Lots of utility methods in {@link it.unimi.dsi.Util} (have a look!)</li>
+	<li>{@link it.unimi.dsi.big.util.MappedFrontCodedStringBigList}, which provides compact memory-mapped storage of strings, possibly with some compression.</li> 
 	<li><em>Big</em> versions of I/O and utility classes in {@link it.unimi.dsi.big.io} and {@link it.unimi.dsi.big.util}.</li> 
 	</ul>
   </body>
diff --git a/test/it/unimi/dsi/UtilTest.java b/test/it/unimi/dsi/UtilTest.java
index 19ca368..6313551 100644
--- a/test/it/unimi/dsi/UtilTest.java
+++ b/test/it/unimi/dsi/UtilTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/big/util/FrontCodedStringBigListTest.java b/test/it/unimi/dsi/big/util/FrontCodedStringBigListTest.java
index c9be6e5..cbfcdcd 100644
--- a/test/it/unimi/dsi/big/util/FrontCodedStringBigListTest.java
+++ b/test/it/unimi/dsi/big/util/FrontCodedStringBigListTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -21,14 +21,10 @@ package it.unimi.dsi.big.util;
 
 import static org.junit.Assert.assertEquals;
 
-import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
-import java.util.SplittableRandom;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
 import it.unimi.dsi.lang.MutableString;
@@ -36,7 +32,7 @@ import it.unimi.dsi.lang.MutableString;
 public class FrontCodedStringBigListTest {
 
 	@Test
-	public void testLargeSet() {
+	public void test() {
 		final List<String> c = Arrays.asList(TernaryIntervalSearchTreeTest.WORDS.clone());
 		final MutableString s = new MutableString();
 		for(int p = 0; p < 2; p++) {
@@ -65,36 +61,4 @@ public class FrontCodedStringBigListTest {
 				}
 			}
 	}
-
-	@Ignore("Needs a lot of memory")
-	@Test
-	public void testbig() {
-		final long size = (1L << 31) + 10000;
-		final FrontCodedStringBigList byteArrayFrontCodedBigList = new FrontCodedStringBigList(new Iterator<String>() {
-			SplittableRandom r = new SplittableRandom(0);
-			long i = 0;
-
-			@Override
-			public boolean hasNext() {
-				return i < size;
-			}
-
-			@Override
-			public String next() {
-				i++;
-				return new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1);
-			}
-		}, 10, true);
-		SplittableRandom r = new SplittableRandom(0);
-		for (long i = 0; i < size; i++) {
-			assertEquals(new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1), byteArrayFrontCodedBigList.get(i));
-		}
-		r = new SplittableRandom(0);
-		final MutableString s = new MutableString();
-		for (long i = 0; i < size; i++) {
-			byteArrayFrontCodedBigList.get(i, s);
-			assertEquals(new String(new byte[] { (byte)r.nextLong() }, StandardCharsets.ISO_8859_1), s);
-		}
-	}
-
 }
diff --git a/test/it/unimi/dsi/big/util/ImmutableBinaryTrieTest.java b/test/it/unimi/dsi/big/util/ImmutableBinaryTrieTest.java
index 56ef0ef..8233dae 100644
--- a/test/it/unimi/dsi/big/util/ImmutableBinaryTrieTest.java
+++ b/test/it/unimi/dsi/big/util/ImmutableBinaryTrieTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/big/util/ImmutableExternalPrefixMapTest.java b/test/it/unimi/dsi/big/util/ImmutableExternalPrefixMapTest.java
index 4e98767..41f5633 100644
--- a/test/it/unimi/dsi/big/util/ImmutableExternalPrefixMapTest.java
+++ b/test/it/unimi/dsi/big/util/ImmutableExternalPrefixMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -38,7 +38,7 @@ import it.unimi.dsi.util.LongIntervals;
 
 public class ImmutableExternalPrefixMapTest {
 
-	public void testLargeSet(final int blockSize) throws IOException {
+	public void test(final int blockSize) throws IOException {
 		final Collection<String> c = Arrays.asList(TernaryIntervalSearchTreeTest.WORDS);
 		TernaryIntervalSearchTree t = new TernaryIntervalSearchTree(c);
 		ImmutableExternalPrefixMap d = new ImmutableExternalPrefixMap(c, blockSize);
@@ -81,28 +81,28 @@ public class ImmutableExternalPrefixMapTest {
 	}
 
 	@Test
-	public void testLargeSet64() throws IOException {
-		testLargeSet(64);
+	public void test64() throws IOException {
+		test(64);
 	}
 
 	@Test
-	public void testLargeSet128() throws IOException {
-		testLargeSet(128);
+	public void test128() throws IOException {
+		test(128);
 	}
 
 	@Test
-	public void testLargeSet256() throws IOException {
-		testLargeSet(256);
+	public void test256() throws IOException {
+		test(256);
 	}
 
 	@Test
-	public void testLargeSet1024() throws IOException {
-		testLargeSet(1024);
+	public void test1024() throws IOException {
+		test(1024);
 	}
 
 	@Test
-	public void testLargeSet16384() throws IOException {
-		testLargeSet(16384);
+	public void test16384() throws IOException {
+		test(16384);
 	}
 
 	@Test
diff --git a/test/it/unimi/dsi/big/util/LiterallySignedStringMapTest.java b/test/it/unimi/dsi/big/util/LiterallySignedStringMapTest.java
index 506c833..f55abf2 100644
--- a/test/it/unimi/dsi/big/util/LiterallySignedStringMapTest.java
+++ b/test/it/unimi/dsi/big/util/LiterallySignedStringMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -30,10 +30,7 @@ import java.util.Collections;
 import org.junit.Test;
 
 import it.unimi.dsi.fastutil.Hash;
-import it.unimi.dsi.fastutil.Size64;
 import it.unimi.dsi.fastutil.io.BinIO;
-import it.unimi.dsi.fastutil.objects.AbstractObject2LongFunction;
-import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
 import it.unimi.dsi.fastutil.objects.Object2LongOpenCustomHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectBigLists;
 import it.unimi.dsi.lang.MutableString;
@@ -84,57 +81,4 @@ public class LiterallySignedStringMapTest {
 			for(int i = s.length + n; i-- != s.length;) assertEquals(-1, map.getLong(Integer.toString(i)));
 		}
 	}
-
-	private final class LargeFunction extends AbstractObject2LongFunction<String> implements Size64 {
-		private static final long serialVersionUID = 1L;
-
-		@Override
-		public long getLong(final Object key) {
-			try {
-				final long l = Long.parseLong(key.toString());
-				return l < 1L << 31 ? l : -1;
-			}
-			catch(final Exception e) {
-				return -1;
-			}
-		}
-
-		@Override
-		public boolean containsKey(final Object key) {
-			try {
-				final long l = Long.parseLong(key.toString());
-				return l < 1L << 31;
-			}
-			catch(final Exception e) {
-				return false;
-			}
-		}
-
-		@Override
-		@Deprecated
-		public int size() {
-			return Integer.MAX_VALUE;
-		}
-
-		@Override
-		public long size64() {
-			return 1L << 31;
-		}
-	}
-
-	@Test
-	public void testLarge() {
-		new LiterallySignedStringMap(new LargeFunction(), new AbstractObjectBigList<MutableString>() {
-
-			@Override
-			public MutableString get(final long index) {
-				return new MutableString(Long.toString(index));
-			}
-
-			@Override
-			public long size64() {
-				return 1L << 31;
-			}
-		});
-	}
 }
diff --git a/test/it/unimi/dsi/big/util/LongBigArraySignedStringMapTest.java b/test/it/unimi/dsi/big/util/LongBigArraySignedStringMapTest.java
index 3aab61c..94487a4 100644
--- a/test/it/unimi/dsi/big/util/LongBigArraySignedStringMapTest.java
+++ b/test/it/unimi/dsi/big/util/LongBigArraySignedStringMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/big/util/MappedFrontCodedStringBigListTest.java b/test/it/unimi/dsi/big/util/MappedFrontCodedStringBigListTest.java
new file mode 100644
index 0000000..7701501
--- /dev/null
+++ b/test/it/unimi/dsi/big/util/MappedFrontCodedStringBigListTest.java
@@ -0,0 +1,70 @@
+/*
+ * DSI utilities
+ *
+ * Copyright (C) 2010-2022 Sebastiano Vigna
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the GNU Lesser General Public License v2.1 or later,
+ * which is available at
+ * http://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html,
+ * or the Apache Software License 2.0, which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later OR Apache-2.0
+ */
+
+package it.unimi.dsi.big.util;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.configuration2.ex.ConfigurationException;
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import it.unimi.dsi.lang.MutableString;
+
+public class MappedFrontCodedStringBigListTest {
+
+	@Test
+	public void test() throws IOException, ConfigurationException {
+		final String basename = File.createTempFile(this.getClass().getName(), ".basename").toString();
+		final List<String> c = new ArrayList<>(Arrays.asList(TernaryIntervalSearchTreeTest.WORDS.clone()));
+		c.add(StringUtils.repeat("a", 1000));
+		c.add(StringUtils.repeat("a", 500) + StringUtils.repeat("b", 500));
+		c.add(StringUtils.repeat("a", 1000) + StringUtils.repeat("b", 1000));
+		c.add(StringUtils.repeat("a", 100) + StringUtils.repeat("b", 1000));
+		final MutableString s = new MutableString();
+		Collections.sort(c);
+		for (int p = 0; p < 2; p++) {
+			for (int ratio = 1; ratio < 8; ratio++) {
+				final FrontCodedStringBigList fcl = new FrontCodedStringBigList(c.iterator(), ratio, true);
+
+				MappedFrontCodedStringBigList.build(basename, 4, c.stream().map(x -> x.getBytes(StandardCharsets.UTF_8)).iterator());
+				final MappedFrontCodedStringBigList mfcl = MappedFrontCodedStringBigList.load(basename);
+				for (int i = 0; i < fcl.size64(); i++) {
+					assertEquals(Integer.toString(i), c.get(i), mfcl.get(i).toString());
+					assertEquals(Integer.toString(i), c.get(i), mfcl.getString(i));
+					assertEquals(Integer.toString(i), c.get(i), new String(mfcl.getArray(i), StandardCharsets.UTF_8));
+					fcl.get(i, s);
+					assertEquals(Integer.toString(i), c.get(i), s.toString());
+				}
+			}
+		}
+
+		new File(basename + MappedFrontCodedStringBigList.PROPERTIES_EXTENSION).delete();
+		new File(basename + MappedFrontCodedStringBigList.BYTE_ARRAY_EXTENSION).delete();
+		new File(basename + MappedFrontCodedStringBigList.POINTERS_EXTENSION).delete();
+	}
+}
diff --git a/test/it/unimi/dsi/big/util/SemiExternalGammaBigListTest.java b/test/it/unimi/dsi/big/util/SemiExternalGammaBigListTest.java
index bfd3efa..bd5093c 100644
--- a/test/it/unimi/dsi/big/util/SemiExternalGammaBigListTest.java
+++ b/test/it/unimi/dsi/big/util/SemiExternalGammaBigListTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapTest.java b/test/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapTest.java
index 373e8aa..1b8f0f2 100644
--- a/test/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapTest.java
+++ b/test/it/unimi/dsi/big/util/ShiftAddXorSignedStringMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -27,10 +27,7 @@ import java.util.Arrays;
 
 import org.junit.Test;
 
-import it.unimi.dsi.fastutil.Size64;
 import it.unimi.dsi.fastutil.io.BinIO;
-import it.unimi.dsi.fastutil.objects.AbstractObject2LongFunction;
-import it.unimi.dsi.fastutil.objects.AbstractObjectBigList;
 import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
 
 public class ShiftAddXorSignedStringMapTest {
@@ -61,59 +58,4 @@ public class ShiftAddXorSignedStringMapTest {
 
 		}
 	}
-
-	private final class LargeFunction extends AbstractObject2LongFunction<String> implements Size64 {
-		private static final long serialVersionUID = 1L;
-
-		@Override
-		public long getLong(final Object key) {
-			try {
-				final long l = Long.parseLong((String)key);
-				return l < 1L << 31 ? l : -1;
-			}
-			catch(final Exception e) {
-				return -1;
-			}
-		}
-
-		@Override
-		public boolean containsKey(final Object key) {
-			try {
-				final long l = Long.parseLong((String)key);
-				return l < 1L << 31;
-			}
-			catch(final Exception e) {
-				return false;
-			}
-		}
-
-		@Override
-		@Deprecated
-		public int size() {
-			return Integer.MAX_VALUE;
-		}
-
-		@Override
-		public long size64() {
-			return 1L << 31;
-		}
-	}
-
-	@SuppressWarnings("deprecation")
-	@Test
-	public void testLarge() {
-		new ShiftAddXorSignedStringMap(new AbstractObjectBigList<String>() {
-
-			@Override
-			public String get(final long index) {
-				return Long.toString(index);
-			}
-
-			@Override
-			public long size64() {
-				return 1L << 31;
-			}
-		}.iterator(), new LargeFunction(), 1);
-	}
-
 }
diff --git a/test/it/unimi/dsi/big/util/TernaryIntervalSearchTreeTest.java b/test/it/unimi/dsi/big/util/TernaryIntervalSearchTreeTest.java
index 74be4e7..2928452 100644
--- a/test/it/unimi/dsi/big/util/TernaryIntervalSearchTreeTest.java
+++ b/test/it/unimi/dsi/big/util/TernaryIntervalSearchTreeTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2002-2021 Sebastiano Vigna
+ * Copyright (C) 2002-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -339,7 +339,7 @@ public class TernaryIntervalSearchTreeTest {
 	}
 
 	@Test
-	public void testLargeSet() {
+	public void test() {
 		final List<String> c = new ObjectArrayList<>(WORDS);
 		Collections.shuffle(c);
 		TernaryIntervalSearchTree t = new TernaryIntervalSearchTree(c);
diff --git a/test/it/unimi/dsi/bits/AbstractBitVectorTest.java b/test/it/unimi/dsi/bits/AbstractBitVectorTest.java
index ab13239..4131525 100644
--- a/test/it/unimi/dsi/bits/AbstractBitVectorTest.java
+++ b/test/it/unimi/dsi/bits/AbstractBitVectorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -20,12 +20,14 @@
 package it.unimi.dsi.bits;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
 import it.unimi.dsi.fastutil.Size64;
 import it.unimi.dsi.fastutil.booleans.BooleanBigArrayBigList;
+import it.unimi.dsi.fastutil.longs.LongSortedSet;
 
 public class AbstractBitVectorTest {
 
@@ -156,4 +158,16 @@ public class AbstractBitVectorTest {
 		assertEquals(1L << 32, v.size64());
 		assertEquals(1L << 31, ((Size64)v.asLongSet()).size64());
 	}
+
+	@Test(expected = UnsupportedOperationException.class)
+	public void testLongSetView() {
+		final LongArrayBitVector v = LongArrayBitVector.ofLength(1000);
+		assertTrue(v.asLongSet().add(1000));
+		assertEquals(1001, v.length());
+		v.set(1);
+		final LongSortedSet s = v.subVector(1, 500).asLongSet();
+		assertFalse(s.contains(500));
+		assertTrue(s.contains(0));
+		v.subVector(1, 500).asLongSet().add(500);
+	}
 }
diff --git a/test/it/unimi/dsi/bits/BitVectorTestCase.java b/test/it/unimi/dsi/bits/BitVectorTestCase.java
index c107349..f7e7546 100644
--- a/test/it/unimi/dsi/bits/BitVectorTestCase.java
+++ b/test/it/unimi/dsi/bits/BitVectorTestCase.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/BitVectorsTest.java b/test/it/unimi/dsi/bits/BitVectorsTest.java
index c7cd1ba..cbf0223 100644
--- a/test/it/unimi/dsi/bits/BitVectorsTest.java
+++ b/test/it/unimi/dsi/bits/BitVectorsTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/BooleanListBitVectorTest.java b/test/it/unimi/dsi/bits/BooleanListBitVectorTest.java
index fdcb8ea..c9c56a3 100644
--- a/test/it/unimi/dsi/bits/BooleanListBitVectorTest.java
+++ b/test/it/unimi/dsi/bits/BooleanListBitVectorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/ByteArrayTransformationStrategyTest.java b/test/it/unimi/dsi/bits/ByteArrayTransformationStrategyTest.java
index 5f718e3..af7fe3d 100644
--- a/test/it/unimi/dsi/bits/ByteArrayTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/ByteArrayTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -55,7 +55,6 @@ public class ByteArrayTransformationStrategyTest {
 	public void testGetLongPrefixFree() {
 		byte[] a = new byte[] { 0x55, (byte)0xFF };
 		assertEquals(24, TransformationStrategies.prefixFreeByteArray().toBitVector(a).length());
-		System.err.println(Long.toHexString(TransformationStrategies.prefixFreeByteArray().toBitVector(a).getLong(0, 24)));
 		assertEquals(0x00FFAAL, TransformationStrategies.prefixFreeByteArray().toBitVector(a).getLong(0, 24));
 
 		a = new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, 0 };
diff --git a/test/it/unimi/dsi/bits/FastTest.java b/test/it/unimi/dsi/bits/FastTest.java
index a799ce6..701e771 100644
--- a/test/it/unimi/dsi/bits/FastTest.java
+++ b/test/it/unimi/dsi/bits/FastTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/FixedLongTransformationStrategyTest.java b/test/it/unimi/dsi/bits/FixedLongTransformationStrategyTest.java
index 54db78c..d147b1e 100644
--- a/test/it/unimi/dsi/bits/FixedLongTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/FixedLongTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -19,6 +19,7 @@
 
 package it.unimi.dsi.bits;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ -30,18 +31,22 @@ public class FixedLongTransformationStrategyTest {
 	public void testGetBoolean() {
 		final TransformationStrategy<Long> fixedLong = TransformationStrategies.fixedLong();
 		BitVector p = fixedLong.toBitVector(Long.valueOf(0));
-		for(int i = Long.SIZE; i-- != 0;) assertFalse(p.getBoolean(i));
+		for (int i = Long.SIZE; i-- != 1;) assertFalse(p.getBoolean(i));
+
+		// Flipped bit
+		assertTrue(p.getBoolean(0));
 		p = fixedLong.toBitVector(Long.valueOf(0xDEADBEEFDEADF00DL));
-		for(int i = Long.SIZE; i-- != 0;) assertTrue(p.getBoolean(i) == ((0xDEADBEEFDEADF00DL & 1L << Long.SIZE - 1 - i) != 0));
+		for (int i = Long.SIZE; i-- != 0;) assertTrue(p.getBoolean(i) == (((0xDEADBEEFDEADF00DL ^ 1L << 63) & 1L << Long.SIZE - 1 - i) != 0));
 	}
 
 	@Test
 	public void testGetLong() {
 		final TransformationStrategy<Long> fixedLong = TransformationStrategies.fixedLong();
-		final BitVector p = fixedLong.toBitVector(Long.valueOf(Long.reverse(0xDEADBEEFDEADF00DL)));
+		final BitVector p = fixedLong.toBitVector(Long.valueOf(0xDEADBEEFDEADF00DL));
 		for(int from = Long.SIZE; from-- != 0;)
-			for(int to = Long.SIZE; from < to--;)
-				assertTrue(p.getLong(from, to) == LongArrayBitVector.wrap(new long[] { 0xDEADBEEFDEADF00DL }).getLong(from, to));
+			for (int to = Long.SIZE; from < to--;) 
+				assertEquals(LongArrayBitVector.wrap(new long[] {
+						Long.reverse(0xDEADBEEFDEADF00DL) ^ 1 }).getLong(from, to), p.getLong(from, to));
 	}
 
 }
diff --git a/test/it/unimi/dsi/bits/IsoTransformationStrategyTest.java b/test/it/unimi/dsi/bits/IsoTransformationStrategyTest.java
index b90a572..e1c23bd 100644
--- a/test/it/unimi/dsi/bits/IsoTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/IsoTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/LongArrayBitVectorTest.java b/test/it/unimi/dsi/bits/LongArrayBitVectorTest.java
index 1032e7d..ed5dbd3 100644
--- a/test/it/unimi/dsi/bits/LongArrayBitVectorTest.java
+++ b/test/it/unimi/dsi/bits/LongArrayBitVectorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/LongBigArrayBitVectorTest.java b/test/it/unimi/dsi/bits/LongBigArrayBitVectorTest.java
index 10c8352..319c556 100644
--- a/test/it/unimi/dsi/bits/LongBigArrayBitVectorTest.java
+++ b/test/it/unimi/dsi/bits/LongBigArrayBitVectorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/PrefixFreeTransformationStrategyTest.java b/test/it/unimi/dsi/bits/PrefixFreeTransformationStrategyTest.java
index ac6ca4a..0187e23 100644
--- a/test/it/unimi/dsi/bits/PrefixFreeTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/PrefixFreeTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/RawByteArrayTransformationStrategyTest.java b/test/it/unimi/dsi/bits/RawByteArrayTransformationStrategyTest.java
index 6f0db19..c8b22f9 100644
--- a/test/it/unimi/dsi/bits/RawByteArrayTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/RawByteArrayTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/RawFixedLongTransformationStrategyTest.java b/test/it/unimi/dsi/bits/RawFixedLongTransformationStrategyTest.java
index a50d60c..deebacf 100644
--- a/test/it/unimi/dsi/bits/RawFixedLongTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/RawFixedLongTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/RawISOTransformationStrategyTest.java b/test/it/unimi/dsi/bits/RawISOTransformationStrategyTest.java
index 241e170..a8cea76 100644
--- a/test/it/unimi/dsi/bits/RawISOTransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/RawISOTransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/RawUtf16TransformationStrategyTest.java b/test/it/unimi/dsi/bits/RawUtf16TransformationStrategyTest.java
index 2a58857..446fda1 100644
--- a/test/it/unimi/dsi/bits/RawUtf16TransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/RawUtf16TransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/RawUtf32TransformationStrategyTest.java b/test/it/unimi/dsi/bits/RawUtf32TransformationStrategyTest.java
index b1de369..87fa1de 100644
--- a/test/it/unimi/dsi/bits/RawUtf32TransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/RawUtf32TransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/Utf16TransformationStrategyTest.java b/test/it/unimi/dsi/bits/Utf16TransformationStrategyTest.java
index f184e9e..11a5fed 100644
--- a/test/it/unimi/dsi/bits/Utf16TransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/Utf16TransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/bits/Utf32TransformationStrategyTest.java b/test/it/unimi/dsi/bits/Utf32TransformationStrategyTest.java
index 8635bab..04ccee4 100644
--- a/test/it/unimi/dsi/bits/Utf32TransformationStrategyTest.java
+++ b/test/it/unimi/dsi/bits/Utf32TransformationStrategyTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/compression/CodecTestCase.java b/test/it/unimi/dsi/compression/CodecTestCase.java
index 8a16659..4a5c59b 100644
--- a/test/it/unimi/dsi/compression/CodecTestCase.java
+++ b/test/it/unimi/dsi/compression/CodecTestCase.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/compression/HuTuckerCodecTest.java b/test/it/unimi/dsi/compression/HuTuckerCodecTest.java
index c4ec251..cfd494b 100644
--- a/test/it/unimi/dsi/compression/HuTuckerCodecTest.java
+++ b/test/it/unimi/dsi/compression/HuTuckerCodecTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/compression/HuffmanCodecTest.java b/test/it/unimi/dsi/compression/HuffmanCodecTest.java
index 31fe10d..6354b9c 100644
--- a/test/it/unimi/dsi/compression/HuffmanCodecTest.java
+++ b/test/it/unimi/dsi/compression/HuffmanCodecTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2007-2021 Sebastiano Vigna
+ * Copyright (C) 2007-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/ByteBufferInputStreamTest.java b/test/it/unimi/dsi/io/ByteBufferInputStreamTest.java
index b49d734..7b57c54 100644
--- a/test/it/unimi/dsi/io/ByteBufferInputStreamTest.java
+++ b/test/it/unimi/dsi/io/ByteBufferInputStreamTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/ByteDiskQueueTest.java b/test/it/unimi/dsi/io/ByteDiskQueueTest.java
index 5b56610..378cc0f 100644
--- a/test/it/unimi/dsi/io/ByteDiskQueueTest.java
+++ b/test/it/unimi/dsi/io/ByteDiskQueueTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/DelimitedWordReaderTest.java b/test/it/unimi/dsi/io/DelimitedWordReaderTest.java
index 9c2f90b..edccdf6 100644
--- a/test/it/unimi/dsi/io/DelimitedWordReaderTest.java
+++ b/test/it/unimi/dsi/io/DelimitedWordReaderTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/FastBufferedReaderTest.java b/test/it/unimi/dsi/io/FastBufferedReaderTest.java
index ab0bf36..38e74d8 100644
--- a/test/it/unimi/dsi/io/FastBufferedReaderTest.java
+++ b/test/it/unimi/dsi/io/FastBufferedReaderTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/FileLinesByteArrayCollectionTest.java b/test/it/unimi/dsi/io/FileLinesByteArrayCollectionTest.java
index 4bb3c8b..860664f 100644
--- a/test/it/unimi/dsi/io/FileLinesByteArrayCollectionTest.java
+++ b/test/it/unimi/dsi/io/FileLinesByteArrayCollectionTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2016-2021 Sebastiano Vigna
+ * Copyright (C) 2016-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/FileLinesMutableStringIterableTest.java b/test/it/unimi/dsi/io/FileLinesMutableStringIterableTest.java
index 5fd3802..13b551a 100644
--- a/test/it/unimi/dsi/io/FileLinesMutableStringIterableTest.java
+++ b/test/it/unimi/dsi/io/FileLinesMutableStringIterableTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2020-2021 Sebastiano Vigna
+ * Copyright (C) 2020-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/InputBitStreamTest.java b/test/it/unimi/dsi/io/InputBitStreamTest.java
index c6f1806..ebb5b67 100644
--- a/test/it/unimi/dsi/io/InputBitStreamTest.java
+++ b/test/it/unimi/dsi/io/InputBitStreamTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/OfflineIterableTest.java b/test/it/unimi/dsi/io/OfflineIterableTest.java
index 0a5bf63..40f9797 100644
--- a/test/it/unimi/dsi/io/OfflineIterableTest.java
+++ b/test/it/unimi/dsi/io/OfflineIterableTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/OutputBitStreamTest.java b/test/it/unimi/dsi/io/OutputBitStreamTest.java
index b12844d..18d60d5 100644
--- a/test/it/unimi/dsi/io/OutputBitStreamTest.java
+++ b/test/it/unimi/dsi/io/OutputBitStreamTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/io/SegmentedInputStreamTest.java b/test/it/unimi/dsi/io/SegmentedInputStreamTest.java
index 2f7fd23..b81409e 100644
--- a/test/it/unimi/dsi/io/SegmentedInputStreamTest.java
+++ b/test/it/unimi/dsi/io/SegmentedInputStreamTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/lang/EnumParserTest.java b/test/it/unimi/dsi/lang/EnumParserTest.java
index 176bf76..06e0d83 100644
--- a/test/it/unimi/dsi/lang/EnumParserTest.java
+++ b/test/it/unimi/dsi/lang/EnumParserTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/lang/MutableStringTest.java b/test/it/unimi/dsi/lang/MutableStringTest.java
index aae437f..800a393 100644
--- a/test/it/unimi/dsi/lang/MutableStringTest.java
+++ b/test/it/unimi/dsi/lang/MutableStringTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/lang/ObjectParserTest.java b/test/it/unimi/dsi/lang/ObjectParserTest.java
index c685cb9..88aca13 100644
--- a/test/it/unimi/dsi/lang/ObjectParserTest.java
+++ b/test/it/unimi/dsi/lang/ObjectParserTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/lang/TwoStrings.java b/test/it/unimi/dsi/lang/TwoStrings.java
index c4326d2..a05f1dc 100644
--- a/test/it/unimi/dsi/lang/TwoStrings.java
+++ b/test/it/unimi/dsi/lang/TwoStrings.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/parser/BulletParserTest.java b/test/it/unimi/dsi/parser/BulletParserTest.java
index 0b83a22..21220b8 100644
--- a/test/it/unimi/dsi/parser/BulletParserTest.java
+++ b/test/it/unimi/dsi/parser/BulletParserTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/parser/callback/BulletParserCallbackContentHandler.java b/test/it/unimi/dsi/parser/callback/BulletParserCallbackContentHandler.java
index aad401c..47c6aab 100644
--- a/test/it/unimi/dsi/parser/callback/BulletParserCallbackContentHandler.java
+++ b/test/it/unimi/dsi/parser/callback/BulletParserCallbackContentHandler.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/parser/callback/LinkExtractorTest.java b/test/it/unimi/dsi/parser/callback/LinkExtractorTest.java
index 29830ed..51223c8 100644
--- a/test/it/unimi/dsi/parser/callback/LinkExtractorTest.java
+++ b/test/it/unimi/dsi/parser/callback/LinkExtractorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/parser/callback/TextExtractorTest.java b/test/it/unimi/dsi/parser/callback/TextExtractorTest.java
index 1a1b957..99a328b 100644
--- a/test/it/unimi/dsi/parser/callback/TextExtractorTest.java
+++ b/test/it/unimi/dsi/parser/callback/TextExtractorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/stat/JackknifeTest.java b/test/it/unimi/dsi/stat/JackknifeTest.java
index d762418..65f72bf 100644
--- a/test/it/unimi/dsi/stat/JackknifeTest.java
+++ b/test/it/unimi/dsi/stat/JackknifeTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/stat/SummaryStatsTest.java b/test/it/unimi/dsi/stat/SummaryStatsTest.java
index 0f9243e..a5b6828 100644
--- a/test/it/unimi/dsi/stat/SummaryStatsTest.java
+++ b/test/it/unimi/dsi/stat/SummaryStatsTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/test/XorShiftTest.java b/test/it/unimi/dsi/test/XorShiftTest.java
index 6cb53a2..d99ab10 100644
--- a/test/it/unimi/dsi/test/XorShiftTest.java
+++ b/test/it/unimi/dsi/test/XorShiftTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/BloomFilterTest.java b/test/it/unimi/dsi/util/BloomFilterTest.java
index c7b0d15..cbb3a3d 100644
--- a/test/it/unimi/dsi/util/BloomFilterTest.java
+++ b/test/it/unimi/dsi/util/BloomFilterTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/ByteBufferLongBigListTest.java b/test/it/unimi/dsi/util/ByteBufferLongBigListTest.java
index 4d9b5e7..ab3d191 100644
--- a/test/it/unimi/dsi/util/ByteBufferLongBigListTest.java
+++ b/test/it/unimi/dsi/util/ByteBufferLongBigListTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/CircularCharArrayBufferTest.java b/test/it/unimi/dsi/util/CircularCharArrayBufferTest.java
index 1b6246a..2eccc1e 100644
--- a/test/it/unimi/dsi/util/CircularCharArrayBufferTest.java
+++ b/test/it/unimi/dsi/util/CircularCharArrayBufferTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/FrontCodedStringListTest.java b/test/it/unimi/dsi/util/FrontCodedStringListTest.java
index d421dc3..ff310e8 100644
--- a/test/it/unimi/dsi/util/FrontCodedStringListTest.java
+++ b/test/it/unimi/dsi/util/FrontCodedStringListTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -32,7 +32,7 @@ import it.unimi.dsi.lang.MutableString;
 public class FrontCodedStringListTest {
 
 	@Test
-	public void testLargeSet() {
+	public void test() {
 		final List<String> c = Arrays.asList(TernaryIntervalSearchTreeTest.WORDS.clone());
 		final MutableString s = new MutableString();
 		for(int p = 0; p < 2; p++) {
diff --git a/test/it/unimi/dsi/util/HyperLogLogCounterArrayTest.java b/test/it/unimi/dsi/util/HyperLogLogCounterArrayTest.java
index 1ce94e9..7436d0a 100644
--- a/test/it/unimi/dsi/util/HyperLogLogCounterArrayTest.java
+++ b/test/it/unimi/dsi/util/HyperLogLogCounterArrayTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Paolo Boldi and Sebastiano Vigna
+ * Copyright (C) 2010-2022 Paolo Boldi and Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -21,11 +21,8 @@ package it.unimi.dsi.util;
 
 import static org.junit.Assert.assertTrue;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
-import it.unimi.dsi.logging.ProgressLogger;
-
 public class HyperLogLogCounterArrayTest {
 
 	@Test
@@ -84,101 +81,4 @@ public class HyperLogLogCounterArrayTest {
 				assertTrue(correct1 + " < " + 9, correct1 >= 9);
 			}
 	}
-
-	@Ignore("too slow")
-	@Test
-	public void testLarge() {
-		final int numTrials = 10;
-
-		for(final long size: new long[] { 1000000000, 4000000000L })
-			for(final int log2m: new int[] { 6, 8, 12 }) {
-				final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
-				int correct = 0;
-				for (int trial = 0; trial < numTrials; trial++) {
-					final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
-					final long incr = (1L << 60) / size;
-					long x = Long.MIN_VALUE;
-					for(long i = size; i-- != 0;) {
-						a.add(0, x);
-						x += incr;
-					}
-
-					//System.err.println("Trial " + trial + ", size " + size + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
-					if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
-				}
-
-				//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
-				assertTrue(correct + " < " + 9, correct >= 9);
-			}
-	}
-
-
-	@Ignore("too slow")
-	@Test
-	public void testExtreme() {
-		final int numTrials = 20, mustBeCorrect = 18;
-		final ProgressLogger pl = new ProgressLogger();
-
-		for(final int log2m: new int[] { 6, 8, 12 }) {
-			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
-			int correct = 0;
-			final long size = 3L * 1024 * 1024 * 1024;
-			for (int trial = 0; trial < numTrials; trial++) {
-				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
-				pl.start();
-				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 4 != 0) a.add(0, i);
-				pl.stop();
-				pl.count = size;
-				//System.err.println(pl);
-				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
-				if (Math.abs(size - a.count(0)) < 2 * rsd * size) correct++;
-			}
-
-			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
-			assertTrue(correct + " < " + mustBeCorrect, correct >= mustBeCorrect);
-		}
-
-		for(final int log2m: new int[] { 6, 8, 12 }) {
-			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
-			int correct = 0;
-			final long size = 7L * 512 * 1024 * 1024;
-			for (int trial = 0; trial < numTrials; trial++) {
-				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
-				pl.start();
-				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 8 != 0) a.add(0, i);
-				pl.stop();
-				pl.count = size;
-				//System.err.println(pl);
-				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
-				if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
-			}
-
-			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
-			assertTrue(correct + " < " + mustBeCorrect, mustBeCorrect >= 9);
-		}
-
-		for(final int log2m: new int[] { 6, 8, 12 }) {
-			final double rsd = HyperLogLogCounterArray.relativeStandardDeviation(log2m);
-			int correct = 0;
-			final long size = 8L * 1024 * 1024 * 1024;
-			for (int trial = 0; trial < numTrials; trial++) {
-				final HyperLogLogCounterArray a = new HyperLogLogCounterArray(1, size, log2m, trial);
-				pl.start();
-				for(int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++) if (i % 8 != 0) a.add(0, i);
-				pl.stop();
-				pl.count = size;
-				//System.err.println(pl);
-				//System.err.println("Trial " + trial + ", error: " + (size - a.count(0)) / size + " " + (Math.abs(size - a.count(0)) < 2 * rsd * size ? "(+)" : "(-)"));
-				if (Math.abs(size - a.count(0)) / size < 2 * rsd) correct++;
-			}
-
-			//System.err.println("Correct trials for size " + size + ", rsd " + rsd + ": " + correct);
-			assertTrue(correct + " < " + mustBeCorrect, mustBeCorrect >= 9);
-		}
-	}
-
-	public static void main(final String arg[]) {
-		new HyperLogLogCounterArrayTest().testExtreme();
-	}
-
 }
diff --git a/test/it/unimi/dsi/util/ImmutableBinaryTrieTest.java b/test/it/unimi/dsi/util/ImmutableBinaryTrieTest.java
index 26e78ec..d97d49f 100644
--- a/test/it/unimi/dsi/util/ImmutableBinaryTrieTest.java
+++ b/test/it/unimi/dsi/util/ImmutableBinaryTrieTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/ImmutableExternalPrefixMapTest.java b/test/it/unimi/dsi/util/ImmutableExternalPrefixMapTest.java
index 6d033ff..514febe 100644
--- a/test/it/unimi/dsi/util/ImmutableExternalPrefixMapTest.java
+++ b/test/it/unimi/dsi/util/ImmutableExternalPrefixMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -37,7 +37,7 @@ import it.unimi.dsi.fastutil.objects.ObjectSets;
 
 public class ImmutableExternalPrefixMapTest {
 
-	public void testLargeSet(final int blockSize) throws IOException {
+	public void test(final int blockSize) throws IOException {
 		final Collection<String> c = Arrays.asList(TernaryIntervalSearchTreeTest.WORDS);
 		TernaryIntervalSearchTree t = new TernaryIntervalSearchTree(c);
 		ImmutableExternalPrefixMap d = new ImmutableExternalPrefixMap(c, blockSize);
@@ -81,28 +81,28 @@ public class ImmutableExternalPrefixMapTest {
 	}
 
 	@Test
-	public void testLargeSet64() throws IOException {
-		testLargeSet(64);
+	public void test64() throws IOException {
+		test(64);
 	}
 
 	@Test
-	public void testLargeSet128() throws IOException {
-		testLargeSet(128);
+	public void test128() throws IOException {
+		test(128);
 	}
 
 	@Test
-	public void testLargeSet256() throws IOException {
-		testLargeSet(256);
+	public void test256() throws IOException {
+		test(256);
 	}
 
 	@Test
-	public void testLargeSet1024() throws IOException {
-		testLargeSet(1024);
+	public void test1024() throws IOException {
+		test(1024);
 	}
 
 	@Test
-	public void testLargeSet16384() throws IOException {
-		testLargeSet(16384);
+	public void test16384() throws IOException {
+		test(16384);
 	}
 
 	@Test
diff --git a/test/it/unimi/dsi/util/IntervalTest.java b/test/it/unimi/dsi/util/IntervalTest.java
index 6cea303..2df4676 100644
--- a/test/it/unimi/dsi/util/IntervalTest.java
+++ b/test/it/unimi/dsi/util/IntervalTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/KahanSummationTest.java b/test/it/unimi/dsi/util/KahanSummationTest.java
index 24a7f9d..db84086 100644
--- a/test/it/unimi/dsi/util/KahanSummationTest.java
+++ b/test/it/unimi/dsi/util/KahanSummationTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2011-2021 Sebastiano Vigna
+ * Copyright (C) 2011-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/LineIteratorTest.java b/test/it/unimi/dsi/util/LineIteratorTest.java
index 478abdd..407ef43 100644
--- a/test/it/unimi/dsi/util/LineIteratorTest.java
+++ b/test/it/unimi/dsi/util/LineIteratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/LiterallySignedStringMapTest.java b/test/it/unimi/dsi/util/LiterallySignedStringMapTest.java
index 9f83c5c..430877d 100644
--- a/test/it/unimi/dsi/util/LiterallySignedStringMapTest.java
+++ b/test/it/unimi/dsi/util/LiterallySignedStringMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/LongIntervalTest.java b/test/it/unimi/dsi/util/LongIntervalTest.java
index 1d655d6..e1cc85c 100644
--- a/test/it/unimi/dsi/util/LongIntervalTest.java
+++ b/test/it/unimi/dsi/util/LongIntervalTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/SemiExternalGammaListTest.java b/test/it/unimi/dsi/util/SemiExternalGammaListTest.java
index 8c6cd0b..beadaf4 100644
--- a/test/it/unimi/dsi/util/SemiExternalGammaListTest.java
+++ b/test/it/unimi/dsi/util/SemiExternalGammaListTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/ShiftAddXorSignedStringMapTest.java b/test/it/unimi/dsi/util/ShiftAddXorSignedStringMapTest.java
index 3126a6e..6ec4d81 100644
--- a/test/it/unimi/dsi/util/ShiftAddXorSignedStringMapTest.java
+++ b/test/it/unimi/dsi/util/ShiftAddXorSignedStringMapTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/SplitMix64RandomGeneratorTest.java b/test/it/unimi/dsi/util/SplitMix64RandomGeneratorTest.java
index f5173c1..74bf103 100644
--- a/test/it/unimi/dsi/util/SplitMix64RandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/SplitMix64RandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2015-2021 Sebastiano Vigna
+ * Copyright (C) 2015-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/SplitMix64RandomTest.java b/test/it/unimi/dsi/util/SplitMix64RandomTest.java
index 94111a0..162ecb1 100644
--- a/test/it/unimi/dsi/util/SplitMix64RandomTest.java
+++ b/test/it/unimi/dsi/util/SplitMix64RandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2015-2021 Sebastiano Vigna
+ * Copyright (C) 2015-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/TernaryIntervalSearchTreeTest.java b/test/it/unimi/dsi/util/TernaryIntervalSearchTreeTest.java
index 8fb31b5..071a743 100644
--- a/test/it/unimi/dsi/util/TernaryIntervalSearchTreeTest.java
+++ b/test/it/unimi/dsi/util/TernaryIntervalSearchTreeTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
@@ -338,7 +338,7 @@ public class TernaryIntervalSearchTreeTest {
 	}
 
 	@Test
-	public void testLargeSet() {
+	public void test() {
 		final List<String> c = new ObjectArrayList<>(WORDS);
 		Collections.shuffle(c);
 		TernaryIntervalSearchTree t = new TernaryIntervalSearchTree(c);
diff --git a/test/it/unimi/dsi/util/TextPatternTest.java b/test/it/unimi/dsi/util/TextPatternTest.java
index 64f9a55..31d2a40 100644
--- a/test/it/unimi/dsi/util/TextPatternTest.java
+++ b/test/it/unimi/dsi/util/TextPatternTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2010-2021 Sebastiano Vigna
+ * Copyright (C) 2010-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGeneratorTest.java
index 3aa9376..ad73958 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomTest.java b/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomTest.java
index ab55d5f..fc3c7f2 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128PlusPlusRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomGeneratorTest.java
index f166551..2d3df2d 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomTest.java b/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomTest.java
index 5e17d54..e8349f1 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128PlusRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGeneratorTest.java
index 60d3fb3..46421fc 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomTest.java b/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomTest.java
index b6eb215..aae586d 100644
--- a/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomTest.java
+++ b/test/it/unimi/dsi/util/XoRoShiRo128StarStarRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGeneratorTest.java
index 510c3e0..536217a 100644
--- a/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomTest.java b/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomTest.java
index 174079e..4570df5 100644
--- a/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256PlusPlusRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256PlusRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoShiRo256PlusRandomGeneratorTest.java
index 543a1df..ca5f547 100644
--- a/test/it/unimi/dsi/util/XoShiRo256PlusRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256PlusRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256PlusRandomTest.java b/test/it/unimi/dsi/util/XoShiRo256PlusRandomTest.java
index 575c343..adf9137 100644
--- a/test/it/unimi/dsi/util/XoShiRo256PlusRandomTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256PlusRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256StarStarRandomGeneratorTest.java b/test/it/unimi/dsi/util/XoShiRo256StarStarRandomGeneratorTest.java
index 32b26c0..fc6f376 100644
--- a/test/it/unimi/dsi/util/XoShiRo256StarStarRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256StarStarRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XoShiRo256StarStarRandomTest.java b/test/it/unimi/dsi/util/XoShiRo256StarStarRandomTest.java
index b3a22b0..3b2087e 100644
--- a/test/it/unimi/dsi/util/XoShiRo256StarStarRandomTest.java
+++ b/test/it/unimi/dsi/util/XoShiRo256StarStarRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift1024StarPhiRandomGeneratorTest.java b/test/it/unimi/dsi/util/XorShift1024StarPhiRandomGeneratorTest.java
index 149c767..24aabc2 100644
--- a/test/it/unimi/dsi/util/XorShift1024StarPhiRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XorShift1024StarPhiRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift1024StarPhiRandomTest.java b/test/it/unimi/dsi/util/XorShift1024StarPhiRandomTest.java
index b078eef..7b54131 100644
--- a/test/it/unimi/dsi/util/XorShift1024StarPhiRandomTest.java
+++ b/test/it/unimi/dsi/util/XorShift1024StarPhiRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift1024StarRandomGeneratorTest.java b/test/it/unimi/dsi/util/XorShift1024StarRandomGeneratorTest.java
index 7eb07b8..975594c 100644
--- a/test/it/unimi/dsi/util/XorShift1024StarRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XorShift1024StarRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift1024StarRandomTest.java b/test/it/unimi/dsi/util/XorShift1024StarRandomTest.java
index 2885ba8..9c05c9c 100644
--- a/test/it/unimi/dsi/util/XorShift1024StarRandomTest.java
+++ b/test/it/unimi/dsi/util/XorShift1024StarRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2013-2021 Sebastiano Vigna
+ * Copyright (C) 2013-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift128PlusRandomGeneratorTest.java b/test/it/unimi/dsi/util/XorShift128PlusRandomGeneratorTest.java
index d4c7fd3..9d1b8d5 100644
--- a/test/it/unimi/dsi/util/XorShift128PlusRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XorShift128PlusRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift128PlusRandomTest.java b/test/it/unimi/dsi/util/XorShift128PlusRandomTest.java
index 9442b0f..2f7547c 100644
--- a/test/it/unimi/dsi/util/XorShift128PlusRandomTest.java
+++ b/test/it/unimi/dsi/util/XorShift128PlusRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2014-2021 Sebastiano Vigna
+ * Copyright (C) 2014-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift64StarRandomGeneratorTest.java b/test/it/unimi/dsi/util/XorShift64StarRandomGeneratorTest.java
index a855a46..d590def 100644
--- a/test/it/unimi/dsi/util/XorShift64StarRandomGeneratorTest.java
+++ b/test/it/unimi/dsi/util/XorShift64StarRandomGeneratorTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/XorShift64StarRandomTest.java b/test/it/unimi/dsi/util/XorShift64StarRandomTest.java
index 7527dbf..7d17049 100644
--- a/test/it/unimi/dsi/util/XorShift64StarRandomTest.java
+++ b/test/it/unimi/dsi/util/XorShift64StarRandomTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2012-2021 Sebastiano Vigna
+ * Copyright (C) 2012-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,
diff --git a/test/it/unimi/dsi/util/concurrent/ReorderingBlockingQueueTest.java b/test/it/unimi/dsi/util/concurrent/ReorderingBlockingQueueTest.java
index 1f4eb90..0c0349a 100644
--- a/test/it/unimi/dsi/util/concurrent/ReorderingBlockingQueueTest.java
+++ b/test/it/unimi/dsi/util/concurrent/ReorderingBlockingQueueTest.java
@@ -1,7 +1,7 @@
 /*
  * DSI utilities
  *
- * Copyright (C) 2017-2021 Sebastiano Vigna
+ * Copyright (C) 2017-2022 Sebastiano Vigna
  *
  * This program and the accompanying materials are made available under the
  * terms of the GNU Lesser General Public License v2.1 or later,