diff --git a/doc/modules/ROOT/pages/benchmarks.adoc b/doc/modules/ROOT/pages/benchmarks.adoc
index a19a5270..8378147c 100644
--- a/doc/modules/ROOT/pages/benchmarks.adoc
+++ b/doc/modules/ROOT/pages/benchmarks.adoc
@@ -1,6 +1,5 @@
 [#benchmarks]
 :idprefix: benchmarks_
-:imagesdir: ../diagrams
 
 = Benchmarks
 
@@ -24,12 +23,12 @@ The unsuccessful lookup benchmarks use `n` randomly generated integers but using
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/gcc/running insertion.xlsx.practice.png[width=250,link=../diagrams/benchmarks-set/gcc/running insertion.xlsx.practice.png,window=_blank]
-|image::benchmarks-set/gcc/running%20insertion.xlsx.practice non-unique.png[width=250,link=../diagrams/benchmarks-set/gcc/running%20insertion.xlsx.practice non-unique.png,window=_blank]
-|image::benchmarks-set/gcc/running%20insertion.xlsx.practice non-unique 5.png[width=250,link=../diagrams/benchmarks-set/gcc/running%20insertion.xlsx.practice non-unique 5.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice.png[width=250,link=_images/benchmarks-set/gcc/running insertion.xlsx.practice.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice non-unique.png[width=250,link=_images/benchmarks-set/gcc/running insertion.xlsx.practice non-unique.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice non-unique 5.png[width=250,link=_images/benchmarks-set/gcc/running insertion.xlsx.practice non-unique 5.png,window=_blank]
 
-h|non-duplicate elements 
-h|duplicate elements 
+h|non-duplicate elements
+h|duplicate elements
 h|duplicate elements, +
 max load factor 5
 |===
@@ -38,14 +37,14 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/gcc/running%20insertion.xlsx.practice norehash.png[width=250,link=../diagrams/benchmarks-set/gcc/running%20insertion.xlsx.practice norehash.png,window=_blank]
-|image::benchmarks-set/gcc/running%20insertion.xlsx.practice norehash non-unique.png[width=250,link=../diagrams/benchmarks-set/gcc/running%20insertion.xlsx.practice norehash non-unique.png,window=_blank]
-|image::benchmarks-set/gcc/running%20insertion.xlsx.practice norehash non-unique 5.png[width=250,link=../diagrams/benchmarks-set/gcc/running%20insertion.xlsx.practice norehash non-unique 5.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice norehash.png[width=250,link= _images/benchmarks-set/gcc/running insertion.xlsx.practice norehash.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice norehash non-unique.png[width=250,link= _images/benchmarks-set/gcc/running insertion.xlsx.practice norehash non-unique.png,window=_blank]
+|image::benchmarks-set/gcc/running insertion.xlsx.practice norehash non-unique 5.png[width=250,link= _images/benchmarks-set/gcc/running insertion.xlsx.practice norehash non-unique 5.png,window=_blank]
 
 h|non-duplicate elements, +
 prior `reserve`
 h|duplicate elements, +
-prior `reserve` 
+prior `reserve`
 h|duplicate elements, +
 max load factor 5, +
 prior `reserve`
@@ -58,21 +57,21 @@ prior `reserve`
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/gcc/scattered%20erasure.xlsx.practice.png[width=250,link=../diagrams/benchmarks-set/gcc/scattered%20erasure.xlsx.practice.png,window=_blank]
-|image::benchmarks-set/gcc/scattered%20erasure.xlsx.practice non-unique.png[width=250,link=../diagrams/benchmarks-set/gcc/scattered%20erasure.xlsx.practice non-unique.png,window=_blank]
-|image::benchmarks-set/gcc/scattered%20erasure.xlsx.practice non-unique 5.png[width=250,link=../diagrams/benchmarks-set/gcc/scattered%20erasure.xlsx.practice non-unique 5.png,window=_blank]
+|image::benchmarks-set/gcc/scattered erasure.xlsx.practice.png[width=250,link= _images/benchmarks-set/gcc/scattered erasure.xlsx.practice.png,window=_blank]
+|image::benchmarks-set/gcc/scattered erasure.xlsx.practice non-unique.png[width=250,link= _images/benchmarks-set/gcc/scattered erasure.xlsx.practice non-unique.png,window=_blank]
+|image::benchmarks-set/gcc/scattered erasure.xlsx.practice non-unique 5.png[width=250,link= _images/benchmarks-set/gcc/scattered erasure.xlsx.practice non-unique 5.png,window=_blank]
 
-h|non-duplicate elements 
-h|duplicate elements 
+h|non-duplicate elements
+h|duplicate elements
 h|duplicate elements, +
 max load factor 5
 
 |
-|image::benchmarks-set/gcc/scattered%20erasure%20by%20key.xlsx.practice non-unique.png[width=250,link=../diagrams/benchmarks-set/gcc/scattered%20erasure%20by%20key.xlsx.practice non-unique.png,window=_blank]
-|image::benchmarks-set/gcc/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png[width=250,link=../diagrams/benchmarks-set/gcc/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png,window=_blank]
+|image::benchmarks-set/gcc/scattered erasure by key.xlsx.practice non-unique.png[width=250,link= _images/benchmarks-set/gcc/scattered erasure by key.xlsx.practice non-unique.png,window=_blank]
+|image::benchmarks-set/gcc/scattered erasure by key.xlsx.practice non-unique 5.png[width=250,link= _images/benchmarks-set/gcc/scattered erasure by key.xlsx.practice non-unique 5.png,window=_blank]
 
 |
-h|by key, duplicate elements 
+h|by key, duplicate elements
 h|by key, duplicate elements, +
 max load factor 5
 
@@ -84,9 +83,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20successful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/gcc/scattered successful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered successful looukp.xlsx.practice.png]
+|image::benchmarks-set/gcc/scattered successful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered successful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/gcc/scattered successful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered successful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -101,9 +100,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/gcc/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice.png]
+|image::benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/gcc/scattered unsuccessful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -120,9 +119,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice.png[width=250, window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice.png]
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice non-unique.png[width=250, window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice non-unique.png]
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice non-unique 5.png[width=250, window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice.png[width=250, window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice non-unique.png[width=250, window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice non-unique.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice non-unique 5.png[width=250, window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -135,9 +134,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash.png]
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash non-unique.png]
-|image::benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/running%20insertion.xlsx.practice norehash non-unique 5.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash non-unique.png]
+|image::benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/running insertion.xlsx.practice norehash non-unique 5.png]
 
 h|non-duplicate elements, +
 prior `reserve`
@@ -155,9 +154,9 @@ prior `reserve`
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice.png]
-|image::benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice non-unique.png]
-|image::benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20erasure.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice.png]
+|image::benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice non-unique.png]
+|image::benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered erasure.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -165,11 +164,11 @@ h|duplicate elements, +
 max load factor 5
 
 |
