diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9239071..a9c10a8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/")
 set(EXECUTABLE_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/build")
 
 # set compiler flags, see http://stackoverflow.com/questions/7724569/debug-vs-release-in-cmake
-set(CMAKE_CXX_FLAGS                "-Ofast -fno-signed-zeros -fno-trapping-math -Wall -Wno-format-extra-args -Wextra -Wformat-nonliteral -Wformat-security -Wformat=2 -Wextra -Wno-implicit-fallthrough -pedantic")
+set(CMAKE_CXX_FLAGS                "-Ofast -fno-signed-zeros -fno-trapping-math -Wall -Wno-format-extra-args -Wextra -Wformat-nonliteral -Wformat-security -Wformat=2 -Wextra -Wno-implicit-fallthrough -pedantic -Wno-keyword-macro")
 set(CMAKE_CXX_FLAGS_SANITIZE       "-Og -g -fsanitize=address -fsanitize=leak -fsanitize=undefined -DLOGLEVEL=3 -DPFAEDLE_DBG=1")
 set(CMAKE_CXX_FLAGS_PROFILE        "-g -pg -DLOGLEVEL=3 -DPFAEDLE_DBG=1")
 set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g -DLOGLEVEL=3 -DPFAEDLE_DBG=1")
diff --git a/src/util/3rdparty/MurmurHash3.cpp b/src/util/3rdparty/MurmurHash3.cpp
index aa7982d..23ac4fb 100644
--- a/src/util/3rdparty/MurmurHash3.cpp
+++ b/src/util/3rdparty/MurmurHash3.cpp
@@ -16,57 +16,48 @@
 
 #if defined(_MSC_VER)
 
-#define FORCE_INLINE	__forceinline
+#define FORCE_INLINE __forceinline
 
 #include <stdlib.h>
 
-#define ROTL32(x,y)	_rotl(x,y)
-#define ROTL64(x,y)	_rotl64(x,y)
+#define ROTL32(x, y) _rotl(x, y)
+#define ROTL64(x, y) _rotl64(x, y)
 
 #define BIG_CONSTANT(x) (x)
 
 // Other compilers
 
-#else	// defined(_MSC_VER)
+#else  // defined(_MSC_VER)
 
-#define	FORCE_INLINE inline __attribute__((always_inline))
+#define FORCE_INLINE inline __attribute__((always_inline))
 
-inline uint32_t rotl32 ( uint32_t x, int8_t r )
-{
+inline uint32_t rotl32(uint32_t x, int8_t r) {
   return (x << r) | (x >> (32 - r));
 }
 
-inline uint64_t rotl64 ( uint64_t x, int8_t r )
-{
+inline uint64_t rotl64(uint64_t x, int8_t r) {
   return (x << r) | (x >> (64 - r));
 }
 
-#define	ROTL32(x,y)	rotl32(x,y)
-#define ROTL64(x,y)	rotl64(x,y)
+#define ROTL32(x, y) rotl32(x, y)
+#define ROTL64(x, y) rotl64(x, y)
 
 #define BIG_CONSTANT(x) (x##LLU)
 
-#endif // !defined(_MSC_VER)
+#endif  // !defined(_MSC_VER)
 
 //-----------------------------------------------------------------------------
 // Block read - if your platform needs to do endian-swapping or can only
 // handle aligned reads, do the conversion here
 
-FORCE_INLINE uint32_t getblock32 ( const uint32_t * p, int i )
-{
-  return p[i];
-}
+FORCE_INLINE uint32_t getblock32(const uint32_t *p, int i) { return p[i]; }
 
-FORCE_INLINE uint64_t getblock64 ( const uint64_t * p, int i )
-{
-  return p[i];
-}
+FORCE_INLINE uint64_t getblock64(const uint64_t *p, int i) { return p[i]; }
 
 //-----------------------------------------------------------------------------
 // Finalization mix - force all bits of a hash block to avalanche
 
-FORCE_INLINE uint32_t fmix32 ( uint32_t h )
-{
+FORCE_INLINE uint32_t fmix32(uint32_t h) {
   h ^= h >> 16;
   h *= 0x85ebca6b;
   h ^= h >> 13;
@@ -78,8 +69,7 @@ FORCE_INLINE uint32_t fmix32 ( uint32_t h )
 
 //----------
 
-FORCE_INLINE uint64_t fmix64 ( uint64_t k )
-{
+FORCE_INLINE uint64_t fmix64(uint64_t k) {
   k ^= k >> 33;
   k *= BIG_CONSTANT(0xff51afd7ed558ccd);
   k ^= k >> 33;
@@ -91,10 +81,8 @@ FORCE_INLINE uint64_t fmix64 ( uint64_t k )
 
 //-----------------------------------------------------------------------------
 
-void MurmurHash3_x86_32 ( const void * key, int len,
-                          uint32_t seed, void * out )
-{
-  const uint8_t * data = (const uint8_t*)key;
+void MurmurHash3_x86_32(const void *key, int len, uint32_t seed, void *out) {
+  const uint8_t *data = (const uint8_t *)key;
   const int nblocks = len / 4;
 
   uint32_t h1 = seed;
@@ -105,34 +93,40 @@ void MurmurHash3_x86_32 ( const void * key, int len,
   //----------
   // body
 
-  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+  const uint32_t *blocks = (const uint32_t *)(data + nblocks * 4);
 
-  for(int i = -nblocks; i; i++)
-  {
-    uint32_t k1 = getblock32(blocks,i);
+  for (int i = -nblocks; i; i++) {
+    uint32_t k1 = getblock32(blocks, i);
 
     k1 *= c1;
-    k1 = ROTL32(k1,15);
+    k1 = ROTL32(k1, 15);
     k1 *= c2;
-    
+
     h1 ^= k1;
-    h1 = ROTL32(h1,13); 
-    h1 = h1*5+0xe6546b64;
+    h1 = ROTL32(h1, 13);
+    h1 = h1 * 5 + 0xe6546b64;
   }
 
   //----------
   // tail
 
-  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+  const uint8_t *tail = (const uint8_t *)(data + nblocks * 4);
 
   uint32_t k1 = 0;
 
-  switch(len & 3)
-  {
-  case 3: k1 ^= tail[2] << 16;
-  case 2: k1 ^= tail[1] << 8;
-  case 1: k1 ^= tail[0];
-          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  switch (len & 3) {
+    case 3:
+      k1 ^= tail[2] << 16;
+      // fall through
+    case 2:
+      k1 ^= tail[1] << 8;
+      // fall through
+    case 1:
+      k1 ^= tail[0];
+      k1 *= c1;
+      k1 = ROTL32(k1, 15);
+      k1 *= c2;
+      h1 ^= k1;
   };
 
   //----------
@@ -142,15 +136,14 @@ void MurmurHash3_x86_32 ( const void * key, int len,
 
   h1 = fmix32(h1);
 
-  *(uint32_t*)out = h1;
-} 
+  *(uint32_t *)out = h1;
+}
 
 //-----------------------------------------------------------------------------
 
-void MurmurHash3_x86_128 ( const void * key, const int len,
-                           uint32_t seed, void * out )
-{
-  const uint8_t * data = (const uint8_t*)key;
+void MurmurHash3_x86_128(const void *key, const int len, uint32_t seed,
+                         void *out) {
+  const uint8_t *data = (const uint8_t *)key;
   const int nblocks = len / 16;
 
   uint32_t h1 = seed;
@@ -158,104 +151,170 @@ void MurmurHash3_x86_128 ( const void * key, const int len,
   uint32_t h3 = seed;
   uint32_t h4 = seed;
 
-  const uint32_t c1 = 0x239b961b; 
+  const uint32_t c1 = 0x239b961b;
   const uint32_t c2 = 0xab0e9789;
-  const uint32_t c3 = 0x38b34ae5; 
+  const uint32_t c3 = 0x38b34ae5;
   const uint32_t c4 = 0xa1e38b93;
 
   //----------
   // body
 
-  const uint32_t * blocks = (const uint32_t *)(data + nblocks*16);
+  const uint32_t *blocks = (const uint32_t *)(data + nblocks * 16);
 
-  for(int i = -nblocks; i; i++)
-  {
-    uint32_t k1 = getblock32(blocks,i*4+0);
-    uint32_t k2 = getblock32(blocks,i*4+1);
-    uint32_t k3 = getblock32(blocks,i*4+2);
-    uint32_t k4 = getblock32(blocks,i*4+3);
+  for (int i = -nblocks; i; i++) {
+    uint32_t k1 = getblock32(blocks, i * 4 + 0);
+    uint32_t k2 = getblock32(blocks, i * 4 + 1);
+    uint32_t k3 = getblock32(blocks, i * 4 + 2);
+    uint32_t k4 = getblock32(blocks, i * 4 + 3);
 
-    k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+    k1 *= c1;
+    k1 = ROTL32(k1, 15);
+    k1 *= c2;
+    h1 ^= k1;
 
-    h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b;
+    h1 = ROTL32(h1, 19);
+    h1 += h2;
+    h1 = h1 * 5 + 0x561ccd1b;
 
-    k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+    k2 *= c2;
+    k2 = ROTL32(k2, 16);
+    k2 *= c3;
+    h2 ^= k2;
 
-    h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747;
+    h2 = ROTL32(h2, 17);
+    h2 += h3;
+    h2 = h2 * 5 + 0x0bcaa747;
 
-    k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+    k3 *= c3;
+    k3 = ROTL32(k3, 17);
+    k3 *= c4;
+    h3 ^= k3;
 
-    h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35;
+    h3 = ROTL32(h3, 15);
+    h3 += h4;
+    h3 = h3 * 5 + 0x96cd1c35;
 
-    k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+    k4 *= c4;
+    k4 = ROTL32(k4, 18);
+    k4 *= c1;
+    h4 ^= k4;
 
-    h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17;
+    h4 = ROTL32(h4, 13);
+    h4 += h1;
+    h4 = h4 * 5 + 0x32ac3b17;
   }
 
   //----------
   // tail
 
-  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+  const uint8_t *tail = (const uint8_t *)(data + nblocks * 16);
 
   uint32_t k1 = 0;
   uint32_t k2 = 0;
   uint32_t k3 = 0;
   uint32_t k4 = 0;
 
-  switch(len & 15)
-  {
-  case 15: k4 ^= tail[14] << 16;
-  case 14: k4 ^= tail[13] << 8;
-  case 13: k4 ^= tail[12] << 0;
-           k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
-
-  case 12: k3 ^= tail[11] << 24;
-  case 11: k3 ^= tail[10] << 16;
-  case 10: k3 ^= tail[ 9] << 8;
-  case  9: k3 ^= tail[ 8] << 0;
-           k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
-
-  case  8: k2 ^= tail[ 7] << 24;
-  case  7: k2 ^= tail[ 6] << 16;
-  case  6: k2 ^= tail[ 5] << 8;
-  case  5: k2 ^= tail[ 4] << 0;
-           k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
-
-  case  4: k1 ^= tail[ 3] << 24;
-  case  3: k1 ^= tail[ 2] << 16;
-  case  2: k1 ^= tail[ 1] << 8;
-  case  1: k1 ^= tail[ 0] << 0;
-           k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  switch (len & 15) {
+    case 15:
+      k4 ^= tail[14] << 16;
+      // fall through
+    case 14:
+      k4 ^= tail[13] << 8;
+      // fall through
+    case 13:
+      k4 ^= tail[12] << 0;
+      k4 *= c4;
+      k4 = ROTL32(k4, 18);
+      k4 *= c1;
+      h4 ^= k4;
+      // fall through
+    case 12:
+      k3 ^= tail[11] << 24;
+      // fall through
+    case 11:
+      k3 ^= tail[10] << 16;
+      // fall through
+    case 10:
+      k3 ^= tail[9] << 8;
+      // fall through
+    case 9:
+      k3 ^= tail[8] << 0;
+      k3 *= c3;
+      k3 = ROTL32(k3, 17);
+      k3 *= c4;
+      h3 ^= k3;
+      // fall through
+    case 8:
+      k2 ^= tail[7] << 24;
+      // fall through
+    case 7:
+      k2 ^= tail[6] << 16;
+      // fall through
+    case 6:
+      k2 ^= tail[5] << 8;
+      // fall through
+    case 5:
+      k2 ^= tail[4] << 0;
+      k2 *= c2;
+      k2 = ROTL32(k2, 16);
+      k2 *= c3;
+      h2 ^= k2;
+      // fall through
+    case 4:
+      k1 ^= tail[3] << 24;
+      // fall through
+    case 3:
+      k1 ^= tail[2] << 16;
+      // fall through
+    case 2:
+      k1 ^= tail[1] << 8;
+      // fall through
+    case 1:
+      k1 ^= tail[0] << 0;
+      k1 *= c1;
+      k1 = ROTL32(k1, 15);
+      k1 *= c2;
+      h1 ^= k1;
   };
 
   //----------
   // finalization
 
-  h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
+  h1 ^= len;
+  h2 ^= len;
+  h3 ^= len;
+  h4 ^= len;
 
-  h1 += h2; h1 += h3; h1 += h4;
-  h2 += h1; h3 += h1; h4 += h1;
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
 
   h1 = fmix32(h1);
   h2 = fmix32(h2);
   h3 = fmix32(h3);
   h4 = fmix32(h4);
 
-  h1 += h2; h1 += h3; h1 += h4;
-  h2 += h1; h3 += h1; h4 += h1;
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
 
-  ((uint32_t*)out)[0] = h1;
-  ((uint32_t*)out)[1] = h2;
-  ((uint32_t*)out)[2] = h3;
-  ((uint32_t*)out)[3] = h4;
+  ((uint32_t *)out)[0] = h1;
+  ((uint32_t *)out)[1] = h2;
+  ((uint32_t *)out)[2] = h3;
+  ((uint32_t *)out)[3] = h4;
 }
 
 //-----------------------------------------------------------------------------
 
-void MurmurHash3_x64_128 ( const void * key, const int len,
-                           const uint32_t seed, void * out )
-{
-  const uint8_t * data = (const uint8_t*)key;
+void MurmurHash3_x64_128(const void *key, const int len, const uint32_t seed,
+                         void *out) {
+  const uint8_t *data = (const uint8_t *)key;
   const int nblocks = len / 16;
 
   uint64_t h1 = seed;
@@ -267,56 +326,99 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
   //----------
   // body
 
-  const uint64_t * blocks = (const uint64_t *)(data);
+  const uint64_t *blocks = (const uint64_t *)(data);
 
-  for(int i = 0; i < nblocks; i++)
-  {
-    uint64_t k1 = getblock64(blocks,i*2+0);
-    uint64_t k2 = getblock64(blocks,i*2+1);
+  for (int i = 0; i < nblocks; i++) {
+    uint64_t k1 = getblock64(blocks, i * 2 + 0);
+    uint64_t k2 = getblock64(blocks, i * 2 + 1);
 
-    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+    k1 *= c1;
+    k1 = ROTL64(k1, 31);
+    k1 *= c2;
+    h1 ^= k1;
 
-    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+    h1 = ROTL64(h1, 27);
+    h1 += h2;
+    h1 = h1 * 5 + 0x52dce729;
 
-    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+    k2 *= c2;
+    k2 = ROTL64(k2, 33);
+    k2 *= c1;
+    h2 ^= k2;
 
-    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+    h2 = ROTL64(h2, 31);
+    h2 += h1;
+    h2 = h2 * 5 + 0x38495ab5;
   }
 
   //----------
   // tail
 
-  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+  const uint8_t *tail = (const uint8_t *)(data + nblocks * 16);
 
   uint64_t k1 = 0;
   uint64_t k2 = 0;
 
-  switch(len & 15)
-  {
-  case 15: k2 ^= ((uint64_t)tail[14]) << 48;
-  case 14: k2 ^= ((uint64_t)tail[13]) << 40;
-  case 13: k2 ^= ((uint64_t)tail[12]) << 32;
-  case 12: k2 ^= ((uint64_t)tail[11]) << 24;
-  case 11: k2 ^= ((uint64_t)tail[10]) << 16;
-  case 10: k2 ^= ((uint64_t)tail[ 9]) << 8;
-  case  9: k2 ^= ((uint64_t)tail[ 8]) << 0;
-           k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
-
-  case  8: k1 ^= ((uint64_t)tail[ 7]) << 56;
-  case  7: k1 ^= ((uint64_t)tail[ 6]) << 48;
-  case  6: k1 ^= ((uint64_t)tail[ 5]) << 40;
-  case  5: k1 ^= ((uint64_t)tail[ 4]) << 32;
-  case  4: k1 ^= ((uint64_t)tail[ 3]) << 24;
-  case  3: k1 ^= ((uint64_t)tail[ 2]) << 16;
-  case  2: k1 ^= ((uint64_t)tail[ 1]) << 8;
-  case  1: k1 ^= ((uint64_t)tail[ 0]) << 0;
-           k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+  switch (len & 15) {
+    case 15:
+      k2 ^= ((uint64_t)tail[14]) << 48;
+      // fall through
+    case 14:
+      k2 ^= ((uint64_t)tail[13]) << 40;
+      // fall through
+    case 13:
+      k2 ^= ((uint64_t)tail[12]) << 32;
+      // fall through
+    case 12:
+      k2 ^= ((uint64_t)tail[11]) << 24;
+      // fall through
+    case 11:
+      k2 ^= ((uint64_t)tail[10]) << 16;
+      // fall through
+    case 10:
+      k2 ^= ((uint64_t)tail[9]) << 8;
+      // fall through
+    case 9:
+      k2 ^= ((uint64_t)tail[8]) << 0;
+      k2 *= c2;
+      k2 = ROTL64(k2, 33);
+      k2 *= c1;
+      h2 ^= k2;
+      // fall through
+    case 8:
+      k1 ^= ((uint64_t)tail[7]) << 56;
+      // fall through
+    case 7:
+      k1 ^= ((uint64_t)tail[6]) << 48;
+      // fall through
+    case 6:
+      k1 ^= ((uint64_t)tail[5]) << 40;
+      // fall through
+    case 5:
+      k1 ^= ((uint64_t)tail[4]) << 32;
+      // fall through
+    case 4:
+      k1 ^= ((uint64_t)tail[3]) << 24;
+      // fall through
+    case 3:
+      k1 ^= ((uint64_t)tail[2]) << 16;
+      // fall through
+    case 2:
+      k1 ^= ((uint64_t)tail[1]) << 8;
+      // fall through
+    case 1:
+      k1 ^= ((uint64_t)tail[0]) << 0;
+      k1 *= c1;
+      k1 = ROTL64(k1, 31);
+      k1 *= c2;
+      h1 ^= k1;
   };
 
   //----------
   // finalization
 
-  h1 ^= len; h2 ^= len;
+  h1 ^= len;
+  h2 ^= len;
 
   h1 += h2;
   h2 += h1;
@@ -327,9 +429,8 @@ void MurmurHash3_x64_128 ( const void * key, const int len,
   h1 += h2;
   h2 += h1;
 
-  ((uint64_t*)out)[0] = h1;
-  ((uint64_t*)out)[1] = h2;
+  ((uint64_t *)out)[0] = h1;
+  ((uint64_t *)out)[1] = h2;
 }
 
 //-----------------------------------------------------------------------------
-
diff --git a/src/util/Misc.h b/src/util/Misc.h
index feb3207..d27e79e 100644
--- a/src/util/Misc.h
+++ b/src/util/Misc.h
@@ -9,8 +9,10 @@
 #include <cstring>
 #include <chrono>
 #include <sstream>
+#include <iomanip>
 #include <immintrin.h>
 #include <iostream>
+#include <sstream>
 #include <vector>
 #include <unistd.h>
 #include <sys/types.h>
@@ -114,6 +116,21 @@ inline bool isFloatingPoint(const std::string& str) {
   return ss.eof() && ! ss.fail();
 }
 
+// _____________________________________________________________________________
+inline std::string formatFloat(double f, size_t digits) {
+  std::stringstream ss;
+  ss << std::fixed << std::setprecision(digits) << f;
+	std::string ret = ss.str();
+
+  if (ret.find('.') != std::string::npos) {
+		auto p = ret.find_last_not_of('0');
+    if (ret[p] == '.') return ret.substr(0, p);
+    return ret.substr(0, p + 1);
+  }
+
+  return ret;
+}
+
 // _____________________________________________________________________________
 inline double atof(const char* p, uint8_t mn) {
   // this atof implementation works only on "normal" float strings like
diff --git a/src/util/geo/Box.h b/src/util/geo/Box.h
index b65f1d3..1415937 100644
--- a/src/util/geo/Box.h
+++ b/src/util/geo/Box.h
@@ -24,6 +24,9 @@ class Box {
   Point<T>& getLowerLeft() { return _ll; }
   Point<T>& getUpperRight() { return _ur; }
 
+  Point<T> getUpperLeft() { return {_ll.getX(), _ur.getY()}; }
+  Point<T> getLowerRight() { return {_ur.getX(), _ll.getY()}; }
+
   void setLowerLeft(const Point<T>& ll) { _ll = ll; }
   void setUpperRight(const Point<T>& ur) { _ur = ur; }
 
diff --git a/src/util/geo/Geo.h b/src/util/geo/Geo.h
index 8b7f966..ce6020b 100644
--- a/src/util/geo/Geo.h
+++ b/src/util/geo/Geo.h
@@ -10,6 +10,7 @@
 #include <math.h>
 #include <algorithm>
 #include <cassert>
+#include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
@@ -742,6 +743,19 @@ inline double angBetween(const Point<T>& p1, const Point<T>& q1) {
   return angBetween(p1.getX(), p1.getY(), q1.getX(), q1.getY());
 }
 
+// _____________________________________________________________________________
+template <typename T>
+inline double angBetween(const Point<T>& p1, const MultiPoint<T>& points) {
+  double sinSum = 0;
+  double cosSum = 0;
+  for (auto q1 : points) {
+    double a = angBetween(p1.getX(), p1.getY(), q1.getX(), q1.getY());
+    sinSum += sin(a);
+    cosSum += cos(a);
+  }
+  return atan2(sinSum / points.size(), cosSum / points.size());
+}
+
 // _____________________________________________________________________________
 inline double dist(double x1, double y1, double x2, double y2) {
   return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
@@ -932,19 +946,19 @@ inline Line<T> lineFromWKT(std::string wkt) {
 // _____________________________________________________________________________
 template <typename T>
 inline std::string getWKT(const Point<T>& p) {
-  std::stringstream ss;
-  ss << std::fixed << std::setprecision(6) << "POINT (" << p.getX() << " " << p.getY() << ")";
-  return ss.str();
+  return std::string("POINT (") + formatFloat(p.getX(), 6) + " " +
+         formatFloat(p.getY(), 6) + ")";
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline std::string getWKT(const std::vector<Point<T>>& p) {
   std::stringstream ss;
-  ss << std::fixed << std::setprecision(6) << "MULTIPOINT (";
+  ss << "MULTIPOINT (";
   for (size_t i = 0; i < p.size(); i++) {
     if (i) ss << ", ";
-    ss << "(" << p[i].getX() << " " << p[i].getY() << ")";
+    ss << "(" << formatFloat(p.getX(), 6) << " " << formatFloat(p.getY(), 6)
+       << ")";
   }
   ss << ")";
   return ss.str();
@@ -954,10 +968,10 @@ inline std::string getWKT(const std::vector<Point<T>>& p) {
 template <typename T>
 inline std::string getWKT(const Line<T>& l) {
   std::stringstream ss;
-  ss << std::fixed << std::setprecision(6) << "LINESTRING (";
+  ss << "LINESTRING (";
   for (size_t i = 0; i < l.size(); i++) {
     if (i) ss << ", ";
-    ss << l[i].getX() << " " << l[i].getY();
+    ss << formatFloat(l[i].getX(), 6) << " " << formatFloat(l[i].getY(), 6);
   }
   ss << ")";
   return ss.str();
@@ -967,14 +981,15 @@ inline std::string getWKT(const Line<T>& l) {
 template <typename T>
 inline std::string getWKT(const std::vector<Line<T>>& ls) {
   std::stringstream ss;
-  ss << std::fixed << std::setprecision(6) << "MULTILINESTRING (";
+  ss << "MULTILINESTRING (";
 
   for (size_t j = 0; j < ls.size(); j++) {
     if (j) ss << ", ";
     ss << "(";
     for (size_t i = 0; i < ls[j].size(); i++) {
       if (i) ss << ", ";
-      ss << ls[j][i].getX() << " " << ls[j][i].getY();
+      ss << formatFloat(ls[j][i].getX(), 6) << " "
+         << formatFloat(ls[j][i].getY(), 6);
     }
     ss << ")";
   }
@@ -994,11 +1009,16 @@ template <typename T>
 inline std::string getWKT(const Box<T>& l) {
   std::stringstream ss;
   ss << "POLYGON ((";
-  ss << l.getLowerLeft().getX() << " " << l.getLowerLeft().getY();
-  ss << ", " << l.getUpperRight().getX() << " " << l.getLowerLeft().getY();
-  ss << ", " << l.getUpperRight().getX() << " " << l.getUpperRight().getY();
-  ss << ", " << l.getLowerLeft().getX() << " " << l.getUpperRight().getY();
-  ss << ", " << l.getLowerLeft().getX() << " " << l.getLowerLeft().getY();
+  ss << formatFloat(l.getLowerLeft().getX(), 6) << " "
+     << formatFloat(l.getLowerLeft().getY(), 6);
+  ss << ", " << formatFloat(l.getUpperRight().getX(), 6) << " "
+     << formatFloat(l.getLowerLeft().getY(), 6);
+  ss << ", " << formatFloat(l.getUpperRight().getX(), 6) << " "
+     << formatFloat(l.getUpperRight().getY(), 6);
+  ss << ", " << formatFloat(l.getLowerLeft().getX(), 6) << " "
+     << formatFloat(l.getUpperRight().getY(), 6);
+  ss << ", " << formatFloat(l.getLowerLeft().getX(), 6) << " "
+     << formatFloat(l.getLowerLeft().getY(), 6);
   ss << "))";
   return ss.str();
 }
@@ -1009,9 +1029,11 @@ inline std::string getWKT(const Polygon<T>& p) {
   std::stringstream ss;
   ss << "POLYGON ((";
   for (size_t i = 0; i < p.getOuter().size(); i++) {
-    ss << p.getOuter()[i].getX() << " " << p.getOuter()[i].getY() << ", ";
+    ss << formatFloat(p.getOuter()[i].getX(), 6) << " "
+       << formatFloat(p.getOuter()[i].getY(), 6) << ", ";
   }
-  ss << p.getOuter().front().getX() << " " << p.getOuter().front().getY();
+  ss << formatFloat(p.getOuter().front().getX(), 6) << " "
+     << formatFloat(p.getOuter().front().getY(), 6);
   ss << "))";
   return ss.str();
 }
@@ -1026,11 +1048,11 @@ inline std::string getWKT(const std::vector<Polygon<T>>& ls) {
     if (j) ss << ", ";
     ss << "((";
     for (size_t i = 0; i < ls[j].getOuter().size(); i++) {
-      ss << ls[j].getOuter()[i].getX() << " " << ls[j].getOuter()[i].getY()
-         << ", ";
+      ss << formatFloat(ls[j].getOuter()[i].getX(), 6) << " "
+         << formatFloat(ls[j].getOuter()[i].getY(), 6) << ", ";
     }
-    ss << ls[j].getOuter().front().getX() << " "
-       << ls[j].getOuter().front().getY();
+    ss << formatFloat(ls[j].getOuter().front().getX(), 6) << " "
+       << formatFloat(ls[j].getOuter().front().getY(), 6);
     ss << "))";
   }
 
@@ -1224,7 +1246,8 @@ inline double parallelity(const Box<T>& box, const MultiLine<T>& multiline) {
 
 // _____________________________________________________________________________
 template <template <typename> class Geometry, typename T>
-inline RotatedBox<T> getOrientedEnvelope(Geometry<T> pol) {
+inline RotatedBox<T> getOrientedEnvelope(std::vector<Geometry<T>> pol,
+                                         double step) {
   // TODO: implement this nicer, works for now, but inefficient
   // see
   // https://geidav.wordpress.com/tag/gift-wrapping/#fn-1057-FreemanShapira1975
@@ -1235,8 +1258,8 @@ inline RotatedBox<T> getOrientedEnvelope(Geometry<T> pol) {
   double rotateDeg = 0;
 
   // rotate in 1 deg steps
-  for (int i = 1; i < 360; i += 1) {
-    pol = rotate(pol, 1, center);
+  for (double i = step; i < 360; i += step) {
+    pol = rotate(pol, step, center);
     Box<T> e = getBoundingBox(pol);
     if (area(tmpBox) > area(e)) {
       tmpBox = e;
@@ -1247,6 +1270,50 @@ inline RotatedBox<T> getOrientedEnvelope(Geometry<T> pol) {
   return RotatedBox<T>(tmpBox, -rotateDeg, center);
 }
 
+// _____________________________________________________________________________
+template <template <typename> class Geometry, typename T>
+inline RotatedBox<T> getOrientedEnvelope(std::vector<Geometry<T>> pol) {
+  return getOrientedEnvelope(pol, 1);
+}
+
+// _____________________________________________________________________________
+template <template <typename> class Geometry, typename T>
+inline RotatedBox<T> getOrientedEnvelope(Geometry<T> pol, double step) {
+  std::vector<Geometry<T>> mult{pol};
+  return getOrientedEnvelope(mult, step);
+}
+
+// _____________________________________________________________________________
+template <template <typename> class Geometry, typename T>
+inline RotatedBox<T> getOrientedEnvelope(Geometry<T> pol) {
+  std::vector<Geometry<T>> mult{pol};
+  return getOrientedEnvelope(mult, 1);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline Polygon<T> buffer(const Line<T>& line, double d, size_t points) {
+  // so far only works correctly if the input polygon is convex
+  MultiPoint<T> pSet;
+  for (const auto& p : line) {
+    Point<T> anchor{p.getX() + d, p.getY()};
+    double deg = 0;
+    pSet.push_back(p);
+    for (size_t i = 0; i < points; i++) {
+      pSet.push_back(rotate(anchor, deg, p));
+      deg += 360 / (1.0 * points);
+    }
+  }
+
+  return convexHull(pSet);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline Polygon<T> buffer(const Polygon<T>& pol, double d, size_t points) {
+  return buffer(pol.getOuter(), d, points);
+}
+
 // _____________________________________________________________________________
 template <typename T>
 inline Box<T> extendBox(const Box<T>& a, Box<T> b) {
@@ -1799,7 +1866,6 @@ inline double haversine(const Point<T>& a, const Point<T>& b) {
   return haversine(a.getY(), a.getX(), b.getY(), b.getX());
 }
 
-
 // _____________________________________________________________________________
 template <typename T>
 inline Line<T> densify(const Line<T>& l, double d) {
@@ -1963,8 +2029,8 @@ inline double accFrechetDistCHav(const Line<T>& a, const Line<T>& b, double d) {
 
   for (size_t i = 1; i < p.size(); i++) {
     for (size_t j = 1; j < q.size(); j++) {
-      float d =
-          util::geo::haversine(p[i], q[j]) * util::geo::haversine(p[i], p[i - 1]);
+      float d = util::geo::haversine(p[i], q[j]) *
+                util::geo::haversine(p[i], p[i - 1]);
       ca[i * q.size() + j] =
           d + std::min(ca[(i - 1) * q.size() + j],
                        std::min(ca[i * q.size() + (j - 1)],
@@ -2042,7 +2108,6 @@ inline double latLngLen(const Line<T>& g) {
   return ret;
 }
 
-
 // _____________________________________________________________________________
 template <typename G>
 inline double webMercDistFactor(const G& a) {
diff --git a/src/util/geo/PolyLine.h b/src/util/geo/PolyLine.h
index 78c7928..75036e2 100644
--- a/src/util/geo/PolyLine.h
+++ b/src/util/geo/PolyLine.h
@@ -71,8 +71,6 @@ class PolyLine {
   double distTo(const PolyLine<T>& g) const;
   double distTo(const Point<T>& p) const;
 
-  SharedSegments<T> getSharedSegments(const PolyLine<T>& pl, double dmax) const;
-
   double getLength() const;
 
   // return point at dist
diff --git a/src/util/geo/PolyLine.tpp b/src/util/geo/PolyLine.tpp
index ee85584..1f5f6f8 100644
--- a/src/util/geo/PolyLine.tpp
+++ b/src/util/geo/PolyLine.tpp
@@ -188,9 +188,9 @@ PolyLine<T> PolyLine<T>::getSegment(const LinePoint<T>& start,
   ret << end.p;
 
   // find a more performant way to clear the result of above
-  // ret.simplify(0);
+  ret.simplify(0);
 
-  // assert(ret.getLine().size());
+  assert(ret.getLine().size());
 
   return ret;
 }
@@ -478,120 +478,6 @@ void PolyLine<T>::move(double vx, double vy) {
   }
 }
 
-// _____________________________________________________________________________
-template <typename T>
-SharedSegments<T> PolyLine<T>::getSharedSegments(const PolyLine<T>& pl,
-                                                 double dmax) const {
-  /**
-   * Returns the segments this polyline share with pl
-   * atm, this is a very simple distance-based algorithm
-   */
-  double STEP_SIZE = 2;
-  double MAX_SKIPS = 4;
-  double MIN_SEG_LENGTH = 0.1;  // dmax / 2;  // make this configurable!
-
-  SharedSegments<T> ret;
-
-  if (distTo(pl) > dmax) return ret;
-
-  bool in = false, single = true;
-  double curDist = 0;
-  double curTotalSegDist = 0;
-  size_t skips;
-
-  LinePoint<T> curStartCand, curEndCand, curStartCandCmp, curEndCandCmp;
-
-  double comp = 0, curSegDist = 0;
-  double length = getLength(), plLength = pl.getLength();
-
-  for (size_t i = 1; i < _line.size(); ++i) {
-    const Point<T>& s = _line[i - 1];
-    const Point<T>& e = _line[i];
-
-    bool lastRound = false;
-
-    double totalDist = dist(s, e);
-    while (curSegDist <= totalDist) {
-      const auto& curPointer = interpolate(s, e, curSegDist);
-
-      if (pl.distTo(curPointer) <= dmax) {
-        LinePoint<T> curCmpPointer = pl.projectOn(curPointer);
-        LinePoint<T> curBackProjectedPointer = projectOn(curCmpPointer.p);
-
-        skips = 0;
-
-        if (in) {
-          curEndCand = curBackProjectedPointer;
-          curEndCandCmp = curCmpPointer;
-
-          if (curEndCand.totalPos < curStartCand.totalPos) {
-            curEndCand = curStartCand;
-          }
-
-          single = false;
-
-          comp = fabs(curStartCand.totalPos * length -
-                      curEndCand.totalPos * length) /
-                 fabs(curStartCandCmp.totalPos * plLength -
-                      curEndCandCmp.totalPos * plLength);
-        } else {
-          in = true;
-          curStartCand = curBackProjectedPointer;
-          curStartCandCmp = curCmpPointer;
-        }
-      } else {
-        if (in) {
-          skips++;
-          if (skips > MAX_SKIPS) {  // TODO: make configurable
-            if (comp > 0.8 && comp < 1.2 && !single &&
-                (fabs(curStartCand.totalPos * length -
-                      curEndCand.totalPos * length) > MIN_SEG_LENGTH &&
-                 fabs(curStartCandCmp.totalPos * plLength -
-                      curEndCandCmp.totalPos * plLength) > MIN_SEG_LENGTH)) {
-              ret.segments.push_back(
-                  SharedSegment<T>(std::pair<LinePoint<T>, LinePoint<T>>(
-                                       curStartCand, curStartCandCmp),
-                                   std::pair<LinePoint<T>, LinePoint<T>>(
-                                       curEndCand, curEndCandCmp)));
-
-              // TODO: only return the FIRST one, make this configuralbe
-              return ret;
-            }
-
-            in = false;
-            single = true;
-          }
-        }
-      }
-
-      if (curSegDist + STEP_SIZE > totalDist && !lastRound) {
-        lastRound = true;
-        double finalStep = totalDist - curSegDist - 0.0005;
-        curSegDist += finalStep;
-        curDist += finalStep;
-      } else {
-        curSegDist += STEP_SIZE;
-        curDist += STEP_SIZE;
-      }
-    }
-
-    curSegDist = curSegDist - totalDist;
-    curTotalSegDist += totalDist;
-  }
-
-  if (comp > 0.8 && comp < 1.2 && in && !single &&
-      (fabs(curStartCand.totalPos * length - curEndCand.totalPos * length) >
-           MIN_SEG_LENGTH &&
-       fabs(curStartCandCmp.totalPos * plLength -
-            curEndCandCmp.totalPos * plLength) > MIN_SEG_LENGTH)) {
-    ret.segments.push_back(SharedSegment<T>(
-        std::pair<LinePoint<T>, LinePoint<T>>(curStartCand, curStartCandCmp),
-        std::pair<LinePoint<T>, LinePoint<T>>(curEndCand, curEndCandCmp)));
-  }
-
-  return ret;
-}
-
 // _____________________________________________________________________________
 template <typename T>
 std::set<LinePoint<T>, LinePointCmp<T>> PolyLine<T>::getIntersections(
diff --git a/src/util/graph/DirGraph.h b/src/util/graph/DirGraph.h
index 895b3d7..38877e3 100644
--- a/src/util/graph/DirGraph.h
+++ b/src/util/graph/DirGraph.h
@@ -28,7 +28,7 @@ class DirGraph : public Graph<N, E> {
   Node<N, E>* addNd(const N& pl);
   Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p);
 
-  Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
+  virtual Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
 
 };
 
diff --git a/src/util/graph/EDijkstra.h b/src/util/graph/EDijkstra.h
index 72c2619..a659a19 100644
--- a/src/util/graph/EDijkstra.h
+++ b/src/util/graph/EDijkstra.h
@@ -114,16 +114,18 @@ class EDijkstra : public ShortestPath<EDijkstra> {
   using SettledInit = tsl::robin_map<Edge<N, E>*, RouteEdgeInit<N, E, C>>;
 
   template <typename N, typename E, typename C>
-  using SettledInitNoRes = tsl::robin_map<Edge<N, E>*, RouteEdgeInitNoRes<N, E, C>>;
+  using SettledInitNoRes =
+      tsl::robin_map<Edge<N, E>*, RouteEdgeInitNoRes<N, E, C>>;
 
   template <typename N, typename E, typename C>
   using PQInit = radix_heap::pair_radix_heap<C, RouteEdgeInit<N, E, C>>;
 
   template <typename N, typename E, typename C>
-  using PQInitNoRes = radix_heap::pair_radix_heap<C, RouteEdgeInitNoRes<N, E, C>>;
+  using PQInitNoRes =
+      radix_heap::pair_radix_heap<C, RouteEdgeInitNoRes<N, E, C>>;
 
   template <typename N, typename E, typename C>
-  static C shortestPathImpl(const std::set<Edge<N, E>*> from,
+  static C shortestPathImpl(const std::set<Edge<N, E>*>& from,
                             const std::set<Edge<N, E>*>& to,
                             const util::graph::CostFunc<N, E, C>& costFunc,
                             const util::graph::HeurFunc<N, E, C>& heurFunc,
@@ -148,6 +150,13 @@ class EDijkstra : public ShortestPath<EDijkstra> {
                             const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(const std::set<Node<N, E>*>& from,
+                            const std::set<Node<N, E>*>& to,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
       const std::set<Edge<N, E>*>& from,
@@ -161,6 +170,15 @@ class EDijkstra : public ShortestPath<EDijkstra> {
       std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
       std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes);
 
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
+      const std::set<Edge<N, E>*>& from, const std::set<Edge<N, E>*>& to,
+      const std::unordered_map<Edge<N, E>*, C>& initCosts,
+      const util::graph::CostFunc<N, E, C>& costFunc,
+      const util::graph::HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes);
+
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
       const std::set<Edge<N, E>*>& from, const std::set<Edge<N, E>*>& to,
@@ -202,11 +220,10 @@ class EDijkstra : public ShortestPath<EDijkstra> {
                                PQInit<N, E, C>& pq);
 
   template <typename N, typename E, typename C>
-  static inline void relaxInitNoResEdgs(RouteEdgeInitNoRes<N, E, C>& cur,
-                               const std::set<Edge<N, E>*>& to, C stall,
-                               const util::graph::CostFunc<N, E, C>& costFunc,
-                               const util::graph::HeurFunc<N, E, C>& heurFunc,
-                               PQInitNoRes<N, E, C>& pq);
+  static inline void relaxInitNoResEdgs(
+      RouteEdgeInitNoRes<N, E, C>& cur, const std::set<Edge<N, E>*>& to,
+      C stall, const util::graph::CostFunc<N, E, C>& costFunc,
+      const util::graph::HeurFunc<N, E, C>& heurFunc, PQInitNoRes<N, E, C>& pq);
 
   template <typename N, typename E, typename C>
   static void relaxInv(RouteEdge<N, E, C>& cur,
diff --git a/src/util/graph/EDijkstra.tpp b/src/util/graph/EDijkstra.tpp
index fa1df51..0c98939 100644
--- a/src/util/graph/EDijkstra.tpp
+++ b/src/util/graph/EDijkstra.tpp
@@ -47,7 +47,30 @@ C EDijkstra::shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
 
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
-C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*> from,
+C EDijkstra::shortestPathImpl(const std::set<Node<N, E>*>& from,
+                              const std::set<Node<N, E>*>& to,
+                              const util::graph::CostFunc<N, E, C>& costFunc,
+                              const util::graph::HeurFunc<N, E, C>& heurFunc,
+                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  std::set<Edge<N, E>*> frEs;
+  std::set<Edge<N, E>*> toEs;
+
+  for (auto n : from) {
+    frEs.insert(n->getAdjListIn().begin(), n->getAdjListIn().end());
+  }
+
+  for (auto n : to) {
+    toEs.insert(n->getAdjListIn().begin(), n->getAdjListIn().end());
+  }
+
+  C cost = shortestPathImpl(frEs, toEs, costFunc, heurFunc, resEdges, resNodes);
+
+  return cost;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*>& from,
                               const std::set<Edge<N, E>*>& to,
                               const util::graph::CostFunc<N, E, C>& costFunc,
                               const util::graph::HeurFunc<N, E, C>& heurFunc,
diff --git a/src/util/graph/Graph.h b/src/util/graph/Graph.h
index 3c97832..d1db62f 100644
--- a/src/util/graph/Graph.h
+++ b/src/util/graph/Graph.h
@@ -5,10 +5,10 @@
 #ifndef UTIL_GRAPH_GRAPH_H_
 #define UTIL_GRAPH_GRAPH_H_
 
+#include <cassert>
+#include <iostream>
 #include <set>
 #include <string>
-#include <iostream>
-#include <cassert>
 
 #include "util/graph/Edge.h"
 #include "util/graph/Node.h"
@@ -25,7 +25,7 @@ class Graph {
   Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to);
   virtual Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p) = 0;
   Edge<N, E>* getEdg(Node<N, E>* from, Node<N, E>* to);
-  const Edge<N, E>* getEdg(Node<N, E>* from, Node<N, E>* to) const;
+  const Edge<N, E>* getEdg(const Node<N, E>* from, const Node<N, E>* to) const;
 
   virtual Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b) = 0;
 
@@ -39,11 +39,11 @@ class Graph {
   void delEdg(Node<N, E>* from, Node<N, E>* to);
 
  protected:
-   std::set<Node<N, E>*> _nodes;
+  std::set<Node<N, E>*> _nodes;
 };
 
 #include "util/graph/Graph.tpp"
-}
-}
+}  // namespace graph
+}  // namespace util
 
 #endif  // UTIL_GRAPH_GRAPH_H_
diff --git a/src/util/graph/Graph.tpp b/src/util/graph/Graph.tpp
index 00b9dd5..e65fb61 100644
--- a/src/util/graph/Graph.tpp
+++ b/src/util/graph/Graph.tpp
@@ -22,8 +22,7 @@ const std::set<Node<N, E>*>& Graph<N, E>::getNds() const {
 
 // _____________________________________________________________________________
 template <typename N, typename E>
-typename std::set<Node<N, E>*>::iterator Graph<N, E>::delNd(
-    Node<N, E>* n) {
+typename std::set<Node<N, E>*>::iterator Graph<N, E>::delNd(Node<N, E>* n) {
   return delNd(_nodes.find(n));
 }
 
@@ -69,10 +68,10 @@ Node<N, E>* Graph<N, E>::sharedNode(const Edge<N, E>* a, const Edge<N, E>* b) {
   return r;
 }
 
-
 // _____________________________________________________________________________
 template <typename N, typename E>
-const Edge<N, E>* Graph<N, E>::getEdg(Node<N, E>* from, Node<N, E>* to) const {
+const Edge<N, E>* Graph<N, E>::getEdg(const Node<N, E>* from,
+                                      const Node<N, E>* to) const {
   for (auto e : from->getAdjList()) {
     if (e->getOtherNd(from) == to) return e;
   }
diff --git a/src/util/graph/ShortestPath.h b/src/util/graph/ShortestPath.h
index 99a7e81..5779e77 100644
--- a/src/util/graph/ShortestPath.h
+++ b/src/util/graph/ShortestPath.h
@@ -79,6 +79,16 @@ class ShortestPath {
                                resNodes);
   }
 
+  template <typename N, typename E, typename C>
+  static C shortestPath(const std::set<Node<N, E>*>& from,
+                        const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc) {
+    EList<N, E>* el = 0;
+    NList<N, E>* nl = 0;
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               el, nl);
+  }
+
   template <typename N, typename E, typename C>
   static C shortestPath(const std::set<Node<N, E>*> from,
                         const std::set<Node<N, E>*>& to,
diff --git a/src/util/graph/UndirGraph.h b/src/util/graph/UndirGraph.h
index 127f35a..028126e 100644
--- a/src/util/graph/UndirGraph.h
+++ b/src/util/graph/UndirGraph.h
@@ -30,7 +30,7 @@ class UndirGraph : public Graph<N, E> {
   Node<N, E>* addNd(const N& pl);
   Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p);
 
-  Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
+  virtual Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
 
 };
 
diff --git a/src/util/graph/UndirGraph.tpp b/src/util/graph/UndirGraph.tpp
index cb5a3c2..5f2076e 100644
--- a/src/util/graph/UndirGraph.tpp
+++ b/src/util/graph/UndirGraph.tpp
@@ -42,12 +42,14 @@ Edge<N, E>* UndirGraph<N, E>::addEdg(Node<N, E>* from, Node<N, E>* to,
 template <typename N, typename E>
 Node<N, E>* UndirGraph<N, E>::mergeNds(Node<N, E>* a, Node<N, E>* b) {
   for (auto e : a->getAdjListOut()) {
+    if (e->getFrom() != a) continue;
     if (e->getTo() != b) {
       addEdg(b, e->getTo(), e->pl());
     }
   }
 
   for (auto e : a->getAdjListIn()) {
+    if (e->getTo() != a) continue;
     if (e->getFrom() != b) {
       addEdg(e->getFrom(), b, e->pl());
     }
diff --git a/src/util/graph/radix_heap.h b/src/util/graph/radix_heap.h
index cb0eef7..1c8416a 100644
--- a/src/util/graph/radix_heap.h
+++ b/src/util/graph/radix_heap.h
@@ -128,7 +128,7 @@ class pair_radix_heap {
   void push(key_type key, const value_type &value) {
     unsigned_key_type x = encoder_type::encode(key);
     if (last_ > x) {
-      std::cerr << "Not monotone: " << last_ << " vs " << x << std::endl;
+      std::cerr << "PQ: not monotone: " << last_ << " vs " << x << std::endl;
       x = last_;
     }
     ++size_;
@@ -140,7 +140,7 @@ class pair_radix_heap {
   void push(key_type key, value_type &&value) {
     unsigned_key_type x = encoder_type::encode(key);
     if (last_ > x) {
-      std::cerr << "Not monotone: " << last_ << " vs " << x << std::endl;
+      std::cerr << "PQ: not monotone: " << last_ << " vs " << x << std::endl;
       x = last_;
     }
     ++size_;
diff --git a/src/util/json/Writer.h b/src/util/json/Writer.h
index 0a25be0..72958fe 100644
--- a/src/util/json/Writer.h
+++ b/src/util/json/Writer.h
@@ -30,9 +30,9 @@ struct Null {};
 struct Val {
   enum VAL_T { UINT, INT, FLOAT, STRING, ARRAY, DICT, BOOL, JSNULL };
   VAL_T type;
-  int i;
-  uint64_t ui;
-  double f;
+  int i = 0;
+  uint64_t ui = 0;
+  double f = 0;
   std::string str;
   std::vector<Val> arr;
   std::map<std::string, Val> dict;
diff --git a/src/util/tests/TestMain.cpp b/src/util/tests/TestMain.cpp
index 97cfb1c..31d7cf1 100644
--- a/src/util/tests/TestMain.cpp
+++ b/src/util/tests/TestMain.cpp
@@ -1843,7 +1843,6 @@ int main(int argc, char** argv) {
   TEST(geo::getWKT(geo::segment(DLine{{0, 0}, {0, 1}, {0, 2}}, 0.5, 1)), ==, "LINESTRING (0 1, 0 2)");
 }
 
-
   // inversion count
   std::vector<int> test = {2, 1};
   TEST(inversions(test), ==, 1);
@@ -1880,4 +1879,13 @@ int main(int argc, char** argv) {
 
   test = {9, 8, 7, 6, 5, 4, 3, 2, 1};
   TEST(inversions(test), ==, 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1);
+
+  // nice float formatting
+	TEST(formatFloat(15.564, 3), ==, "15.564");
+	TEST(formatFloat(15.564, 0), ==, "16");
+	TEST(formatFloat(15.0000, 10), ==, "15");
+	TEST(formatFloat(15.0100, 10), ==, "15.01");
+	TEST(formatFloat(0.0000, 10), ==, "0");
+	TEST(formatFloat(-1.0000, 10), ==, "-1");
+	TEST(formatFloat(-15.000001, 10), ==, "-15.000001");
 }
diff --git a/src/util/tests/lest.h b/src/util/tests/lest.h
deleted file mode 100644
index f3c9f49..0000000
--- a/src/util/tests/lest.h
+++ /dev/null
@@ -1,1483 +0,0 @@
-// Copyright 2013-2018 by Martin Moene
-//
-// lest is based on ideas by Kevlin Henney, see video at
-// http://skillsmatter.com/podcast/agile-testing/kevlin-henney-rethinking-unit-testing-in-c-plus-plus
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef LEST_LEST_HPP_INCLUDED
-#define LEST_LEST_HPP_INCLUDED
-
-#include <algorithm>
-#include <chrono>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <random>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <set>
-#include <tuple>
-#include <typeinfo>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include <cctype>
-#include <cmath>
-#include <cstddef>
-
-#define lest_MAJOR  1
-#define lest_MINOR  35
-#define lest_PATCH  1
-
-#define  lest_VERSION  lest_STRINGIFY(lest_MAJOR) "." lest_STRINGIFY(lest_MINOR) "." lest_STRINGIFY(lest_PATCH)
-
-#ifndef  lest_FEATURE_AUTO_REGISTER
-# define lest_FEATURE_AUTO_REGISTER  0
-#endif
-
-#ifndef  lest_FEATURE_COLOURISE
-# define lest_FEATURE_COLOURISE  0
-#endif
-
-#ifndef  lest_FEATURE_LITERAL_SUFFIX
-# define lest_FEATURE_LITERAL_SUFFIX  0
-#endif
-
-#ifndef  lest_FEATURE_REGEX_SEARCH
-# define lest_FEATURE_REGEX_SEARCH  0
-#endif
-
-#ifndef  lest_FEATURE_TIME_PRECISION
-# define lest_FEATURE_TIME_PRECISION  0
-#endif
-
-#ifndef  lest_FEATURE_WSTRING
-# define lest_FEATURE_WSTRING  1
-#endif
-
-#ifdef    lest_FEATURE_RTTI
-# define  lest__cpp_rtti  lest_FEATURE_RTTI
-#elif defined(__cpp_rtti)
-# define  lest__cpp_rtti  __cpp_rtti
-#elif defined(__GXX_RTTI) || defined (_CPPRTTI)
-# define  lest__cpp_rtti  1
-#else
-# define  lest__cpp_rtti  0
-#endif
-
-#if lest_FEATURE_REGEX_SEARCH
-# include <regex>
-#endif
-
-// Stringify:
-
-#define lest_STRINGIFY(  x )  lest_STRINGIFY_( x )
-#define lest_STRINGIFY_( x )  #x
-
-// Compiler warning suppression:
-
-#if defined (__clang__)
-# pragma clang diagnostic ignored "-Waggregate-return"
-# pragma clang diagnostic ignored "-Woverloaded-shift-op-parentheses"
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wunused-comparison"
-#elif defined (__GNUC__)
-# pragma GCC   diagnostic ignored "-Waggregate-return"
-# pragma GCC   diagnostic push
-#endif
-
-// Suppress shadow and unused-value warning for sections:
-
-#if defined (__clang__)
-# define lest_SUPPRESS_WSHADOW    _Pragma( "clang diagnostic push" ) \
-                                  _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
-# define lest_SUPPRESS_WUNUSED    _Pragma( "clang diagnostic push" ) \
-                                  _Pragma( "clang diagnostic ignored \"-Wunused-value\"" )
-# define lest_RESTORE_WARNINGS    _Pragma( "clang diagnostic pop"  )
-
-#elif defined (__GNUC__)
-# define lest_SUPPRESS_WSHADOW    _Pragma( "GCC diagnostic push" ) \
-                                  _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
-# define lest_SUPPRESS_WUNUSED    _Pragma( "GCC diagnostic push" ) \
-                                  _Pragma( "GCC diagnostic ignored \"-Wunused-value\"" )
-# define lest_RESTORE_WARNINGS    _Pragma( "GCC diagnostic pop"  )
-#else
-# define lest_SUPPRESS_WSHADOW    /*empty*/
-# define lest_SUPPRESS_WUNUSED    /*empty*/
-# define lest_RESTORE_WARNINGS    /*empty*/
-#endif
-
-// C++ language version detection (C++20 is speculative):
-// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
-
-#ifndef   lest_CPLUSPLUS
-# if defined(_MSVC_LANG ) && !defined(__clang__)
-#  define lest_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
-# else
-#  define lest_CPLUSPLUS  __cplusplus
-# endif
-#endif
-
-#define lest_CPP98_OR_GREATER  ( lest_CPLUSPLUS >= 199711L )
-#define lest_CPP11_OR_GREATER  ( lest_CPLUSPLUS >= 201103L )
-#define lest_CPP14_OR_GREATER  ( lest_CPLUSPLUS >= 201402L )
-#define lest_CPP17_OR_GREATER  ( lest_CPLUSPLUS >= 201703L )
-#define lest_CPP20_OR_GREATER  ( lest_CPLUSPLUS >= 202000L )
-
-#if ! defined( lest_NO_SHORT_MACRO_NAMES ) && ! defined( lest_NO_SHORT_ASSERTION_NAMES )
-# define MODULE            lest_MODULE
-
-# if ! lest_FEATURE_AUTO_REGISTER
-#  define CASE             lest_CASE
-#  define CASE_ON          lest_CASE_ON
-#  define SCENARIO         lest_SCENARIO
-# endif
-
-# define SETUP             lest_SETUP
-# define SECTION           lest_SECTION
-
-# define EXPECT            lest_EXPECT
-# define EXPECT_NOT        lest_EXPECT_NOT
-# define EXPECT_NO_THROW   lest_EXPECT_NO_THROW
-# define EXPECT_THROWS     lest_EXPECT_THROWS
-# define EXPECT_THROWS_AS  lest_EXPECT_THROWS_AS
-
-# define GIVEN             lest_GIVEN
-# define WHEN              lest_WHEN
-# define THEN              lest_THEN
-# define AND_WHEN          lest_AND_WHEN
-# define AND_THEN          lest_AND_THEN
-#endif
-
-#if lest_FEATURE_AUTO_REGISTER
-#define lest_SCENARIO( specification, sketch )  lest_CASE( specification, lest::text("Scenario: ") + sketch  )
-#else
-#define lest_SCENARIO( sketch  )  lest_CASE(    lest::text("Scenario: ") + sketch  )
-#endif
-#define lest_GIVEN(    context )  lest_SETUP(   lest::text("   Given: ") + context )
-#define lest_WHEN(     story   )  lest_SECTION( lest::text("    When: ") + story   )
-#define lest_THEN(     story   )  lest_SECTION( lest::text("    Then: ") + story   )
-#define lest_AND_WHEN( story   )  lest_SECTION( lest::text("And then: ") + story   )
-#define lest_AND_THEN( story   )  lest_SECTION( lest::text("And then: ") + story   )
-
-#if lest_FEATURE_AUTO_REGISTER
-
-# define lest_CASE( specification, proposition ) \
-    static void lest_FUNCTION( lest::env & ); \
-    namespace { lest::add_test lest_REGISTRAR( specification, lest::test( proposition, lest_FUNCTION ) ); } \
-    static void lest_FUNCTION( lest::env & lest_env )
-
-#else // lest_FEATURE_AUTO_REGISTER
-
-# define lest_CASE( proposition ) \
-    proposition, []( lest::env & lest_env )
-
-# define lest_CASE_ON( proposition, ... ) \
-    proposition, [__VA_ARGS__]( lest::env & lest_env )
-
-# define lest_MODULE( specification, module ) \
-    namespace { lest::add_module _( specification, module ); }
-
-#endif //lest_FEATURE_AUTO_REGISTER
-
-#define lest_SETUP( context ) \
-    for ( int lest__section = 0, lest__count = 1; lest__section < lest__count; lest__count -= 0==lest__section++ ) \
-       for ( lest::ctx lest__ctx_setup( lest_env, context ); lest__ctx_setup; )
-
-#define lest_SECTION( proposition ) \
-    lest_SUPPRESS_WSHADOW \
-    static int lest_UNIQUE( id ) = 0; \
-    if ( lest::guard( lest_UNIQUE( id ), lest__section, lest__count ) ) \
-        for ( int lest__section = 0, lest__count = 1; lest__section < lest__count; lest__count -= 0==lest__section++ ) \
-            for ( lest::ctx lest__ctx_section( lest_env, proposition ); lest__ctx_section; ) \
-    lest_RESTORE_WARNINGS
-
-#define lest_EXPECT( expr ) \
-    do { \
-        try \
-        { \
-            if ( lest::result score = lest_DECOMPOSE( expr ) ) \
-                throw lest::failure{ lest_LOCATION, #expr, score.decomposition }; \
-            else if ( lest_env.pass() ) \
-                lest::report( lest_env.os, lest::passing{ lest_LOCATION, #expr, score.decomposition, lest_env.zen() }, lest_env.context() ); \
-        } \
-        catch(...) \
-        { \
-            lest::inform( lest_LOCATION, #expr ); \
-        } \
-    } while ( lest::is_false() )
-
-#define lest_EXPECT_NOT( expr ) \
-    do { \
-        try \
-        { \
-            if ( lest::result score = lest_DECOMPOSE( expr ) ) \
-            { \
-                if ( lest_env.pass() ) \
-                    lest::report( lest_env.os, lest::passing{ lest_LOCATION, lest::not_expr( #expr ), lest::not_expr( score.decomposition ), lest_env.zen() }, lest_env.context() ); \
-            } \
-            else \
-                throw lest::failure{ lest_LOCATION, lest::not_expr( #expr ), lest::not_expr( score.decomposition ) }; \
-        } \
-        catch(...) \
-        { \
-            lest::inform( lest_LOCATION, lest::not_expr( #expr ) ); \
-        } \
-    } while ( lest::is_false() )
-
-#define lest_EXPECT_NO_THROW( expr ) \
-    do \
-    { \
-        try \
-        { \
-            lest_SUPPRESS_WUNUSED \
-            expr; \
-            lest_RESTORE_WARNINGS \
-        } \
-        catch (...) \
-        { \
-            lest::inform( lest_LOCATION, #expr ); \
-        } \
-        if ( lest_env.pass() ) \
-            lest::report( lest_env.os, lest::got_none( lest_LOCATION, #expr ), lest_env.context() ); \
-    } while ( lest::is_false() )
-
-#define lest_EXPECT_THROWS( expr ) \
-    do \
-    { \
-        try \
-        { \
-            lest_SUPPRESS_WUNUSED \
-            expr; \
-            lest_RESTORE_WARNINGS \
-        } \
-        catch (...) \
-        { \
-            if ( lest_env.pass() ) \
-                lest::report( lest_env.os, lest::got{ lest_LOCATION, #expr }, lest_env.context() ); \
-            break; \
-        } \
-        throw lest::expected{ lest_LOCATION, #expr }; \
-    } \
-    while ( lest::is_false() )
-
-#define lest_EXPECT_THROWS_AS( expr, excpt ) \
-    do \
-    { \
-        try \
-        { \
-            lest_SUPPRESS_WUNUSED \
-            expr; \
-            lest_RESTORE_WARNINGS \
-        }  \
-        catch ( excpt & ) \
-        { \
-            if ( lest_env.pass() ) \
-                lest::report( lest_env.os, lest::got{ lest_LOCATION, #expr, lest::of_type( #excpt ) }, lest_env.context() ); \
-            break; \
-        } \
-        catch (...) {} \
-        throw lest::expected{ lest_LOCATION, #expr, lest::of_type( #excpt ) }; \
-    } \
-    while ( lest::is_false() )
-
-#define lest_UNIQUE(  name       ) lest_UNIQUE2( name, __LINE__ )
-#define lest_UNIQUE2( name, line ) lest_UNIQUE3( name, line )
-#define lest_UNIQUE3( name, line ) name ## line
-
-#define lest_DECOMPOSE( expr ) ( lest::expression_decomposer() << expr )
-
-#define lest_FUNCTION  lest_UNIQUE(__lest_function__  )
-#define lest_REGISTRAR lest_UNIQUE(__lest_registrar__ )
-
-#define lest_LOCATION  lest::location{__FILE__, __LINE__}
-
-namespace lest {
-
-const int exit_max_value = 255;
-
-using text  = std::string;
-using texts = std::vector<text>;
-
-struct env;
-
-struct test
-{
-    text name;
-    std::function<void( env & )> behaviour;
-
-#if lest_FEATURE_AUTO_REGISTER
-    test( text name_, std::function<void( env & )> behaviour_ )
-    : name( name_), behaviour( behaviour_) {}
-#endif
-};
-
-using tests = std::vector<test>;
-
-#if lest_FEATURE_AUTO_REGISTER
-
-struct add_test
-{
-    add_test( tests & specification, test const & test_case )
-    {
-        specification.push_back( test_case );
-    }
-};
-
-#else
-
-struct add_module
-{
-    template< std::size_t N >
-    add_module( tests & specification, test const (&module)[N] )
-    {
-        specification.insert( specification.end(), std::begin( module ), std::end( module ) );
-    }
-};
-
-#endif
-
-struct result
-{
-    const bool passed;
-    const text decomposition;
-
-    template< typename T >
-    result( T const & passed_, text decomposition_)
-    : passed( !!passed_), decomposition( decomposition_) {}
-
-    explicit operator bool() { return ! passed; }
-};
-
-struct location
-{
-    const text file;
-    const int line;
-
-    location( text file_, int line_)
-    : file( file_), line( line_) {}
-};
-
-struct comment
-{
-    const text info;
-
-    comment( text info_) : info( info_) {}
-    explicit operator bool() { return ! info.empty(); }
-};
-
-struct message : std::runtime_error
-{
-    const text kind;
-    const location where;
-    const comment note;
-
-    ~message() throw() {}   // GCC 4.6
-
-    message( text kind_, location where_, text expr_, text note_ = "" )
-    : std::runtime_error( expr_), kind( kind_), where( where_), note( note_) {}
-};
-
-struct failure : message
-{
-    failure( location where_, text expr_, text decomposition_)
-    : message{ "failed", where_, expr_ + " for " + decomposition_ } {}
-};
-
-struct success : message
-{
-//    using message::message;   // VC is lagging here
-
-    success( text kind_, location where_, text expr_, text note_ = "" )
-    : message( kind_, where_, expr_, note_ ) {}
-};
-
-struct passing : success
-{
-    passing( location where_, text expr_, text decomposition_, bool zen )
-    : success( "passed", where_, expr_ + (zen ? "":" for " + decomposition_) ) {}
-};
-
-struct got_none : success
-{
-    got_none( location where_, text expr_ )
-    : success( "passed: got no exception", where_, expr_ ) {}
-};
-
-struct got : success
-{
-    got( location where_, text expr_)
-    : success( "passed: got exception", where_, expr_) {}
-
-    got( location where_, text expr_, text excpt_)
-    : success( "passed: got exception " + excpt_, where_, expr_) {}
-};
-
-struct expected : message
-{
-    expected( location where_, text expr_, text excpt_ = "" )
-    : message{ "failed: didn't get exception", where_, expr_, excpt_ } {}
-};
-
-struct unexpected : message
-{
-    unexpected( location where_, text expr_, text note_ = "" )
-    : message{ "failed: got unexpected exception", where_, expr_, note_ } {}
-};
-
-struct guard
-{
-    int & id;
-    int const & section;
-
-    guard( int & id_, int const & section_, int & count )
-    : id( id_), section( section_)
-    {
-        if ( section == 0 )
-            id = count++ - 1;
-    }
-    operator bool() { return id == section; }
-};
-
-class approx
-{
-public:
-    explicit approx ( double magnitude )
-    : epsilon_  { std::numeric_limits<float>::epsilon() * 100 }
-    , scale_    { 1.0 }
-    , magnitude_{ magnitude } {}
-
-    approx( approx const & other ) = default;
-
-    static approx custom() { return approx( 0 ); }
-
-    approx operator()( double new_magnitude )
-    {
-        approx appr( new_magnitude );
-        appr.epsilon( epsilon_ );
-        appr.scale  ( scale_   );
-        return appr;
-    }
-
-    double magnitude() const { return magnitude_; }
-
-    approx & epsilon( double epsilon ) { epsilon_ = epsilon; return *this; }
-    approx & scale  ( double scale   ) { scale_   = scale;   return *this; }
-
-    friend bool operator == ( double lhs, approx const & rhs )
-    {
-        // Thanks to Richard Harris for his help refining this formula.
-        return std::abs( lhs - rhs.magnitude_ ) < rhs.epsilon_ * ( rhs.scale_ + (std::min)( std::abs( lhs ), std::abs( rhs.magnitude_ ) ) );
-    }
-
-    friend bool operator == ( approx const & lhs, double rhs ) { return  operator==( rhs, lhs ); }
-    friend bool operator != ( double lhs, approx const & rhs ) { return !operator==( lhs, rhs ); }
-    friend bool operator != ( approx const & lhs, double rhs ) { return !operator==( rhs, lhs ); }
-
-    friend bool operator <= ( double lhs, approx const & rhs ) { return lhs < rhs.magnitude_ || lhs == rhs; }
-    friend bool operator <= ( approx const & lhs, double rhs ) { return lhs.magnitude_ < rhs || lhs == rhs; }
-    friend bool operator >= ( double lhs, approx const & rhs ) { return lhs > rhs.magnitude_ || lhs == rhs; }
-    friend bool operator >= ( approx const & lhs, double rhs ) { return lhs.magnitude_ > rhs || lhs == rhs; }
-
-private:
-    double epsilon_;
-    double scale_;
-    double magnitude_;
-};
-
-inline bool is_false(           ) { return false; }
-inline bool is_true ( bool flag ) { return  flag; }
-
-inline text not_expr( text message )
-{
-    return "! ( " + message + " )";
-}
-
-inline text with_message( text message )
-{
-    return "with message \"" + message + "\"";
-}
-
-inline text of_type( text type )
-{
-    return "of type " + type;
-}
-
-inline void inform( location where, text expr )
-{
-    try
-    {
-        throw;
-    }
-    catch( message const & )
-    {
-        throw;
-    }
-    catch( std::exception const & e )
-    {
-        throw unexpected{ where, expr, with_message( e.what() ) }; \
-    }
-    catch(...)
-    {
-        throw unexpected{ where, expr, "of unknown type" }; \
-    }
-}
-
-// Expression decomposition:
-
-template< typename T >
-auto make_value_string( T const & value ) -> std::string;
-
-template< typename T >
-auto make_memory_string( T const & item ) -> std::string;
-
-#if lest_FEATURE_LITERAL_SUFFIX
-inline char const * sfx( char const  * txt ) { return txt; }
-#else
-inline char const * sfx( char const  *      ) { return ""; }
-#endif
-
-inline std::string transformed( char chr )
-{
-    struct Tr { char chr; char const * str; } table[] =
-    {
-        {'\\', "\\\\" },
-        {'\r', "\\r"  }, {'\f', "\\f" },
-        {'\n', "\\n"  }, {'\t', "\\t" },
-    };
-
-    for ( auto tr : table )
-    {
-        if ( chr == tr.chr )
-            return tr.str;
-    }
-
-    auto unprintable = [](char c){ return 0 <= c && c < ' '; };
-
-    auto to_hex_string = [](char c)
-    {
-        std::ostringstream os;
-        os << "\\x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>( static_cast<unsigned char>(c) );
-        return os.str();
-    };
-
-    return unprintable( chr  ) ? to_hex_string( chr ) : std::string( 1, chr );
-}
-
-inline std::string make_tran_string( std::string const & txt ) { std::ostringstream os; for(auto c:txt) os << transformed(c); return os.str(); }
-inline std::string make_strg_string( std::string const & txt ) { return "\"" + make_tran_string(                 txt   ) + "\"" ; }
-inline std::string make_char_string(                char chr ) { return "\'" + make_tran_string( std::string( 1, chr ) ) + "\'" ; }
-
-inline std::string to_string( std::nullptr_t              ) { return "nullptr"; }
-inline std::string to_string( std::string     const & txt ) { return make_strg_string( txt ); }
-#if lest_FEATURE_WSTRING
-inline std::string to_string( std::wstring    const & txt ) ;
-#endif
-
-inline std::string to_string( char    const * const   txt ) { return txt ? make_strg_string( txt ) : "{null string}"; }
-inline std::string to_string( char          * const   txt ) { return txt ? make_strg_string( txt ) : "{null string}"; }
-#if lest_FEATURE_WSTRING
-inline std::string to_string( wchar_t const * const   txt ) { return txt ? to_string( std::wstring( txt ) ) : "{null string}"; }
-inline std::string to_string( wchar_t       * const   txt ) { return txt ? to_string( std::wstring( txt ) ) : "{null string}"; }
-#endif
-
-inline std::string to_string(          bool          flag ) { return flag ? "true" : "false"; }
-
-inline std::string to_string(   signed short        value ) { return make_value_string( value ) ;             }
-inline std::string to_string( unsigned short        value ) { return make_value_string( value ) + sfx("u"  ); }
-inline std::string to_string(   signed   int        value ) { return make_value_string( value ) ;             }
-inline std::string to_string( unsigned   int        value ) { return make_value_string( value ) + sfx("u"  ); }
-inline std::string to_string(   signed  long        value ) { return make_value_string( value ) + sfx("l"  ); }
-inline std::string to_string( unsigned  long        value ) { return make_value_string( value ) + sfx("ul" ); }
-inline std::string to_string(   signed  long long   value ) { return make_value_string( value ) + sfx("ll" ); }
-inline std::string to_string( unsigned  long long   value ) { return make_value_string( value ) + sfx("ull"); }
-inline std::string to_string(         double        value ) { return make_value_string( value ) ;             }
-inline std::string to_string(          float        value ) { return make_value_string( value ) + sfx("f"  ); }
-
-inline std::string to_string(   signed char           chr ) { return make_char_string( static_cast<char>( chr ) ); }
-inline std::string to_string( unsigned char           chr ) { return make_char_string( static_cast<char>( chr ) ); }
-inline std::string to_string(          char           chr ) { return make_char_string(                    chr   ); }
-
-template< typename T >
-struct is_streamable
-{
-    template< typename U >
-    static auto test( int ) -> decltype( std::declval<std::ostream &>() << std::declval<U>(), std::true_type() );
-
-    template< typename >
-    static auto test( ... ) -> std::false_type;
-
-#ifdef _MSC_VER
-    enum { value = std::is_same< decltype( test<T>(0) ), std::true_type >::value };
-#else
-    static constexpr bool value = std::is_same< decltype( test<T>(0) ), std::true_type >::value;
-#endif
-};
-
-template< typename T >
-struct is_container
-{
-    template< typename U >
-    static auto test( int ) -> decltype( std::declval<U>().begin() == std::declval<U>().end(), std::true_type() );
-
-    template< typename >
-    static auto test( ... ) -> std::false_type;
-
-#ifdef _MSC_VER
-    enum { value = std::is_same< decltype( test<T>(0) ), std::true_type >::value };
-#else
-    static constexpr bool value = std::is_same< decltype( test<T>(0) ), std::true_type >::value;
-#endif
-};
-
-template< typename T, typename R >
-using ForEnum = typename std::enable_if< std::is_enum<T>::value, R>::type;
-
-template< typename T, typename R >
-using ForNonEnum = typename std::enable_if< ! std::is_enum<T>::value, R>::type;
-
-template< typename T, typename R >
-using ForStreamable = typename std::enable_if< is_streamable<T>::value, R>::type;
-
-template< typename T, typename R >
-using ForNonStreamable = typename std::enable_if< ! is_streamable<T>::value, R>::type;
-
-template< typename T, typename R >
-using ForContainer = typename std::enable_if< is_container<T>::value, R>::type;
-
-template< typename T, typename R >
-using ForNonContainerNonPointer = typename std::enable_if< ! (is_container<T>::value || std::is_pointer<T>::value), R>::type;
-
-template< typename T >
-auto make_enum_string( T const & item ) -> ForNonEnum<T, std::string>
-{
-#if lest__cpp_rtti
-    return text("[type: ") + typeid(T).name() + "]: " + make_memory_string( item );
-#else
-    return text("[type: (no RTTI)]: ") + make_memory_string( item );
-#endif
-}
-
-template< typename T >
-auto make_enum_string( T const & item ) -> ForEnum<T, std::string>
-{
-    return to_string( static_cast<typename std::underlying_type<T>::type>( item ) );
-}
-
-template< typename T >
-auto make_string( T const & item ) -> ForNonStreamable<T, std::string>
-{
-    return make_enum_string( item );
-}
-
-template< typename T >
-auto make_string( T const & item ) -> ForStreamable<T, std::string>
-{
-    std::ostringstream os; os << item; return os.str();
-}
-
-template<typename T1, typename T2>
-auto make_string( std::pair<T1,T2> const & pair ) -> std::string
-{
-    std::ostringstream oss;
-    oss << "{ " << to_string( pair.first ) << ", " << to_string( pair.second ) << " }";
-    return oss.str();
-}
-
-template< typename TU, std::size_t N >
-struct make_tuple_string
-{
-    static std::string make( TU const & tuple )
-    {
-        std::ostringstream os;
-        os << to_string( std::get<N - 1>( tuple ) ) << ( N < std::tuple_size<TU>::value ? ", ": " ");
-        return make_tuple_string<TU, N - 1>::make( tuple ) + os.str();
-    }
-};
-
-template< typename TU >
-struct make_tuple_string<TU, 0>
-{
-    static std::string make( TU const & ) { return ""; }
-};
-
-template< typename ...TS >
-auto make_string( std::tuple<TS...> const & tuple ) -> std::string
-{
-    return "{ " + make_tuple_string<std::tuple<TS...>, sizeof...(TS)>::make( tuple ) + "}";
-}
-
-template< typename T >
-inline std::string make_string( T const * ptr )
-{
-    // Note showbase affects the behavior of /integer/ output;
-    std::ostringstream os;
-    os << std::internal << std::hex << std::showbase << std::setw( 2 + 2 * sizeof(T*) ) << std::setfill('0') << reinterpret_cast<std::ptrdiff_t>( ptr );
-    return os.str();
-}
-
-template< typename C, typename R >
-inline std::string make_string( R C::* ptr )
-{
-    std::ostringstream os;
-    os << std::internal << std::hex << std::showbase << std::setw( 2 + 2 * sizeof(R C::* ) ) << std::setfill('0') << ptr;
-    return os.str();
-}
-
-template< typename T >
-auto to_string( T const * ptr ) -> std::string
-{
-    return ! ptr ? "nullptr" : make_string( ptr );
-}
-
-template<typename C, typename R>
-auto to_string( R C::* ptr ) -> std::string
-{
-    return ! ptr ? "nullptr" : make_string( ptr );
-}
-
-template< typename T >
-auto to_string( T const & item ) -> ForNonContainerNonPointer<T, std::string>
-{
-    return make_string( item );
-}
-
-template< typename C >
-auto to_string( C const & cont ) -> ForContainer<C, std::string>
-{
-    std::ostringstream os;
-    os << "{ ";
-    for ( auto & x : cont )
-    {
-        os << to_string( x ) << ", ";
-    }
-    os << "}";
-    return os.str();
-}
-
-#if lest_FEATURE_WSTRING
-inline
-auto to_string( std::wstring const & txt ) -> std::string
-{
-    std::string result; result.reserve( txt.size() );
-
-    for( auto & chr : txt )
-    {
-        result += chr <= 0xff ? static_cast<char>( chr ) : '?';
-    }
-    return to_string( result );
-}
-#endif
-
-template< typename T >
-auto make_value_string( T const & value ) -> std::string
-{
-    std::ostringstream os; os << value; return os.str();
-}
-
-inline
-auto make_memory_string( void const * item, std::size_t size ) -> std::string
-{
-    // reverse order for little endian architectures:
-
-    auto is_little_endian = []
-    {
-        union U { int i = 1; char c[ sizeof(int) ]; };
-
-        return 1 != U{}.c[ sizeof(int) - 1 ];
-    };
-
-    int i = 0, end = static_cast<int>( size ), inc = 1;
-
-    if ( is_little_endian() ) { i = end - 1; end = inc = -1; }
-
-    unsigned char const * bytes = static_cast<unsigned char const *>( item );
-
-    std::ostringstream os;
-    os << "0x" << std::setfill( '0' ) << std::hex;
-    for ( ; i != end; i += inc )
-    {
-        os << std::setw(2) << static_cast<unsigned>( bytes[i] ) << " ";
-    }
-    return os.str();
-}
-
-template< typename T >
-auto make_memory_string( T const & item ) -> std::string
-{
-    return make_memory_string( &item, sizeof item );
-}
-
-inline
-auto to_string( approx const & appr ) -> std::string
-{
-    return to_string( appr.magnitude() );
-}
-
-template< typename L, typename R >
-auto to_string( L const & lhs, std::string op, R const & rhs ) -> std::string
-{
-    std::ostringstream os; os << to_string( lhs ) << " " << op << " " << to_string( rhs ); return os.str();
-}
-
-template< typename L >
-struct expression_lhs
-{
-    const L lhs;
-
-    expression_lhs( L lhs_) : lhs( lhs_) {}
-
-    operator result() { return result{ !!lhs, to_string( lhs ) }; }
-
-    template< typename R > result operator==( R const & rhs ) { return result{ lhs == rhs, to_string( lhs, "==", rhs ) }; }
-    template< typename R > result operator!=( R const & rhs ) { return result{ lhs != rhs, to_string( lhs, "!=", rhs ) }; }
-    template< typename R > result operator< ( R const & rhs ) { return result{ lhs <  rhs, to_string( lhs, "<" , rhs ) }; }
-    template< typename R > result operator<=( R const & rhs ) { return result{ lhs <= rhs, to_string( lhs, "<=", rhs ) }; }
-    template< typename R > result operator> ( R const & rhs ) { return result{ lhs >  rhs, to_string( lhs, ">" , rhs ) }; }
-    template< typename R > result operator>=( R const & rhs ) { return result{ lhs >= rhs, to_string( lhs, ">=", rhs ) }; }
-};
-
-struct expression_decomposer
-{
-    template <typename L>
-    expression_lhs<L const &> operator<< ( L const & operand )
-    {
-        return expression_lhs<L const &>( operand );
-    }
-};
-
-// Reporter:
-
-#if lest_FEATURE_COLOURISE
-
-inline text red  ( text words ) { return "\033[1;31m" + words + "\033[0m"; }
-inline text green( text words ) { return "\033[1;32m" + words + "\033[0m"; }
-inline text gray ( text words ) { return "\033[1;30m" + words + "\033[0m"; }
-
-inline bool starts_with( text words, text with )
-{
-    return 0 == words.find( with );
-}
-
-inline text replace( text words, text from, text to )
-{
-    size_t pos = words.find( from );
-    return pos == std::string::npos ? words : words.replace( pos, from.length(), to  );
-}
-
-inline text colour( text words )
-{
-    if      ( starts_with( words, "failed" ) ) return replace( words, "failed", red  ( "failed" ) );
-    else if ( starts_with( words, "passed" ) ) return replace( words, "passed", green( "passed" ) );
-
-    return replace( words, "for", gray( "for" ) );
-}
-
-inline bool is_cout( std::ostream & os ) { return &os == &std::cout; }
-
-struct colourise
-{
-    const text words;
-
-    colourise( text words )
-    : words( words ) {}
-
-    // only colourise for std::cout, not for a stringstream as used in tests:
-
-    std::ostream & operator()( std::ostream & os ) const
-    {
-        return is_cout( os ) ? os << colour( words ) : os << words;
-    }
-};
-
-inline std::ostream & operator<<( std::ostream & os, colourise words ) { return words( os ); }
-#else
-inline text colourise( text words ) { return words; }
-#endif
-
-inline text pluralise( text word, int n )
-{
-    return n == 1 ? word : word + "s";
-}
-
-inline std::ostream & operator<<( std::ostream & os, comment note )
-{
-    return os << (note ? " " + note.info : "" );
-}
-
-inline std::ostream & operator<<( std::ostream & os, location where )
-{
-#ifdef __GNUG__
-    return os << where.file << ":" << where.line;
-#else
-    return os << where.file << "(" << where.line << ")";
-#endif
-}
-
-inline void report( std::ostream & os, message const & e, text test )
-{
-    os << e.where << ": " << colourise( e.kind ) << e.note << ": " << test << ": " << colourise( e.what() ) << std::endl;
-}
-
-// Test runner:
-
-#if lest_FEATURE_REGEX_SEARCH
-    inline bool search( text re, text line )
-    {
-        return std::regex_search( line, std::regex( re ) );
-    }
-#else
-    inline bool search( text part, text line )
-    {
-        auto case_insensitive_equal = []( char a, char b )
-        {
-            return tolower( a ) == tolower( b );
-        };
-
-        return std::search(
-            line.begin(), line.end(),
-            part.begin(), part.end(), case_insensitive_equal ) != line.end();
-    }
-#endif
-
-inline bool match( texts whats, text line )
-{
-    for ( auto & what : whats )
-    {
-        if ( search( what, line ) )
-            return true;
-    }
-    return false;
-}
-
-inline bool select( text name, texts include )
-{
-    auto none = []( texts args ) { return args.size() == 0; };
-
-#if lest_FEATURE_REGEX_SEARCH
-    auto hidden = []( text arg ){ return match( { "\\[\\..*", "\\[hide\\]" }, arg ); };
-#else
-    auto hidden = []( text arg ){ return match( { "[.", "[hide]" }, arg ); };
-#endif
-
-    if ( none( include ) )
-    {
-        return ! hidden( name );
-    }
-
-    bool any = false;
-    for ( auto pos = include.rbegin(); pos != include.rend(); ++pos )
-    {
-        auto & part = *pos;
-
-        if ( part == "@" || part == "*" )
-            return true;
-
-        if ( search( part, name ) )
-            return true;
-
-        if ( '!' == part[0] )
-        {
-            any = true;
-            if ( search( part.substr(1), name ) )
-                return false;
-        }
-        else
-        {
-            any = false;
-        }
-    }
-    return any && ! hidden( name );
-}
-
-inline int indefinite( int repeat ) { return repeat == -1; }
-
-using seed_t = std::mt19937::result_type;
-
-struct options
-{
-    bool help    = false;
-    bool abort   = false;
-    bool count   = false;
-    bool list    = false;
-    bool tags    = false;
-    bool time    = false;
-    bool pass    = false;
-    bool zen     = false;
-    bool lexical = false;
-    bool random  = false;
-    bool verbose = false;
-    bool version = false;
-    int  repeat  = 1;
-    seed_t seed  = 0;
-};
-
-struct env
-{
-    std::ostream & os;
-    options opt;
-    text testing;
-    std::vector< text > ctx;
-
-    env( std::ostream & out, options option )
-    : os( out ), opt( option ), testing(), ctx() {}
-
-    env & operator()( text test )
-    {
-        clear(); testing = test; return *this;
-    }
-
-    bool abort() { return opt.abort; }
-    bool pass()  { return opt.pass; }
-    bool zen()   { return opt.zen; }
-
-    void clear() { ctx.clear(); }
-    void pop()   { ctx.pop_back(); }
-    void push( text proposition ) { ctx.emplace_back( proposition ); }
-
-    text context() { return testing + sections(); }
-
-    text sections()
-    {
-        if ( ! opt.verbose )
-            return "";
-
-        text msg;
-        for( auto section : ctx )
-        {
-            msg += "\n  " + section;
-        }
-        return msg;
-    }
-};
-
-struct ctx
-{
-    env & environment;
-    bool once;
-
-    ctx( env & environment_, text proposition_ )
-    : environment( environment_), once( true )
-    {
-        environment.push( proposition_);
-    }
-
-    ~ctx()
-    {
-#if lest_CPP17_OR_GREATER
-        if ( std::uncaught_exceptions() == 0 )
-#else
-        if ( ! std::uncaught_exception() )
-#endif
-        {
-            environment.pop();
-        }
-    }
-
-    explicit operator bool() { bool result = once; once = false; return result; }
-};
-
-struct action
-{
-    std::ostream & os;
-
-    action( std::ostream & out ) : os( out ) {}
-
-    action( action const & ) = delete;
-    void operator=( action const & ) = delete;
-
-    operator      int() { return 0; }
-    bool        abort() { return false; }
-    action & operator()( test ) { return *this; }
-};
-
-struct print : action
-{
-    print( std::ostream & out ) : action( out ) {}
-
-    print & operator()( test testing )
-    {
-        os << testing.name << "\n"; return *this;
-    }
-};
-
-inline texts tags( text name, texts result = {} )
-{
-    auto none = std::string::npos;
-    auto lb   = name.find_first_of( "[" );
-    auto rb   = name.find_first_of( "]" );
-
-    if ( lb == none || rb == none )
-        return result;
-
-    result.emplace_back( name.substr( lb, rb - lb + 1 ) );
-
-    return tags( name.substr( rb + 1 ), result );
-}
-
-struct ptags : action
-{
-    std::set<text> result;
-
-    ptags( std::ostream & out ) : action( out ), result() {}
-
-    ptags & operator()( test testing )
-    {
-        for ( auto & tag : tags( testing.name ) )
-            result.insert( tag );
-
-        return *this;
-    }
-
-    ~ptags()
-    {
-        std::copy( result.begin(), result.end(), std::ostream_iterator<text>( os, "\n" ) );
-    }
-};
-
-struct count : action
-{
-    int n = 0;
-
-    count( std::ostream & out ) : action( out ) {}
-
-    count & operator()( test ) { ++n; return *this; }
-
-    ~count()
-    {
-        os << n << " selected " << pluralise("test", n) << "\n";
-    }
-};
-
-struct timer
-{
-    using time = std::chrono::high_resolution_clock;
-
-    time::time_point start = time::now();
-
-    double elapsed_seconds() const
-    {
-        return 1e-6 * static_cast<double>( std::chrono::duration_cast< std::chrono::microseconds >( time::now() - start ).count() );
-    }
-};
-
-struct times : action
-{
-    env output;
-    int selected = 0;
-    int failures = 0;
-
-    timer total;
-
-    times( std::ostream & out, options option )
-    : action( out ), output( out, option ), total()
-    {
-        os << std::setfill(' ') << std::fixed << std::setprecision( lest_FEATURE_TIME_PRECISION );
-    }
-
-    operator int() { return failures; }
-
-    bool abort() { return output.abort() && failures > 0; }
-
-    times & operator()( test testing )
-    {
-        timer t;
-
-        try
-        {
-            testing.behaviour( output( testing.name ) );
-        }
-        catch( message const & )
-        {
-            ++failures;
-        }
-
-        os << std::setw(3) << ( 1000 * t.elapsed_seconds() ) << " ms: " << testing.name  << "\n";
-
-        return *this;
-    }
-
-    ~times()
-    {
-        os << "Elapsed time: " << std::setprecision(1) << total.elapsed_seconds() << " s\n";
-    }
-};
-
-struct confirm : action
-{
-    env output;
-    int selected = 0;
-    int failures = 0;
-
-    confirm( std::ostream & out, options option )
-    : action( out ), output( out, option ) {}
-
-    operator int() { return failures; }
-
-    bool abort() { return output.abort() && failures > 0; }
-
-    confirm & operator()( test testing )
-    {
-        try
-        {
-            ++selected; testing.behaviour( output( testing.name ) );
-        }
-        catch( message const & e )
-        {
-            ++failures; report( os, e, output.context() );
-        }
-        return *this;
-    }
-
-    ~confirm()
-    {
-        if ( failures > 0 )
-        {
-            os << failures << " out of " << selected << " selected " << pluralise("test", selected) << " " << colourise( "failed.\n" );
-        }
-        else if ( output.pass() )
-        {
-            os << "All " << selected << " selected " << pluralise("test", selected) << " " << colourise( "passed.\n" );
-        }
-    }
-};
-
-template< typename Action >
-bool abort( Action & perform )
-{
-    return perform.abort();
-}
-
-template< typename Action >
-Action && for_test( tests specification, texts in, Action && perform, int n = 1 )
-{
-    for ( int i = 0; indefinite( n ) || i < n; ++i )
-    {
-        for ( auto & testing : specification )
-        {
-            if ( select( testing.name, in ) )
-                if ( abort( perform( testing ) ) )
-                    return std::move( perform );
-        }
-    }
-    return std::move( perform );
-}
-
-inline void sort( tests & specification )
-{
-    auto test_less = []( test const & a, test const & b ) { return a.name < b.name; };
-    std::sort( specification.begin(), specification.end(), test_less );
-}
-
-inline void shuffle( tests & specification, options option )
-{
-    std::shuffle( specification.begin(), specification.end(), std::mt19937( option.seed ) );
-}
-
-// workaround MinGW bug, http://stackoverflow.com/a/16132279:
-
-inline int stoi( text num )
-{
-    return static_cast<int>( std::strtol( num.c_str(), nullptr, 10 ) );
-}
-
-inline bool is_number( text arg )
-{
-    return std::all_of( arg.begin(), arg.end(), ::isdigit );
-}
-
-inline seed_t seed( text opt, text arg )
-{
-    if ( is_number( arg ) )
-        return static_cast<seed_t>( lest::stoi( arg ) );
-
-    if ( arg == "time" )
-        return static_cast<seed_t>( std::chrono::high_resolution_clock::now().time_since_epoch().count() );
-
-    throw std::runtime_error( "expecting 'time' or positive number with option '" + opt + "', got '" + arg + "' (try option --help)" );
-}
-
-inline int repeat( text opt, text arg )
-{
-    const int num = lest::stoi( arg );
-
-    if ( indefinite( num ) || num >= 0 )
-        return num;
-
-    throw std::runtime_error( "expecting '-1' or positive number with option '" + opt + "', got '" + arg + "' (try option --help)" );
-}
-
-inline auto split_option( text arg ) -> std::tuple<text, text>
-{
-    auto pos = arg.rfind( '=' );
-
-    return pos == text::npos
-                ? std::make_tuple( arg, "" )
-                : std::make_tuple( arg.substr( 0, pos ), arg.substr( pos + 1 ) );
-}
-
-inline auto split_arguments( texts args ) -> std::tuple<options, texts>
-{
-    options option; texts in;
-
-    bool in_options = true;
-
-    for ( auto & arg : args )
-    {
-        if ( in_options )
-        {
-            text opt, val;
-            std::tie( opt, val ) = split_option( arg );
-
-            if      ( opt[0] != '-'                             ) { in_options     = false;           }
-            else if ( opt == "--"                               ) { in_options     = false; continue; }
-            else if ( opt == "-h"      || "--help"       == opt ) { option.help    =  true; continue; }
-            else if ( opt == "-a"      || "--abort"      == opt ) { option.abort   =  true; continue; }
-            else if ( opt == "-c"      || "--count"      == opt ) { option.count   =  true; continue; }
-            else if ( opt == "-g"      || "--list-tags"  == opt ) { option.tags    =  true; continue; }
-            else if ( opt == "-l"      || "--list-tests" == opt ) { option.list    =  true; continue; }
-            else if ( opt == "-t"      || "--time"       == opt ) { option.time    =  true; continue; }
-            else if ( opt == "-p"      || "--pass"       == opt ) { option.pass    =  true; continue; }
-            else if ( opt == "-z"      || "--pass-zen"   == opt ) { option.zen     =  true; continue; }
-            else if ( opt == "-v"      || "--verbose"    == opt ) { option.verbose =  true; continue; }
-            else if (                     "--version"    == opt ) { option.version =  true; continue; }
-            else if ( opt == "--order" && "declared"     == val ) { /* by definition */   ; continue; }
-            else if ( opt == "--order" && "lexical"      == val ) { option.lexical =  true; continue; }
-            else if ( opt == "--order" && "random"       == val ) { option.random  =  true; continue; }
-            else if ( opt == "--random-seed" ) { option.seed   = seed  ( "--random-seed", val ); continue; }
-            else if ( opt == "--repeat"      ) { option.repeat = repeat( "--repeat"     , val ); continue; }
-            else throw std::runtime_error( "unrecognised option '" + arg + "' (try option --help)" );
-        }
-        in.push_back( arg );
-    }
-    option.pass = option.pass || option.zen;
-
-    return std::make_tuple( option, in );
-}
-
-inline int usage( std::ostream & os )
-{
-    os <<
-        "\nUsage: test [options] [test-spec ...]\n"
-        "\n"
-        "Options:\n"
-        "  -h, --help         this help message\n"
-        "  -a, --abort        abort at first failure\n"
-        "  -c, --count        count selected tests\n"
-        "  -g, --list-tags    list tags of selected tests\n"
-        "  -l, --list-tests   list selected tests\n"
-        "  -p, --pass         also report passing tests\n"
-        "  -z, --pass-zen     ... without expansion\n"
-        "  -t, --time         list duration of selected tests\n"
-        "  -v, --verbose      also report passing or failing sections\n"
-        "  --order=declared   use source code test order (default)\n"
-        "  --order=lexical    use lexical sort test order\n"
-        "  --order=random     use random test order\n"
-        "  --random-seed=n    use n for random generator seed\n"
-        "  --random-seed=time use time for random generator seed\n"
-        "  --repeat=n         repeat selected tests n times (-1: indefinite)\n"
-        "  --version          report lest version and compiler used\n"
-        "  --                 end options\n"
-        "\n"
-        "Test specification:\n"
-        "  \"@\", \"*\" all tests, unless excluded\n"
-        "  empty    all tests, unless tagged [hide] or [.optional-name]\n"
-#if lest_FEATURE_REGEX_SEARCH
-        "  \"re\"     select tests that match regular expression\n"
-        "  \"!re\"    omit tests that match regular expression\n"
-#else
-        "  \"text\"   select tests that contain text (case insensitive)\n"
-        "  \"!text\"  omit tests that contain text (case insensitive)\n"
-#endif
-        ;
-    return 0;
-}
-
-inline text compiler()
-{
-    std::ostringstream os;
-#if   defined (__clang__ )
-    os << "clang " << __clang_version__;
-#elif defined (__GNUC__  )
-    os << "gcc " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__;
-#elif defined ( _MSC_VER )
-    os << "MSVC " << (_MSC_VER / 100 - 5 - (_MSC_VER < 1900)) << " (" << _MSC_VER << ")";
-#else
-    os << "[compiler]";
-#endif
-    return os.str();
-}
-
-inline int version( std::ostream & os )
-{
-    os << "lest version "  << lest_VERSION << "\n"
-       << "Compiled with " << compiler()   << " on " << __DATE__ << " at " << __TIME__ << ".\n"
-       << "For more information, see https://github.com/martinmoene/lest.\n";
-    return 0;
-}
-
-inline int run( tests specification, texts arguments, std::ostream & os = std::cout )
-{
-    try
-    {
-        options option; texts in;
-        std::tie( option, in ) = split_arguments( arguments );
-
-        if ( option.lexical ) {    sort( specification         ); }
-        if ( option.random  ) { shuffle( specification, option ); }
-
-        if ( option.help    ) { return usage   ( os ); }
-        if ( option.version ) { return version ( os ); }
-        if ( option.count   ) { return for_test( specification, in, count( os ) ); }
-        if ( option.list    ) { return for_test( specification, in, print( os ) ); }
-        if ( option.tags    ) { return for_test( specification, in, ptags( os ) ); }
-        if ( option.time    ) { return for_test( specification, in, times( os, option ) ); }
-
-        return for_test( specification, in, confirm( os, option ), option.repeat );
-    }
-    catch ( std::exception const & e )
-    {
-        os << "Error: " << e.what() << "\n";
-        return 1;
-    }
-}
-
-inline int run( tests specification, int argc, char * argv[], std::ostream & os = std::cout )
-{
-    return run( specification, texts( argv + 1, argv + argc ), os  );
-}
-
-template< std::size_t N >
-int run( test const (&specification)[N], texts arguments, std::ostream & os = std::cout )
-{
-    std::cout.sync_with_stdio( false );
-    return (std::min)( run( tests( specification, specification + N ), arguments, os  ), exit_max_value );
-}
-
-template< std::size_t N >
-int run( test const (&specification)[N], std::ostream & os = std::cout )
-{
-    return run( tests( specification, specification + N ), {}, os  );
-}
-
-template< std::size_t N >
-int run( test const (&specification)[N], int argc, char * argv[], std::ostream & os = std::cout )
-{
-    return run( tests( specification, specification + N ), texts( argv + 1, argv + argc ), os  );
-}
-
-} // namespace lest
-
-#if defined (__clang__)
-# pragma clang diagnostic pop
-#elif defined (__GNUC__)
-# pragma GCC   diagnostic pop
-#endif
-
-#endif // LEST_LEST_HPP_INCLUDED