-|image::benchmarks-set/clang_libcpp/scattered%20erasure%20by%20key.xlsx.practice non-unique.png[width=250,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20erasure%20by%20key.xlsx.practice non-unique.png,window=_blank]
-|image::benchmarks-set/clang_libcpp/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png[width=250,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png,window=_blank]
+|image::benchmarks-set/clang_libcpp/scattered erasure by key.xlsx.practice non-unique.png[width=250,link= _images/benchmarks-set/clang_libcpp/scattered erasure by key.xlsx.practice non-unique.png,window=_blank]
+|image::benchmarks-set/clang_libcpp/scattered erasure by key.xlsx.practice non-unique 5.png[width=250,link= _images/benchmarks-set/clang_libcpp/scattered erasure by key.xlsx.practice non-unique 5.png,window=_blank]
 
 |
-h|by key, duplicate elements 
+h|by key, duplicate elements
 h|by key, duplicate elements, +
 max load factor 5
 
@@ -181,9 +180,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20successful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice.png]
+|image::benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered successful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -198,9 +197,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/clang_libcpp/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice.png]
+|image::benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/clang_libcpp/scattered unsuccessful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -217,9 +216,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice.png]
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice non-unique.png]
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice non-unique.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -232,9 +231,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice norehash.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice norehash.png]
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice norehash non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice norehash non-unique.png]
-|image::benchmarks-set/vs/running%20insertion.xlsx.practice norehash non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/running%20insertion.xlsx.practice norehash non-unique 5.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice norehash.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice norehash.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice norehash non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice norehash non-unique.png]
+|image::benchmarks-set/vs/running insertion.xlsx.practice norehash non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/vs/running insertion.xlsx.practice norehash non-unique 5.png]
 
 h|non-duplicate elements, +
 prior `reserve`
@@ -252,9 +251,9 @@ prior `reserve`
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/vs/scattered%20erasure.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20erasure.xlsx.practice.png]
-|image::benchmarks-set/vs/scattered%20erasure.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20erasure.xlsx.practice non-unique.png]
-|image::benchmarks-set/vs/scattered%20erasure.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20erasure.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/vs/scattered erasure.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered erasure.xlsx.practice.png]
+|image::benchmarks-set/vs/scattered erasure.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered erasure.xlsx.practice non-unique.png]
+|image::benchmarks-set/vs/scattered erasure.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered erasure.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -262,11 +261,11 @@ h|duplicate elements, +
 max load factor 5
 
 |
-|image::benchmarks-set/vs/scattered%20erasure%20by%20key.xlsx.practice non-unique.png[width=250,link=../diagrams/benchmarks-set/vs/scattered%20erasure%20by%20key.xlsx.practice non-unique.png,window=_blank]
-|image::benchmarks-set/vs/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png[width=250,link=../diagrams/benchmarks-set/vs/scattered%20erasure%20by%20key.xlsx.practice non-unique 5.png,window=_blank]
+|image::benchmarks-set/vs/scattered erasure by key.xlsx.practice non-unique.png[width=250,link= _images/benchmarks-set/vs/scattered erasure by key.xlsx.practice non-unique.png,window=_blank]
+|image::benchmarks-set/vs/scattered erasure by key.xlsx.practice non-unique 5.png[width=250,link= _images/benchmarks-set/vs/scattered erasure by key.xlsx.practice non-unique 5.png,window=_blank]
 
 |
-h|by key, duplicate elements 
+h|by key, duplicate elements
 h|by key, duplicate elements, +
 max load factor 5
 
@@ -278,9 +277,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20successful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/vs/scattered successful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered successful looukp.xlsx.practice.png]
+|image::benchmarks-set/vs/scattered successful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered successful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/vs/scattered successful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered successful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -295,9 +294,9 @@ max load factor 5
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice.png]
-|image::benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice non-unique.png]
-|image::benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link=../diagrams/benchmarks-set/vs/scattered%20unsuccessful%20looukp.xlsx.practice non-unique 5.png]
+|image::benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice.png]
+|image::benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice non-unique.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice non-unique.png]
+|image::benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice non-unique 5.png[width=250,window=_blank,link= _images/benchmarks-set/vs/scattered unsuccessful looukp.xlsx.practice non-unique 5.png]
 
 h|non-duplicate elements
 h|duplicate elements
@@ -333,10 +332,10 @@ The unsuccessful lookup benchmarks use `n` randomly generated integers but using
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/gcc-x64/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x64/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x64/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x64/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x64/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x64/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x64/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x64/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x64/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x64/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x64/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x64/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x64/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x64/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -352,10 +351,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/clang-x64/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x64/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x64/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x64/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x64/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x64/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x64/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x64/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x64/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x64/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x64/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x64/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x64/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x64/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -371,10 +370,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/vs-x64/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x64/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x64/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x64/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x64/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x64/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x64/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x64/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x64/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x64/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x64/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x64/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x64/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x64/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x64/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -390,10 +389,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/clang-arm64/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-arm64/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-arm64/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-arm64/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-arm64/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-arm64/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-arm64/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-arm64/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-arm64/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-arm64/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-arm64/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-arm64/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-arm64/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-arm64/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-arm64/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-arm64/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -409,10 +408,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/gcc-x86/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x86/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x86/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x86/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x86/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x86/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/gcc-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/gcc-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x86/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x86/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x86/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x86/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x86/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x86/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/gcc-x86/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/gcc-x86/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -428,10 +427,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/clang-x86/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x86/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x86/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x86/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x86/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x86/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/clang-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/clang-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x86/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x86/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x86/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x86/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x86/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x86/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/clang-x86/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/clang-x86/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -447,10 +446,10 @@ h|unsuccessful lookup
 [cols="4*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-flat_map/vs-x86/Running%20insertion.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x86/Running%20insertion.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x86/Running%20erasure.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x86/Running%20erasure.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x86/Scattered%20successful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x86/Scattered%20successful%20looukp.xlsx.plot.png]
-|image::benchmarks-flat_map/vs-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png[width=250,window=_blank,link=../diagrams/benchmarks-flat_map/vs-x86/Scattered%20unsuccessful%20looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x86/Running insertion.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x86/Running insertion.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x86/Running erasure.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x86/Running erasure.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x86/Scattered successful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x86/Scattered successful looukp.xlsx.plot.png]
+|image::benchmarks-flat_map/vs-x86/Scattered unsuccessful looukp.xlsx.plot.png[width=250,window=_blank,link= _images/benchmarks-flat_map/vs-x86/Scattered unsuccessful looukp.xlsx.plot.png]
 
 h|running insertion
 h|running erasure
@@ -476,9 +475,9 @@ operations follow a https://en.wikipedia.org/wiki/Zipf%27s_law#Formal_definition
 with different _skew_ parameters: the higher the skew, the more concentrated are the keys in the lower values
 of the covered range.
 
-`boost::concurrent_flat_map` and `boost::concurrent_node_map` are exercised using both regular and xref:#concurrent_bulk_visitation[bulk visitation]:
+`boost::concurrent_flat_map` and `boost::concurrent_node_map` are exercised using both regular and xref:concurrent.adoc#concurrent_bulk_visitation[bulk visitation]:
 in the latter case, lookup keys are buffered in a local array and then processed at
-once each time the buffer reaches xref:#concurrent_flat_map_constants[`bulk_visit_size`].
+once each time the buffer reaches `xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_constants[bulk_visit_size]`.
 
 === GCC 12, x64
 
@@ -487,9 +486,9 @@ once each time the buffer reaches xref:#concurrent_flat_map_constants[`bulk_visi
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -503,9 +502,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x64/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x64/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -522,9 +521,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -538,9 +537,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x64/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x64/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -557,9 +556,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -573,9 +572,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x64/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x64/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -592,9 +591,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -608,9 +607,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-arm64/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-arm64/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -627,9 +626,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -643,9 +642,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/gcc-x86/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/gcc-x86/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -662,9 +661,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -678,9 +677,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/clang-x86/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/clang-x86/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
@@ -697,9 +696,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.01.png]
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.5.png]
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.500k%2C%200.99.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.01.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.5.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.500k, 0.99.png]
 
 h|500k updates, 4.5M lookups +
 skew=0.01
@@ -713,9 +712,9 @@ skew=0.99
 [cols="3*^.^a", frame=all, grid=all]
 |===
 
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.01.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.01.png]
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.5.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.5.png]
-|image::benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.99.png[width=250,window=_blank,link=../diagrams/benchmarks-concurrent_map/vs-x86/Parallel%20workload.xlsx.5M%2C%200.99.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.01.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.01.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.5.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.5.png]
+|image::benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.99.png[width=250,window=_blank,link= _images/benchmarks-concurrent_map/vs-x86/Parallel workload.xlsx.5M, 0.99.png]
 
 h|5M updates, 45M lookups +
 skew=0.01
diff --git a/doc/modules/ROOT/pages/buckets.adoc b/doc/modules/ROOT/pages/buckets.adoc
index bef4de66..bbf77e24 100644
--- a/doc/modules/ROOT/pages/buckets.adoc
+++ b/doc/modules/ROOT/pages/buckets.adoc
@@ -1,6 +1,5 @@
 [#buckets]
 :idprefix: buckets_
-:imagesdir: ../diagrams
 
 = Basics of Hash Tables
 
@@ -49,15 +48,15 @@ open-addressing containers offer a very limited API for accessing buckets.
 2+^h| *All containers*
 h|*Method* h|*Description*
 
-|`size_type bucket_count() const` 
+|`size_type bucket_count() const`
 |The number of buckets.
 
 2+^h| *Closed-addressing containers only*
 h|*Method* h|*Description*
 
-|`size_type max_bucket_count() const` 
+|`size_type max_bucket_count() const`
 |An upper bound on the number of buckets.
-|`size_type bucket_size(size_type n) const` 
+|`size_type bucket_size(size_type n) const`
 |The number of elements in bucket `n`.
 
 |`size_type bucket(key_type const& k) const`
@@ -112,13 +111,13 @@ or close to the hint - unless your hint is unreasonably small or large.
 2+^h| *All containers*
 h|*Method* h|*Description*
 
-|`X(size_type n)` 
+|`X(size_type n)`
 |Construct an empty container with at least `n` buckets (`X` is the container type).
 
-|`X(InputIterator i, InputIterator j, size_type n)` 
+|`X(InputIterator i, InputIterator j, size_type n)`
 |Construct an empty container with at least `n` buckets and insert elements from the range `[i, j)` (`X` is the container type).
 
-|`float load_factor() const` 
+|`float load_factor() const`
 |The average number of elements per bucket.
 
 |`float max_load_factor() const`
@@ -139,12 +138,10 @@ h|*Method* h|*Description*
 
 |===
 
-A note on `max_load` for open-addressing and concurrent containers: the maximum load will be 
+A note on `max_load` for open-addressing and concurrent containers: the maximum load will be
 (`max_load_factor() * bucket_count()`) right after `rehash` or on container creation, but may
 slightly decrease when erasing elements in high-load situations. For instance, if we
 have a <<unordered_flat_map,`boost::unordered_flat_map`>> with `size()` almost
 at `max_load()` level and then erase 1,000 elements, `max_load()` may decrease by around a
 few dozen elements. This is done internally by Boost.Unordered in order
 to keep its performance stable, and must be taken into account when planning for rehash-free insertions.
-
-
diff --git a/doc/modules/ROOT/pages/changes.adoc b/doc/modules/ROOT/pages/changes.adoc
index a7034389..32a1bf64 100644
--- a/doc/modules/ROOT/pages/changes.adoc
+++ b/doc/modules/ROOT/pages/changes.adoc
@@ -296,7 +296,7 @@ when the returned proxy is not used.
 
 This is major change which has been converted to use Boost.Move's move
 emulation, and be more compliant with the {cpp}11 standard. See the
-xref:unordered.adoc#compliance[compliance section] for details.
+xref:compliance.adoc[compliance section] for details.
 
 The container now meets {cpp}11's complexity requirements, but to do so
 uses a little more memory. This means that `quick_erase` and
@@ -456,5 +456,3 @@ many of the suggestions from the review.
 
 Initial review version, for the review conducted from 7th December 2007 to
 16th December 2007.
-
-
diff --git a/doc/modules/ROOT/pages/compliance.adoc b/doc/modules/ROOT/pages/compliance.adoc
index d532b246..c2f2904f 100644
--- a/doc/modules/ROOT/pages/compliance.adoc
+++ b/doc/modules/ROOT/pages/compliance.adoc
@@ -22,7 +22,7 @@ are only available on {cpp}17 (or later) compilers.
 === Piecewise Pair Emplacement
 
 In accordance with the standard specification,
-`boost::unordered_[multi]map::emplace` supports piecewise pair construction: 
+`boost::unordered_[multi]map::emplace` supports piecewise pair construction:
 
 [source,c++]
 ----
@@ -66,7 +66,7 @@ radically different from that imposed by the standard (closed addressing).
 
 Open-addressing containers provided by Boost.Unordered only work with reasonably
 compliant C++11 (or later) compilers. Language-level features such as move semantics
-and variadic template parameters are then not emulated. 
+and variadic template parameters are then not emulated.
 The containers are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^]
 and support https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[fancy pointers^].
 
@@ -103,7 +103,7 @@ except those implying iterators.
 
 In a non-concurrent unordered container, iterators serve two main purposes:
 
-* Access to an element previously located via lookup. 
+* Access to an element previously located via lookup.
 * Container traversal.
 
 In place of iterators, Boost.Unordered concurrent containers use _internal visitation_
@@ -136,7 +136,7 @@ template<class F> size_t visit_all(F f);
 of which there are parallelized versions in C++17 compilers with parallel
 algorithm support. In general, the interface of concurrent containers
 is derived from that of their non-concurrent counterparts by a fairly straightforward
-process of replacing iterators with visitation where applicable. If for 
+process of replacing iterators with visitation where applicable. If for
 regular maps `iterator` and `const_iterator` provide mutable and const access to elements,
 respectively, here visitation is granted mutable or const access depending on
 the constness of the member function used (there are also `*cvisit` overloads for
@@ -145,6 +145,6 @@ explicit const visitation); In the case of `boost::concurrent_flat_set`, visitat
 One notable operation not provided by `boost::concurrent_flat_map`/`boost::concurrent_node_map`
 is `operator[]`/`at`, which can be
 replaced, if in a more convoluted manner, by
-xref:#concurrent_flat_map_try_emplace_or_cvisit[`try_emplace_or_visit`].
+`xref:reference/concurrent_flat_map.adoc#concurrent_flat_map_try_emplace_or_cvisit[try_emplace_or_visit]`.
 
 //-
diff --git a/doc/modules/ROOT/pages/concurrent.adoc b/doc/modules/ROOT/pages/concurrent.adoc
index 75fd7922..3a4ee3b0 100644
--- a/doc/modules/ROOT/pages/concurrent.adoc
+++ b/doc/modules/ROOT/pages/concurrent.adoc
@@ -82,7 +82,7 @@ On the other hand, a visitation function can _not_ access the container itself:
 
 [source,c++]
 ----
-m.visit(k, [&](const auto& x) { 
+m.visit(k, [&](const auto& x) {
   some_function(x, m.size()); // forbidden: m can't be accessed inside visitation
 });
 ----
@@ -105,7 +105,7 @@ outside of visitation may be beneficial:
 [source,c++]
 ----
 std::optional<value_type> o;
-bool found = m.visit(k, [&](const auto& x) { 
+bool found = m.visit(k, [&](const auto& x) {
   o = x;
 });
 if (found) {
@@ -118,7 +118,7 @@ many classical operations have visitation-enabled variations:
 
 [source,c++]
 ----
-m.insert_or_visit(x, [](auto& y) { 
+m.insert_or_visit(x, [](auto& y) {
   // if insertion failed because of an equivalent element y,
   // do something with it, for instance:
   ++y.second; // increment the mapped part of the element
@@ -141,19 +141,19 @@ element already exists):
 [source,c++]
 ----
   m.insert_and_cvisit(x,
-    [](const auto& y) { 
-      std::cout<< "(" << y.first << ", " << y.second <<") inserted\n"; 
+    [](const auto& y) {
+      std::cout<< "(" << y.first << ", " << y.second <<") inserted\n";
     },
-    [](const auto& y) { 
-      std::cout<< "(" << y.first << ", " << y.second << ") already exists\n"; 
+    [](const auto& y) {
+      std::cout<< "(" << y.first << ", " << y.second << ") already exists\n";
     });
 ----
 
 Consult the references of
-xref:#concurrent_node_set[`boost::concurrent_node_set`],
-xref:#concurrent_flat_map[`boost::concurrent_node_map`],
-xref:#concurrent_flat_set[`boost::concurrent_flat_set`] and 
-xref:#concurrent_flat_map[`boost::concurrent_flat_map`]
+`xref:reference/concurrent_node_set#concurrent_node_set[boost::concurrent_node_set]`,
+`xref:reference/concurrent_node_map#concurrent_flat_map[boost::concurrent_node_map]`,
+`xref:reference/concurrent_flat_set#concurrent_flat_set[boost::concurrent_flat_set]` and
+`xref:reference/concurrent_flat_map#concurrent_flat_map[boost::concurrent_flat_map]`
 for the complete list of visitation-enabled operations.
 
 == Whole-Table Visitation
@@ -237,7 +237,7 @@ m.visit(keys.begin(), keys.end(), [](auto& x) { ++x.second; });
 This functionality is not provided for mere syntactic convenience, though: by processing all the
 keys at once, some internal optimizations can be applied that increase
 performance over the regular, one-at-a-time case (consult the
-xref:#benchmarks_boostconcurrent_flat_map[benchmarks]). In fact, it may be beneficial
+xref:benchmarks.adoc#benchmarks_boostconcurrent_flatnode_map[benchmarks]). In fact, it may be beneficial
 to buffer incoming keys so that they can be bulk visited in chunks:
 
 [source,c++]
diff --git a/doc/modules/ROOT/pages/debuggability.adoc b/doc/modules/ROOT/pages/debuggability.adoc
index 6e7e674f..3ded2170 100644
--- a/doc/modules/ROOT/pages/debuggability.adoc
+++ b/doc/modules/ROOT/pages/debuggability.adoc
@@ -53,7 +53,7 @@ You can load the pretty-printers externally from the non-embedded Python script.
 
 === Visualization structure
 
-The visualizations mirror the standard unordered containers. The map containers display an association from key to mapped value. The set containers display an association from index to value. An iterator is either displayed with its item, or as an end iterator. Here is what may be shown for an example `boost::unordered_map`, an example `boost::unordered_set`, and their respective begin and end iterators. 
+The visualizations mirror the standard unordered containers. The map containers display an association from key to mapped value. The set containers display an association from index to value. An iterator is either displayed with its item, or as an end iterator. Here is what may be shown for an example `boost::unordered_map`, an example `boost::unordered_set`, and their respective begin and end iterators.
 
 ```plaintext
 (gdb) print example_unordered_map
@@ -74,11 +74,11 @@ The other containers are identical other than replacing "`boost::unordered_{map|
 
 Both the SIMD and the non-SIMD implementations are viewable through the GDB pretty-printers.
 
-For open-addressing containers where xref:#hash_quality_container_statistics[container statistics] are enabled, you can obtain these statistics by calling `get_stats()` on the container, from within GDB. This is overridden in GDB as an link:https://sourceware.org/gdb/current/onlinedocs/gdb.html/Xmethod-API.html[xmethod], so it will not invoke any C++ synchronization code. See the following printout as an example for the expected format.
+For open-addressing containers where xref:hash_quality.adoc#hash_quality_container_statistics[container statistics] are enabled, you can obtain these statistics by calling `get_stats()` on the container, from within GDB. This is overridden in GDB as an link:https://sourceware.org/gdb/current/onlinedocs/gdb.html/Xmethod-API.html[xmethod], so it will not invoke any C++ synchronization code. See the following printout as an example for the expected format.
 
 ```plaintext
 (gdb) print example_flat_map.get_stats()
-$1 = [stats] = {[insertion] = {[count] = 5, [probe_length] = {avg = 1.0, var = 0.0, dev = 0.0}}, 
+$1 = [stats] = {[insertion] = {[count] = 5, [probe_length] = {avg = 1.0, var = 0.0, dev = 0.0}},
   [successful_lookup] = {[count] = 0, [probe_length] = {avg = 0.0, var = 0.0, dev = 0.0},
     [num_comparisons] = {avg = 0.0, var = 0.0, dev = 0.0}}, [unsuccessful_lookup] = {[count] = 5,
     [probe_length] = {avg = 1.0, var = 0.0, dev = 0.0},
diff --git a/doc/modules/ROOT/pages/hash_equality.adoc b/doc/modules/ROOT/pages/hash_equality.adoc
index 583e1173..065c03a2 100644
--- a/doc/modules/ROOT/pages/hash_equality.adoc
+++ b/doc/modules/ROOT/pages/hash_equality.adoc
@@ -9,7 +9,7 @@ elements are stored, the unordered associative containers use an equality
 predicate and a hash function. For example, <<unordered_map,boost::unordered_map>>
 is declared as:
 
-```
+```cpp
 template <
     class Key, class Mapped,
     class Hash = boost::hash<Key>,
@@ -22,7 +22,7 @@ The hash function comes first as you might want to change the hash function
 but not the equality predicate. For example, if you wanted to use the
 https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash[FNV-1a hash^] you could write:
 
-```
+```cpp
 boost::unordered_map<std::string, int, hash::fnv_1a>
     dictionary;
 ```
@@ -31,7 +31,7 @@ There is an link:../../examples/fnv1.hpp[implementation of FNV-1a^] in the examp
 
 If you wish to use a different equality function, you will also need to use a matching hash function. For example, to implement a case insensitive dictionary you need to define a case insensitive equality predicate and hash function:
 
-```
+```cpp
 struct iequal_to
 {
     bool operator()(std::string const& x,
@@ -60,7 +60,7 @@ struct ihash
 ```
 
 Which you can then use in a case insensitive dictionary:
-```
+```cpp
 boost::unordered_map<std::string, int, ihash, iequal_to>
     idictionary;
 ```
@@ -80,7 +80,7 @@ equality predicate (e.g. `boost::function`) then you can get into trouble.
 
 Similarly, a custom hash function can be used for custom types:
 
-```
+```cpp
 struct point {
     int x;
     int y;
@@ -108,7 +108,7 @@ boost::unordered_multiset<point, point_hash> points;
 Since the default hash function is link:../../../container_hash/index.html[Boost.Hash^],
 we can extend it to support the type so that the hash function doesn't need to be explicitly given:
 
-```
+```cpp
 struct point {
     int x;
     int y;
@@ -140,10 +140,10 @@ you'll need to explicitly use Boost.Hash.
 |===
 |Method |Description
 
-|`hasher hash_function() const` 
+|`hasher hash_function() const`
 |Returns the container's hash function.
 
-|`key_equal key_eq() const` 
+|`key_equal key_eq() const`
 |Returns the container's key equality function..
 
 |===
diff --git a/doc/modules/ROOT/pages/hash_quality.adoc b/doc/modules/ROOT/pages/hash_quality.adoc
index 828e9421..803fb42f 100644
--- a/doc/modules/ROOT/pages/hash_quality.adoc
+++ b/doc/modules/ROOT/pages/hash_quality.adoc
@@ -43,7 +43,7 @@ struct my_string_hash_function
 ----
 
 By setting the
-xref:#hash_traits_hash_is_avalanching[hash_is_avalanching] trait, we inform Boost.Unordered
+`xref:reference/hash_traits.adoc#hash_traits_hash_is_avalanching[hash_is_avalanching]` trait, we inform Boost.Unordered
 that `my_string_hash_function` is of sufficient quality to be used directly without
 any post-mixing safety net. This comes at the risk of degraded performance in the
 cases where the hash function is not as well-behaved as we've declared.
@@ -75,7 +75,7 @@ The `stats` object provides the following information:
 
 [source,subs=+quotes]
 ----
-stats 
+stats
      .insertion                                     // *Insertion operations*
                .count                               // Number of operations
                .probe_length                        // Probe length per operation
@@ -101,20 +101,20 @@ stats
                          .num_comparisons           // Elements compared per operation
 			                             .average
                                          .variance
-                                         .deviation 
+                                         .deviation
 ----
 
 Statistics for three internal operations are maintained: insertions (without considering
 the previous lookup to determine that the key is not present yet), successful lookups,
 and unsuccessful lookups (including those issued internally when inserting elements).
 _Probe length_ is  the number of
-xref:#structures_open_addressing_containers[bucket groups] accessed per operation.
+xref:structures.adoc#structures_open_addressing_containers[bucket groups] accessed per operation.
 If the hash function behaves properly:
 
 * Average probe lengths should be close to 1.0.
 * The average number of comparisons per successful lookup should be close to 1.0 (that is,
 just the element found is checked).
-* The average number of comparisons per unsuccessful lookup should be close to 0.0. 
+* The average number of comparisons per unsuccessful lookup should be close to 0.0.
 
 An link:../../benchmark/string_stats.cpp[example^] is provided that displays container
 statistics for `boost::hash<std::string>`, an implementation of the
diff --git a/doc/modules/ROOT/pages/intro.adoc b/doc/modules/ROOT/pages/intro.adoc
index 907f59d9..e6728c04 100644
--- a/doc/modules/ROOT/pages/intro.adoc
+++ b/doc/modules/ROOT/pages/intro.adoc
@@ -37,7 +37,7 @@ boost::unordered_multimap
 ^|
 
 ^.^h|*Open addressing*
-^m| boost::unordered_node_set + 
+^m| boost::unordered_node_set +
 boost::unordered_node_map
 ^m| boost::unordered_flat_set +
 boost::unordered_flat_map
@@ -56,7 +56,7 @@ in the market within the technical constraints imposed by the required standard
 * **Open-addressing containers** rely on much faster data structures and algorithms
 (more than 2 times faster in typical scenarios) while slightly diverging from the standard
 interface to accommodate the implementation.
-There are two variants: **flat** (the fastest) and **node-based**, which 
+There are two variants: **flat** (the fastest) and **node-based**, which
 provide pointer stability under rehashing at the expense of being slower.
 * Finally, **concurrent containers** are designed and implemented to be used in high-performance
 multithreaded scenarios. Their interface is radically different from that of regular C++ containers.
@@ -66,14 +66,14 @@ All sets and maps in Boost.Unordered are instantiatied similarly as
 `std::unordered_set` and `std::unordered_map`, respectively:
 
 [source,c++]
-----  
+----
 namespace boost {
     template <
         class Key,
         class Hash = boost::hash<Key>,
         class Pred = std::equal_to<Key>,
         class Alloc = std::allocator<Key> >
-    class unordered_set; 
+    class unordered_set;
     // same for unordered_multiset, unordered_flat_set, unordered_node_set,
     // concurrent_flat_set and concurrent_node_set
 
diff --git a/doc/modules/ROOT/pages/rationale.adoc b/doc/modules/ROOT/pages/rationale.adoc
index 29df32f0..9023440a 100644
--- a/doc/modules/ROOT/pages/rationale.adoc
+++ b/doc/modules/ROOT/pages/rationale.adoc
@@ -74,7 +74,7 @@ Since release 1.80.0, prime numbers are chosen for the number of buckets in
 tandem with sophisticated modulo arithmetic. This removes the need for "mixing"
 the result of the user's hash function as was used for release 1.79.0.
 
-== Open-addresing Containers 
+== Open-addresing Containers
 
 The C++ standard specification of unordered associative containers impose
 severe limitations on permissible implementations, the most important being
@@ -129,15 +129,14 @@ concurrent scenarios.
 * Open-addressing layouts are eminently suitable for concurrent access and modification
 with minimal locking. In particular, the metadata array can be used for implementations of
 lookup that are lock-free up to the last step of actual element comparison.
-* Layout compatibility with Boost.Unordered flat containers allows for 
-xref:#concurrent_interoperability_with_non_concurrent_containers[fast transfer]
+* Layout compatibility with Boost.Unordered flat containers allows for
+xref:concurrent.adoc#concurrent_interoperability_with_non_concurrent_containers[fast transfer]
 of all elements between a concurrent container and its non-concurrent counterpart,
 and vice versa.
 
 === Hash Function and Platform Interoperability
 
 Concurrent containers make the same decisions and provide the same guarantees
-as Boost.Unordered open-addressing containers with regards to 
+as Boost.Unordered open-addressing containers with regards to
 xref:#rationale_hash_function[hash function defaults] and
 xref:#rationale_platform_interoperability[platform interoperability].
-
diff --git a/doc/modules/ROOT/pages/ref.adoc b/doc/modules/ROOT/pages/ref.adoc
index 9a1a5098..c6f65ce9 100644
--- a/doc/modules/ROOT/pages/ref.adoc
+++ b/doc/modules/ROOT/pages/ref.adoc
@@ -1,17 +1,17 @@
 [#reference]
 = Reference
 
-include::unordered_map.adoc[]
-include::unordered_multimap.adoc[]
-include::unordered_set.adoc[]
-include::unordered_multiset.adoc[]
-include::hash_traits.adoc[]
-include::stats.adoc[]
-include::unordered_flat_map.adoc[]
-include::unordered_flat_set.adoc[]
-include::unordered_node_map.adoc[]
-include::unordered_node_set.adoc[]
-include::concurrent_flat_map.adoc[]
-include::concurrent_flat_set.adoc[]
-include::concurrent_node_map.adoc[]
-include::concurrent_node_set.adoc[]
+* xref:reference/unordered_map.adoc[unordered_map]
+* xref:reference/unordered_multimap.adoc[unordered_multimap]
+* xref:reference/unordered_set.adoc[unordered_set]
+* xref:reference/unordered_multiset.adoc[unordered_multiset]
+* xref:reference/hash_traits.adoc[hash_traits]
+* xref:reference/stats.adoc[stats]
+* xref:reference/unordered_flat_map.adoc[unordered_flat_map]
+* xref:reference/unordered_flat_set.adoc[unordered_flat_set]
+* xref:reference/unordered_node_map.adoc[unordered_node_map]
+* xref:reference/unordered_node_set.adoc[unordered_node_set]
+* xref:reference/concurrent_flat_map.adoc[concurrent_flat_map]
+* xref:reference/concurrent_flat_set.adoc[concurrent_flat_set]
+* xref:reference/concurrent_node_map.adoc[concurrent_node_map]
+* xref:reference/concurrent_node_set.adoc[concurrent_node_set]
diff --git a/doc/modules/ROOT/pages/regular.adoc b/doc/modules/ROOT/pages/regular.adoc
index 9ad36258..b259e3a4 100644
--- a/doc/modules/ROOT/pages/regular.adoc
+++ b/doc/modules/ROOT/pages/regular.adoc
@@ -5,12 +5,12 @@
 
 Boost.Unordered closed-addressing containers (`boost::unordered_set`, `boost::unordered_map`,
 `boost::unordered_multiset` and `boost::unordered_multimap`) are fully conformant with the
-C++ specification for unordered associative containers, so for those who know how to use 
+C++ specification for unordered associative containers, so for those who know how to use
 `std::unordered_set`, `std::unordered_map`, etc., their homonyms in Boost.Unordered are
-drop-in replacements. The interface of open-addressing containers (`boost::unordered_node_set`, 
+drop-in replacements. The interface of open-addressing containers (`boost::unordered_node_set`,
 `boost::unordered_node_map`, `boost::unordered_flat_set` and `boost::unordered_flat_map`)
 is very similar, but they present some minor differences listed in the dedicated
-xref:#compliance_open_addressing_containers[standard compliance section].
+xref:compliance.adoc#compliance_open_addressing_containers[standard compliance section].
 
 
 For readers without previous experience with hash containers but familiar
@@ -60,7 +60,7 @@ change the number of buckets when this happens. Iterators can be
 invalidated by calls to `insert`, `rehash` and `reserve`.
 
 As for pointers and references,
-they are never invalidated for node-based containers 
+they are never invalidated for node-based containers
 (`boost::unordered_[multi]set`, `boost::unordered_[multi]map`, `boost::unordered_node_set`, `boost::unordered_node_map`),
 but they will be when rehashing occurs for
 `boost::unordered_flat_set` and `boost::unordered_flat_map`: this is because
@@ -106,10 +106,10 @@ See the <<unordered_map_rehash,reference for more details>> on the `rehash` func
 |Keys can be compared using `key_compare` which is accessed by member function `key_comp()`, values can be compared using `value_compare` which is accessed by member function `value_comp()`.
 |Keys can be hashed using `hasher` which is accessed by member function `hash_function()`, and checked for equality using `key_equal` which is accessed by member function `key_eq()`. There is no function object for compared or hashing values.
 
-|Constructors have optional extra parameters for the comparison object. 
+|Constructors have optional extra parameters for the comparison object.
 |Constructors have optional extra parameters for the initial minimum number of buckets, a hash function and an equality object.
 
-|Keys `k1`, `k2` are considered equivalent if `!Compare(k1, k2) && !Compare(k2, k1)`. 
+|Keys `k1`, `k2` are considered equivalent if `!Compare(k1, k2) && !Compare(k2, k1)`.
 |Keys `k1`, `k2` are considered equivalent if `Pred(k1, k2)`
 
 |Member function `lower_bound(k)` and `upper_bound(k)`
diff --git a/doc/modules/ROOT/pages/structures.adoc b/doc/modules/ROOT/pages/structures.adoc
index 66214340..0208a236 100644
--- a/doc/modules/ROOT/pages/structures.adoc
+++ b/doc/modules/ROOT/pages/structures.adoc
@@ -25,7 +25,7 @@ Canonical standard implementations will wind up looking like the diagram below:
 
 [.text-center]
 .The canonical standard approach
-image::singly-linked.png[align=center,link=../diagrams/singly-linked.png,window=_blank]
+image::singly-linked.png[align=center,link=_images/singly-linked.png,window=_blank]
 
 It's worth noting that this approach is only used by pass:[libc++] and pass:[libstdc++]; the MSVC Dinkumware implementation uses a different one. A more detailed analysis of the standard containers can be found http://bannalia.blogspot.com/2013/10/implementation-of-c-unordered.html[here].
 
@@ -63,7 +63,7 @@ A more detailed description of Boost.Unordered's closed-addressing implementatio
 given in an
 https://bannalia.blogspot.com/2022/06/advancing-state-of-art-for.html[external article].
 For more information on implementation rationale, read the
-xref:#rationale_closed_addressing_containers[corresponding section].
+xref:rationale.adoc#rationale_open_addresing_containers[corresponding section].
 
 == Open-addressing Containers
 
@@ -125,13 +125,13 @@ A more detailed description of Boost.Unordered's open-addressing implementation
 given in an
 https://bannalia.blogspot.com/2022/11/inside-boostunorderedflatmap.html[external article].
 For more information on implementation rationale, read the
-xref:#rationale_open_addresing_containers[corresponding section].
+xref:rationale.adoc#rationale_open_addresing_containers[corresponding section].
 
 == Concurrent Containers
 
 `boost::concurrent_flat_set`/`boost::concurrent_node_set` and
 `boost::concurrent_flat_map`/`boost::concurrent_node_map` use the basic
-xref:#structures_open_addressing_containers[open-addressing layout] described above
+xref:structures.adoc#structures_open_addressing_containers[open-addressing layout] described above
 augmented with synchronization mechanisms.
 
 
@@ -177,4 +177,4 @@ practice, the start-over frequency is extremely small, measured in the range
 of parts per million for some of our benchmarks.
 
 For more information on implementation rationale, read the
-xref:#rationale_concurrent_containers[corresponding section].
+xref:rationale.adoc#rationale_concurrent_containers[corresponding section].