Adding upstream version 0.11.1.upstream/0.11.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 30945 insertions, 0 deletions

diff --git a/src/third-party/rapidyaml/ryml_all.hpp b/src/third-party/rapidyaml/ryml_all.hpp
new file mode 100644
index 0000000..ee5248b
--- /dev/null
+++ b/src/third-party/rapidyaml/ryml_all.hpp
@@ -0,0 +1,30945 @@
+#ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
+//
+// Rapid YAML - a library to parse and emit YAML, and do it fast.
+//
+// https://github.com/biojppm/rapidyaml
+//
+// DO NOT EDIT. This file is generated automatically.
+// This is an amalgamated single-header version of the library.
+//
+// INSTRUCTIONS:
+//   - Include at will in any header of your project
+//   - In one (and only one) of your project source files,
+//     #define RYML_SINGLE_HDR_DEFINE_NOW and then include this header.
+//     This will enable the function and class definitions in
+//     the header file.
+//   - To compile into a shared library, just define the
+//     preprocessor symbol RYML_SHARED . This will take
+//     care of symbol export/import.
+//
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// LICENSE.txt
+// https://github.com/biojppm/rapidyaml/LICENSE.txt
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+// Copyright (c) 2018, Joao Paulo Magalhaes <dev@jpmag.me>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+ // shared library: export when defining
+#if defined(RYML_SHARED) && defined(RYML_SINGLE_HDR_DEFINE_NOW) && !defined(RYML_EXPORTS)
+#define RYML_EXPORTS
+#endif
+
+
+ // propagate defines to c4core
+#if defined(RYML_SINGLE_HDR_DEFINE_NOW) && !defined(C4CORE_SINGLE_HDR_DEFINE_NOW)
+#define C4CORE_SINGLE_HDR_DEFINE_NOW
+#endif
+
+#if defined(RYML_EXPORTS) && !defined(C4CORE_EXPORTS)
+#define C4CORE_EXPORTS
+#endif
+
+#if defined(RYML_SHARED) && !defined(C4CORE_SHARED)
+#define C4CORE_SHARED
+#endif
+
+// workaround for include removal while amalgamating
+// resulting in <stdarg.h> missing in arm-none-eabi-g++
+// https://github.com/biojppm/rapidyaml/issues/193
+#include <stdarg.h>
+
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/c4core_all.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/c4core_all.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4CORE_SINGLE_HEADER_AMALGAMATED_HPP_
+//
+// c4core - C++ utilities
+//
+// https://github.com/biojppm/c4core
+//
+// DO NOT EDIT. This file is generated automatically.
+// This is an amalgamated single-header version of the library.
+//
+// INSTRUCTIONS:
+//   - Include at will in any header of your project
+//   - In one (and only one) of your project source files,
+//     #define C4CORE_SINGLE_HDR_DEFINE_NOW and then include this header.
+//     This will enable the function and class definitions in
+//     the header file.
+//   - To compile into a shared library, just define the
+//     preprocessor symbol C4CORE_SHARED . This will take
+//     care of symbol export/import.
+//
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// LICENSE.txt
+// https://github.com/biojppm/c4core/LICENSE.txt
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+// Copyright (c) 2018, Joao Paulo Magalhaes <dev@jpmag.me>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+// shared library: export when defining
+#if defined(C4CORE_SHARED) && defined(C4CORE_SINGLE_HDR_DEFINE_NOW) && !defined(C4CORE_EXPORTS)
+#define C4CORE_EXPORTS
+#endif
+
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/export.hpp
+// https://github.com/biojppm/c4core/src/c4/export.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_EXPORT_HPP_
+#define C4_EXPORT_HPP_
+
+#ifdef _WIN32
+    #ifdef C4CORE_SHARED
+        #ifdef C4CORE_EXPORTS
+            #define C4CORE_EXPORT __declspec(dllexport)
+        #else
+            #define C4CORE_EXPORT __declspec(dllimport)
+        #endif
+    #else
+        #define C4CORE_EXPORT
+    #endif
+#else
+    #define C4CORE_EXPORT
+#endif
+
+#endif /* C4CORE_EXPORT_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/export.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/preprocessor.hpp
+// https://github.com/biojppm/c4core/src/c4/preprocessor.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_PREPROCESSOR_HPP_
+#define _C4_PREPROCESSOR_HPP_
+
+/** @file preprocessor.hpp Contains basic macros and preprocessor utilities.
+ * @ingroup basic_headers */
+
+#ifdef __clang__
+    /* NOTE: using , ## __VA_ARGS__ to deal with zero-args calls to
+     * variadic macros is not portable, but works in clang, gcc, msvc, icc.
+     * clang requires switching off compiler warnings for pedantic mode.
+     * @see http://stackoverflow.com/questions/32047685/variadic-macro-without-arguments */
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" // warning: token pasting of ',' and __VA_ARGS__ is a GNU extension
+#elif defined(__GNUC__)
+    /* GCC also issues a warning for zero-args calls to variadic macros.
+     * This warning is switched on with -pedantic and apparently there is no
+     * easy way to turn it off as with clang. But marking this as a system
+     * header works.
+     * @see https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html
+     * @see http://stackoverflow.com/questions/35587137/ */
+#   pragma GCC system_header
+#endif
+
+#define C4_WIDEN(str) L"" str
+
+#define C4_COUNTOF(arr) (sizeof(arr)/sizeof((arr)[0]))
+
+#define C4_EXPAND(arg) arg
+
+/** useful in some macro calls with template arguments */
+#define C4_COMMA ,
+/** useful in some macro calls with template arguments
+ * @see C4_COMMA */
+#define C4_COMMA_X C4_COMMA
+
+/** expand and quote */
+#define C4_XQUOTE(arg) _C4_XQUOTE(arg)
+#define _C4_XQUOTE(arg) C4_QUOTE(arg)
+#define C4_QUOTE(arg) #arg
+
+/** expand and concatenate */
+#define C4_XCAT(arg1, arg2) _C4_XCAT(arg1, arg2)
+#define _C4_XCAT(arg1, arg2) C4_CAT(arg1, arg2)
+#define C4_CAT(arg1, arg2) arg1##arg2
+
+#define C4_VERSION_CAT(major, minor, patch) ((major)*10000 + (minor)*100 + (patch))
+
+/** A preprocessor foreach. Spectacular trick taken from:
+ * http://stackoverflow.com/a/1872506/5875572
+ * The first argument is for a macro receiving a single argument,
+ * which will be called with every subsequent argument. There is
+ * currently a limit of 32 arguments, and at least 1 must be provided.
+ *
+Example:
+@code{.cpp}
+struct Example {
+    int a;
+    int b;
+    int c;
+};
+// define a one-arg macro to be called
+#define PRN_STRUCT_OFFSETS(field) PRN_STRUCT_OFFSETS_(Example, field)
+#define PRN_STRUCT_OFFSETS_(structure, field) printf(C4_XQUOTE(structure) ":" C4_XQUOTE(field)" - offset=%zu\n", offsetof(structure, field));
+
+// now call the macro for a, b and c
+C4_FOR_EACH(PRN_STRUCT_OFFSETS, a, b, c);
+@endcode */
+#define C4_FOR_EACH(what, ...) C4_FOR_EACH_SEP(what, ;, __VA_ARGS__)
+
+/** same as C4_FOR_EACH(), but use a custom separator between statements.
+ * If a comma is needed as the separator, use the C4_COMMA macro.
+ * @see C4_FOR_EACH
+ * @see C4_COMMA
+ */
+#define C4_FOR_EACH_SEP(what, sep, ...) _C4_FOR_EACH_(_C4_FOR_EACH_NARG(__VA_ARGS__), what, sep, __VA_ARGS__)
+
+/// @cond dev
+
+#define _C4_FOR_EACH_01(what, sep, x) what(x) sep
+#define _C4_FOR_EACH_02(what, sep, x, ...) what(x) sep _C4_FOR_EACH_01(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_03(what, sep, x, ...) what(x) sep _C4_FOR_EACH_02(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_04(what, sep, x, ...) what(x) sep _C4_FOR_EACH_03(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_05(what, sep, x, ...) what(x) sep _C4_FOR_EACH_04(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_06(what, sep, x, ...) what(x) sep _C4_FOR_EACH_05(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_07(what, sep, x, ...) what(x) sep _C4_FOR_EACH_06(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_08(what, sep, x, ...) what(x) sep _C4_FOR_EACH_07(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_09(what, sep, x, ...) what(x) sep _C4_FOR_EACH_08(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_10(what, sep, x, ...) what(x) sep _C4_FOR_EACH_09(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_11(what, sep, x, ...) what(x) sep _C4_FOR_EACH_10(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_12(what, sep, x, ...) what(x) sep _C4_FOR_EACH_11(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_13(what, sep, x, ...) what(x) sep _C4_FOR_EACH_12(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_14(what, sep, x, ...) what(x) sep _C4_FOR_EACH_13(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_15(what, sep, x, ...) what(x) sep _C4_FOR_EACH_14(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_16(what, sep, x, ...) what(x) sep _C4_FOR_EACH_15(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_17(what, sep, x, ...) what(x) sep _C4_FOR_EACH_16(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_18(what, sep, x, ...) what(x) sep _C4_FOR_EACH_17(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_19(what, sep, x, ...) what(x) sep _C4_FOR_EACH_18(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_20(what, sep, x, ...) what(x) sep _C4_FOR_EACH_19(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_21(what, sep, x, ...) what(x) sep _C4_FOR_EACH_20(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_22(what, sep, x, ...) what(x) sep _C4_FOR_EACH_21(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_23(what, sep, x, ...) what(x) sep _C4_FOR_EACH_22(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_24(what, sep, x, ...) what(x) sep _C4_FOR_EACH_23(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_25(what, sep, x, ...) what(x) sep _C4_FOR_EACH_24(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_26(what, sep, x, ...) what(x) sep _C4_FOR_EACH_25(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_27(what, sep, x, ...) what(x) sep _C4_FOR_EACH_26(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_28(what, sep, x, ...) what(x) sep _C4_FOR_EACH_27(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_29(what, sep, x, ...) what(x) sep _C4_FOR_EACH_28(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_30(what, sep, x, ...) what(x) sep _C4_FOR_EACH_29(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_31(what, sep, x, ...) what(x) sep _C4_FOR_EACH_30(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_32(what, sep, x, ...) what(x) sep _C4_FOR_EACH_31(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_NARG(...) _C4_FOR_EACH_NARG_(__VA_ARGS__, _C4_FOR_EACH_RSEQ_N())
+#define _C4_FOR_EACH_NARG_(...) _C4_FOR_EACH_ARG_N(__VA_ARGS__)
+#define _C4_FOR_EACH_ARG_N(_01, _02, _03, _04, _05, _06, _07, _08, _09, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, N, ...) N
+#define _C4_FOR_EACH_RSEQ_N() 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 09, 08, 07, 06, 05, 04, 03, 02, 01
+#define _C4_FOR_EACH_(N, what, sep, ...) C4_XCAT(_C4_FOR_EACH_, N)(what, sep, __VA_ARGS__)
+
+/// @endcond
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif /* _C4_PREPROCESSOR_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/preprocessor.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/platform.hpp
+// https://github.com/biojppm/c4core/src/c4/platform.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_PLATFORM_HPP_
+#define _C4_PLATFORM_HPP_
+
+/** @file platform.hpp Provides platform information macros
+ * @ingroup basic_headers */
+
+// see also https://sourceforge.net/p/predef/wiki/OperatingSystems/
+
+#if defined(_WIN64)
+#   define C4_WIN
+#   define C4_WIN64
+#elif defined(_WIN32)
+#   define C4_WIN
+#   define C4_WIN32
+#elif defined(__ANDROID__)
+#   define C4_ANDROID
+#elif defined(__APPLE__)
+#   include "TargetConditionals.h"
+#   if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+#       define C4_IOS
+#   elif TARGET_OS_MAC || TARGET_OS_OSX
+#       define C4_MACOS
+#   else
+#       error "Unknown Apple platform"
+#   endif
+#elif defined(__linux)
+#   define C4_UNIX
+#   define C4_LINUX
+#elif defined(__unix)
+#   define C4_UNIX
+#elif defined(__arm__) || defined(__aarch64__)
+#   define C4_ARM
+#elif defined(SWIG)
+#   define C4_SWIG
+#else
+#   error "unknown platform"
+#endif
+
+#if defined(__posix) || defined(__unix__) || defined(__linux)
+#   define C4_POSIX
+#endif
+
+
+#endif /* _C4_PLATFORM_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/platform.hpp)
+
+
+#if 0
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/cpu.hpp
+// https://github.com/biojppm/c4core/src/c4/cpu.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_CPU_HPP_
+#define _C4_CPU_HPP_
+
+/** @file cpu.hpp Provides processor information macros
+ * @ingroup basic_headers */
+
+// see also https://sourceforge.net/p/predef/wiki/Architectures/
+// see also https://sourceforge.net/p/predef/wiki/Endianness/
+// see also https://github.com/googlesamples/android-ndk/blob/android-mk/hello-jni/jni/hello-jni.c
+// see http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/global/qprocessordetection.h
+
+#ifdef __ORDER_LITTLE_ENDIAN__
+    #define _C4EL __ORDER_LITTLE_ENDIAN__
+#else
+    #define _C4EL 1234
+#endif
+
+#ifdef __ORDER_BIG_ENDIAN__
+    #define _C4EB __ORDER_BIG_ENDIAN__
+#else
+    #define _C4EB 4321
+#endif
+
+// mixed byte order (eg, PowerPC or ia64)
+#define _C4EM 1111
+
+#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
+    #define C4_CPU_X86_64
+    #define C4_WORDSIZE 8
+    #define C4_BYTE_ORDER _C4EL
+
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+    #define C4_CPU_X86
+    #define C4_WORDSIZE 4
+    #define C4_BYTE_ORDER _C4EL
+
+#elif defined(__arm__) || defined(_M_ARM) \
+    || defined(__TARGET_ARCH_ARM) || defined(__aarch64__) || defined(_M_ARM64)
+   #if defined(__aarch64__) || defined(_M_ARM64)
+       #define C4_CPU_ARM64
+       #define C4_CPU_ARMV8
+       #define C4_WORDSIZE 8
+   #else
+       #define C4_CPU_ARM
+       #define C4_WORDSIZE 4
+       #if defined(__ARM_ARCH_8__) || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 8)
+           #define C4_CPU_ARMV8
+       #elif defined(__ARM_ARCH_7__) || defined(_ARM_ARCH_7)    \
+        || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) \
+        || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 7) \
+        || (defined(_M_ARM) && _M_ARM >= 7)
+           #define C4_CPU_ARMV7
+       #elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
+        || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) \
+        || defined(__ARM_ARCH_6K__)  || defined(__ARM_ARCH_6ZK__) \
+        || defined(__ARM_ARCH_6M__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6)
+           #define C4_CPU_ARMV6
+       #elif defined(__ARM_ARCH_5TEJ__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
+           #define C4_CPU_ARMV5
+       #elif defined(__ARM_ARCH_4T__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 4)
+           #define C4_CPU_ARMV4
+       #else
+           #error "unknown CPU architecture: ARM"
+       #endif
+   #endif
+   #if defined(__ARMEL__) || defined(__LITTLE_ENDIAN__) || defined(__AARCH64EL__) \
+       || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+       #define C4_BYTE_ORDER _C4EL
+   #elif defined(__ARMEB__) || defined(__BIG_ENDIAN__) || defined(__AARCH64EB__) \
+       || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+       #define C4_BYTE_ORDER _C4EB
+   #elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_PDP_ENDIAN__)
+       #define C4_BYTE_ORDER _C4EM
+   #else
+       #error "unknown endianness"
+   #endif
+
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+   #define C4_CPU_IA64
+   #define C4_WORDSIZE 8
+   #define C4_BYTE_ORDER _C4EM
+   // itanium is bi-endian - check byte order below
+
+#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__)       \
+    || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \
+    || defined(_M_MPPC) || defined(_M_PPC)
+   #if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
+       #define C4_CPU_PPC64
+       #define C4_WORDSIZE 8
+   #else
+       #define C4_CPU_PPC
+       #define C4_WORDSIZE 4
+   #endif
+   #define C4_BYTE_ORDER _C4EM
+   // ppc is bi-endian - check byte order below
+
+#elif defined(__s390x__) || defined(__zarch__) || defined(__SYSC_ZARCH_)
+#   define C4_CPU_S390_X
+#   define C4_WORDSIZE 8
+#   define C4_BYTE_ORDER _C4EB
+
+#elif defined(__riscv)
+   #if __riscv_xlen == 64
+       #define C4_CPU_RISCV64
+       #define C4_WORDSIZE 8
+   #else
+       #define C4_CPU_RISCV32
+       #define C4_WORDSIZE 4
+   #endif
+   #define C4_BYTE_ORDER _C4EL
+
+#elif defined(__EMSCRIPTEN__)
+#   define C4_BYTE_ORDER _C4EL
+#   define C4_WORDSIZE 4
+
+#elif defined(SWIG)
+   #error "please define CPU architecture macros when compiling with swig"
+
+#else
+   #error "unknown CPU architecture"
+#endif
+
+#define C4_LITTLE_ENDIAN (C4_BYTE_ORDER == _C4EL)
+#define C4_BIG_ENDIAN (C4_BYTE_ORDER == _C4EB)
+#define C4_MIXED_ENDIAN (C4_BYTE_ORDER == _C4EM)
+
+#endif /* _C4_CPU_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/cpu.hpp)
+#endif
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/compiler.hpp
+// https://github.com/biojppm/c4core/src/c4/compiler.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_COMPILER_HPP_
+#define _C4_COMPILER_HPP_
+
+/** @file compiler.hpp Provides compiler information macros
+ * @ingroup basic_headers */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/platform.hpp
+//#include "c4/platform.hpp"
+#if !defined(C4_PLATFORM_HPP_) && !defined(_C4_PLATFORM_HPP_)
+#error "amalgamate: file c4/platform.hpp must have been included at this point"
+#endif /* C4_PLATFORM_HPP_ */
+
+
+// Compilers:
+//      C4_MSVC
+//             Visual Studio 2022: MSVC++ 17, 1930
+//             Visual Studio 2019: MSVC++ 16, 1920
+//             Visual Studio 2017: MSVC++ 15
+//             Visual Studio 2015: MSVC++ 14
+//             Visual Studio 2013: MSVC++ 13
+//             Visual Studio 2013: MSVC++ 12
+//             Visual Studio 2012: MSVC++ 11
+//             Visual Studio 2010: MSVC++ 10
+//             Visual Studio 2008: MSVC++ 09
+//             Visual Studio 2005: MSVC++ 08
+//      C4_CLANG
+//      C4_GCC
+//      C4_ICC (intel compiler)
+/** @see http://sourceforge.net/p/predef/wiki/Compilers/ for a list of compiler identifier macros */
+/** @see https://msdn.microsoft.com/en-us/library/b0084kay.aspx for VS2013 predefined macros */
+
+#if defined(_MSC_VER)// && (defined(C4_WIN) || defined(C4_XBOX) || defined(C4_UE4))
+#   define C4_MSVC
+#   define C4_MSVC_VERSION_2022 17
+#   define C4_MSVC_VERSION_2019 16
+#   define C4_MSVC_VERSION_2017 15
+#   define C4_MSVC_VERSION_2015 14
+#   define C4_MSVC_VERSION_2013 12
+#   define C4_MSVC_VERSION_2012 11
+#   if _MSC_VER >= 1930
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2022  // visual studio 2022
+#       define C4_MSVC_2022
+#   elif _MSC_VER >= 1920
+#       define C4_MSVC_VERSION C_4MSVC_VERSION_2019  // visual studio 2019
+#       define C4_MSVC_2019
+#   elif _MSC_VER >= 1910
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2017  // visual studio 2017
+#       define C4_MSVC_2017
+#   elif _MSC_VER == 1900
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2015  // visual studio 2015
+#       define C4_MSVC_2015
+#   elif _MSC_VER == 1800
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2013  // visual studio 2013
+#       define C4_MSVC_2013
+#   elif _MSC_VER == 1700
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2012  // visual studio 2012
+#       define C4_MSVC_2012
+#   elif _MSC_VER == 1600
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 10  // visual studio 2010
+#       define C4_MSVC_2010
+#   elif _MSC_VER == 1500
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 09  // visual studio 2008
+#       define C4_MSVC_2008
+#   elif _MSC_VER == 1400
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 08  // visual studio 2005
+#       define C4_MSVC_2005
+#   else
+#       error "MSVC version not supported"
+#   endif // _MSC_VER
+#else
+#   define C4_MSVC_VERSION 0   // visual studio not present
+#   define C4_GCC_LIKE
+#   ifdef __INTEL_COMPILER // check ICC before checking GCC, as ICC defines __GNUC__ too
+#       define C4_ICC
+#       define C4_ICC_VERSION __INTEL_COMPILER
+#   elif defined(__APPLE_CC__)
+#       define C4_XCODE
+#       if defined(__clang__)
+#           define C4_CLANG
+#           ifndef __apple_build_version__
+#               define C4_CLANG_VERSION C4_VERSION_ENCODED(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#           else
+#               define C4_CLANG_VERSION __apple_build_version__
+#           endif
+#       else
+#           define C4_XCODE_VERSION __APPLE_CC__
+#       endif
+#   elif defined(__clang__)
+#       define C4_CLANG
+#       ifndef __apple_build_version__
+#           define C4_CLANG_VERSION C4_VERSION_ENCODED(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#       else
+#           define C4_CLANG_VERSION __apple_build_version__
+#       endif
+#   elif defined(__GNUC__)
+#       define C4_GCC
+#       if defined(__GNUC_PATCHLEVEL__)
+#           define C4_GCC_VERSION C4_VERSION_ENCODED(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#       else
+#           define C4_GCC_VERSION C4_VERSION_ENCODED(__GNUC__, __GNUC_MINOR__, 0)
+#       endif
+#       if __GNUC__ < 5
+#           if __GNUC__ == 4 && __GNUC_MINOR__ >= 8
+// provided by cmake sub-project
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/gcc-4.8.hpp
+//#               include "c4/gcc-4.8.hpp"
+#if !defined(C4_GCC-4_8_HPP_) && !defined(_C4_GCC-4_8_HPP_)
+#error "amalgamate: file c4/gcc-4.8.hpp must have been included at this point"
+#endif /* C4_GCC-4_8_HPP_ */
+
+#           else
+// we do not support GCC < 4.8:
+//  * misses std::is_trivially_copyable
+//  * misses std::align
+//  * -Wshadow has false positives when a local function parameter has the same name as a method
+#               error "GCC < 4.8 is not supported"
+#           endif
+#       endif
+#   endif
+#endif // defined(C4_WIN) && defined(_MSC_VER)
+
+#endif /* _C4_COMPILER_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/compiler.hpp)
+
+// these includes are needed to work around conditional
+// includes in the gcc4.8 shim
+#include <cstdint>
+#include <type_traits>
+#include <cstring>
+
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// cmake/compat/c4/gcc-4.8.hpp
+// https://github.com/biojppm/c4core/cmake/compat/c4/gcc-4.8.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_COMPAT_GCC_4_8_HPP_
+#define _C4_COMPAT_GCC_4_8_HPP_
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ >= 8
+/* STL polyfills for old GNU compilers */
+
+_Pragma("GCC diagnostic ignored \"-Wshadow\"")
+_Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"")
+
+#if __cplusplus
+//included above:
+//#include <cstdint>
+//included above:
+//#include <type_traits>
+
+namespace std {
+
+template<typename _Tp>
+struct is_trivially_copyable : public integral_constant<bool,
+    is_destructible<_Tp>::value && __has_trivial_destructor(_Tp) &&
+    (__has_trivial_constructor(_Tp) || __has_trivial_copy(_Tp) || __has_trivial_assign(_Tp))>
+{ };
+
+template<typename _Tp>
+using is_trivially_copy_constructible = has_trivial_copy_constructor<_Tp>;
+
+template<typename _Tp>
+using is_trivially_default_constructible = has_trivial_default_constructor<_Tp>;
+
+template<typename _Tp>
+using is_trivially_copy_assignable = has_trivial_copy_assign<_Tp>;
+
+/* not supported */
+template<typename _Tp>
+struct is_trivially_move_constructible : false_type
+{ };
+
+/* not supported */
+template<typename _Tp>
+struct is_trivially_move_assignable : false_type
+{ };
+
+inline void *align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
+{
+    if (__space < __size)
+        return nullptr;
+    const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
+    const auto __aligned = (__intptr - 1u + __align) & -__align;
+    const auto __diff = __aligned - __intptr;
+    if (__diff > (__space - __size))
+        return nullptr;
+    else
+    {
+        __space -= __diff;
+        return __ptr = reinterpret_cast<void*>(__aligned);
+    }
+}
+typedef long double max_align_t ;
+
+}
+#else // __cplusplus
+
+//included above:
+//#include <string.h>
+// see https://sourceware.org/bugzilla/show_bug.cgi?id=25399 (ubuntu gcc-4.8)
+#define memset(s, c, count) __builtin_memset(s, c, count)
+
+#endif // __cplusplus
+
+#endif // __GNUC__ == 4 && __GNUC_MINOR__ >= 8
+
+#endif // _C4_COMPAT_GCC_4_8_HPP_
+
+
+// (end https://github.com/biojppm/c4core/cmake/compat/c4/gcc-4.8.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/language.hpp
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_LANGUAGE_HPP_
+#define _C4_LANGUAGE_HPP_
+
+/** @file language.hpp Provides language standard information macros and
+ * compiler agnostic utility macros: namespace facilities, function attributes,
+ * variable attributes, etc.
+ * @ingroup basic_headers */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/preprocessor.hpp
+//#include "c4/preprocessor.hpp"
+#if !defined(C4_PREPROCESSOR_HPP_) && !defined(_C4_PREPROCESSOR_HPP_)
+#error "amalgamate: file c4/preprocessor.hpp must have been included at this point"
+#endif /* C4_PREPROCESSOR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/compiler.hpp
+//#include "c4/compiler.hpp"
+#if !defined(C4_COMPILER_HPP_) && !defined(_C4_COMPILER_HPP_)
+#error "amalgamate: file c4/compiler.hpp must have been included at this point"
+#endif /* C4_COMPILER_HPP_ */
+
+
+/* Detect C++ standard.
+ * @see http://stackoverflow.com/a/7132549/5875572 */
+#ifndef C4_CPP
+#   ifdef _MSC_VER
+#       if _MSC_VER >= 1910  // >VS2015: VS2017, VS2019
+#           if (!defined(_MSVC_LANG))
+#               error _MSVC not defined
+#           endif
+#           if _MSVC_LANG >= 201705L
+#               define C4_CPP 20
+#               define C4_CPP20
+#           elif _MSVC_LANG == 201703L
+#               define C4_CPP 17
+#               define C4_CPP17
+#           elif _MSVC_LANG >= 201402L
+#               define C4_CPP 14
+#               define C4_CPP14
+#           elif _MSVC_LANG >= 201103L
+#               define C4_CPP 11
+#               define C4_CPP11
+#           else
+#               error C++ lesser than C++11 not supported
+#           endif
+#       else
+#           if _MSC_VER == 1900
+#               define C4_CPP 14  // VS2015 is c++14 https://devblogs.microsoft.com/cppblog/c111417-features-in-vs-2015-rtm/
+#               define C4_CPP14
+#           elif _MSC_VER == 1800 // VS2013
+#               define C4_CPP 11
+#               define C4_CPP11
+#           else
+#               error C++ lesser than C++11 not supported
+#           endif
+#       endif
+#   elif defined(__INTEL_COMPILER) // https://software.intel.com/en-us/node/524490
+#       ifdef __INTEL_CXX20_MODE__ // not sure about this
+#           define C4_CPP 20
+#           define C4_CPP20
+#       elif defined __INTEL_CXX17_MODE__ // not sure about this
+#           define C4_CPP 17
+#           define C4_CPP17
+#       elif defined __INTEL_CXX14_MODE__ // not sure about this
+#           define C4_CPP 14
+#           define C4_CPP14
+#       elif defined __INTEL_CXX11_MODE__
+#           define C4_CPP 11
+#           define C4_CPP11
+#       else
+#           error C++ lesser than C++11 not supported
+#       endif
+#   else
+#       ifndef __cplusplus
+#           error __cplusplus is not defined?
+#       endif
+#       if __cplusplus == 1
+#           error cannot handle __cplusplus==1
+#       elif __cplusplus >= 201709L
+#           define C4_CPP 20
+#           define C4_CPP20
+#       elif __cplusplus >= 201703L
+#           define C4_CPP 17
+#           define C4_CPP17
+#       elif __cplusplus >= 201402L
+#           define C4_CPP 14
+#           define C4_CPP14
+#       elif __cplusplus >= 201103L
+#           define C4_CPP 11
+#           define C4_CPP11
+#       elif __cplusplus >= 199711L
+#           error C++ lesser than C++11 not supported
+#       endif
+#   endif
+#else
+#   ifdef C4_CPP == 20
+#       define C4_CPP20
+#   elif C4_CPP == 17
+#       define C4_CPP17
+#   elif C4_CPP == 14
+#       define C4_CPP14
+#   elif C4_CPP == 11
+#       define C4_CPP11
+#   elif C4_CPP == 98
+#       define C4_CPP98
+#       error C++ lesser than C++11 not supported
+#   else
+#       error C4_CPP must be one of 20, 17, 14, 11, 98
+#   endif
+#endif
+
+#ifdef C4_CPP20
+#   define C4_CPP17
+#   define C4_CPP14
+#   define C4_CPP11
+#elif defined(C4_CPP17)
+#   define C4_CPP14
+#   define C4_CPP11
+#elif defined(C4_CPP14)
+#   define C4_CPP11
+#endif
+
+/** lifted from this answer: http://stackoverflow.com/a/20170989/5875572 */
+#ifndef _MSC_VER
+#  if __cplusplus < 201103
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+//#    define C4_NOEXCEPT
+#  elif __cplusplus == 201103
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+//#    define C4_NOEXCEPT noexcept
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+//#    define C4_NOEXCEPT noexcept
+#  endif
+#else  // _MSC_VER
+#  if _MSC_VER < 1900
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+//#    define C4_NOEXCEPT
+#  elif _MSC_VER < 2000
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+//#    define C4_NOEXCEPT noexcept
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+//#    define C4_NOEXCEPT noexcept
+#  endif
+#endif  // _MSC_VER
+
+
+#if C4_CPP < 17
+#define C4_IF_CONSTEXPR
+#define C4_INLINE_CONSTEXPR constexpr
+#else
+#define C4_IF_CONSTEXPR constexpr
+#define C4_INLINE_CONSTEXPR inline constexpr
+#endif
+
+
+//------------------------------------------------------------
+
+#define _C4_BEGIN_NAMESPACE(ns) namespace ns {
+#define _C4_END_NAMESPACE(ns)   }
+
+// MSVC cant handle the C4_FOR_EACH macro... need to fix this
+//#define C4_BEGIN_NAMESPACE(...) C4_FOR_EACH_SEP(_C4_BEGIN_NAMESPACE, , __VA_ARGS__)
+//#define C4_END_NAMESPACE(...) C4_FOR_EACH_SEP(_C4_END_NAMESPACE, , __VA_ARGS__)
+#define C4_BEGIN_NAMESPACE(ns) namespace ns {
+#define C4_END_NAMESPACE(ns) }
+
+#define C4_BEGIN_HIDDEN_NAMESPACE namespace /*hidden*/ {
+#define C4_END_HIDDEN_NAMESPACE } /* namespace hidden */
+
+//------------------------------------------------------------
+
+#ifndef C4_API
+#   if defined(_MSC_VER)
+#       if defined(C4_EXPORT)
+#           define C4_API __declspec(dllexport)
+#       elif defined(C4_IMPORT)
+#           define C4_API __declspec(dllimport)
+#       else
+#           define C4_API
+#       endif
+#   else
+#       define C4_API
+#   endif
+#endif
+
+#ifndef _MSC_VER  ///< @todo assuming gcc-like compiler. check it is actually so.
+/** for function attributes in GCC,
+ * @see https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes */
+/** for __builtin functions in GCC,
+ * @see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */
+#   define C4_RESTRICT __restrict__
+#   define C4_RESTRICT_FN __attribute__((restrict))
+#   define C4_NO_INLINE __attribute__((noinline))
+#   define C4_ALWAYS_INLINE inline __attribute__((always_inline))
+/** force inlining of every callee function */
+#   define C4_FLATTEN __atribute__((flatten))
+/** mark a function as hot, ie as having a visible impact in CPU time
+ * thus making it more likely to inline, etc
+ * @see http://stackoverflow.com/questions/15028990/semantics-of-gcc-hot-attribute */
+#   define C4_HOT __attribute__((hot))
+/** mark a function as cold, ie as NOT having a visible impact in CPU time
+ * @see http://stackoverflow.com/questions/15028990/semantics-of-gcc-hot-attribute */
+#   define C4_COLD __attribute__((cold))
+#   define C4_EXPECT(x, y) __builtin_expect(x, y) ///< @see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
+#   define C4_LIKELY(x)   __builtin_expect(x, 1)
+#   define C4_UNLIKELY(x) __builtin_expect(x, 0)
+#   define C4_UNREACHABLE() __builtin_unreachable()
+#   define C4_ATTR_FORMAT(...) //__attribute__((format (__VA_ARGS__))) ///< @see https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes
+#   define C4_NORETURN __attribute__((noreturn))
+#else
+#   define C4_RESTRICT __restrict
+#   define C4_RESTRICT_FN __declspec(restrict)
+#   define C4_NO_INLINE __declspec(noinline)
+#   define C4_ALWAYS_INLINE inline __forceinline
+/** these are not available in VS AFAIK */
+#   define C4_FLATTEN
+#   define C4_HOT         /** @todo */
+#   define C4_COLD        /** @todo */
+#   define C4_EXPECT(x, y) x /** @todo */
+#   define C4_LIKELY(x)   x /** @todo */
+#   define C4_UNLIKELY(x) x /** @todo */
+#   define C4_UNREACHABLE() /** @todo */
+#   define C4_ATTR_FORMAT(...) /** */
+#   define C4_NORETURN /** @todo */
+#endif
+
+#ifndef _MSC_VER
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __PRETTY_FUNCTION__
+#else /// @todo assuming gcc-like compiler. check it is actually so.
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __FUNCSIG__
+#endif
+
+/** prevent compiler warnings about a specific var being unused */
+#define C4_UNUSED(var) (void)var
+
+#if C4_CPP >= 17
+#define C4_STATIC_ASSERT(cond) static_assert(cond)
+#else
+#define C4_STATIC_ASSERT(cond) static_assert((cond), #cond)
+#endif
+#define C4_STATIC_ASSERT_MSG(cond, msg) static_assert((cond), #cond ": " msg)
+
+/** @def C4_DONT_OPTIMIZE idea lifted from GoogleBenchmark.
+ * @see https://github.com/google/benchmark/blob/master/include/benchmark/benchmark_api.h */
+namespace c4 {
+namespace detail {
+#ifdef __GNUC__
+#   define C4_DONT_OPTIMIZE(var) c4::detail::dont_optimize(var)
+template< class T >
+C4_ALWAYS_INLINE void dont_optimize(T const& value) { asm volatile("" : : "g"(value) : "memory"); }
+#else
+#   define C4_DONT_OPTIMIZE(var) c4::detail::use_char_pointer(reinterpret_cast< const char* >(&var))
+void use_char_pointer(char const volatile*);
+#endif
+} // namespace detail
+} // namespace c4
+
+/** @def C4_KEEP_EMPTY_LOOP prevent an empty loop from being optimized out.
+ * @see http://stackoverflow.com/a/7084193/5875572 */
+#ifndef _MSC_VER
+#   define C4_KEEP_EMPTY_LOOP { asm(""); }
+#else
+#   define C4_KEEP_EMPTY_LOOP { char c; C4_DONT_OPTIMIZE(c); }
+#endif
+
+/** @def C4_VA_LIST_REUSE_MUST_COPY
+ * @todo <jpmag> I strongly suspect that this is actually only in UNIX platforms. revisit this. */
+#ifdef __GNUC__
+#   define C4_VA_LIST_REUSE_MUST_COPY
+#endif
+
+#endif /* _C4_LANGUAGE_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/language.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/types.hpp
+// https://github.com/biojppm/c4core/src/c4/types.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_TYPES_HPP_
+#define _C4_TYPES_HPP_
+
+//included above:
+//#include <stdint.h>
+#include <stddef.h>
+//included above:
+//#include <type_traits>
+
+#if __cplusplus >= 201103L
+#include <utility>  // for integer_sequence and friends
+#endif
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/preprocessor.hpp
+//#include "c4/preprocessor.hpp"
+#if !defined(C4_PREPROCESSOR_HPP_) && !defined(_C4_PREPROCESSOR_HPP_)
+#error "amalgamate: file c4/preprocessor.hpp must have been included at this point"
+#endif /* C4_PREPROCESSOR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+
+/** @file types.hpp basic types, and utility macros and traits for types.
+ * @ingroup basic_headers */
+
+/** @defgroup types Type utilities */
+
+namespace c4 {
+
+/** @defgroup intrinsic_types Intrinsic types
+ * @ingroup types
+ * @{ */
+
+using cbyte = const char; /**< a constant byte */
+using  byte =       char; /**< a mutable byte */
+
+using  i8 =   int8_t;
+using i16 =  int16_t;
+using i32 =  int32_t;
+using i64 =  int64_t;
+using  u8 =  uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+using u64 = uint64_t;
+
+using f32 =  float;
+using f64 = double;
+
+using ssize_t = typename std::make_signed<size_t>::type;
+
+/** @} */
+
+//--------------------------------------------------
+
+/** @defgroup utility_types Utility types
+ * @ingroup types
+ * @{ */
+
+// some tag types
+
+/** a tag type for initializing the containers with variadic arguments a la
+ * initializer_list, minus the initializer_list overload problems.
+ */
+struct aggregate_t {};
+/** @see aggregate_t */
+constexpr const aggregate_t aggregate{};
+
+/** a tag type for specifying the initial capacity of allocatable contiguous storage */
+struct with_capacity_t {};
+/** @see with_capacity_t */
+constexpr const with_capacity_t with_capacity{};
+
+/** a tag type for disambiguating template parameter packs in variadic template overloads */
+struct varargs_t {};
+/** @see with_capacity_t */
+constexpr const varargs_t varargs{};
+
+
+//--------------------------------------------------
+
+/** whether a value should be used in place of a const-reference in argument passing. */
+template<class T>
+struct cref_uses_val
+{
+    enum { value = (
+    std::is_scalar<T>::value
+    ||
+    (
+#if C4_CPP >= 20
+        (std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value)
+#else
+        std::is_pod<T>::value
+#endif
+        &&
+        sizeof(T) <= sizeof(size_t))) };
+};
+/** utility macro to override the default behaviour for c4::fastcref<T>
+ @see fastcref */
+#define C4_CREF_USES_VAL(T) \
+template<>                  \
+struct cref_uses_val<T>     \
+{                           \
+    enum { value = true };  \
+};
+
+/** Whether to use pass-by-value or pass-by-const-reference in a function argument
+ * or return type. */
+template<class T>
+using fastcref = typename std::conditional<c4::cref_uses_val<T>::value, T, T const&>::type;
+
+//--------------------------------------------------
+
+/** Just what its name says. Useful sometimes as a default empty policy class. */
+struct EmptyStruct
+{
+    template<class... T> EmptyStruct(T && ...){}
+};
+
+/** Just what its name says. Useful sometimes as a default policy class to
+ * be inherited from. */
+struct EmptyStructVirtual
+{
+    virtual ~EmptyStructVirtual() = default;
+    template<class... T> EmptyStructVirtual(T && ...){}
+};
+
+
+/** */
+template<class T>
+struct inheritfrom : public T {};
+
+//--------------------------------------------------
+// Utilities to make a class obey size restrictions (eg, min size or size multiple of).
+// DirectX usually makes this restriction with uniform buffers.
+// This is also useful for padding to prevent false-sharing.
+
+/** how many bytes must be added to size such that the result is at least minsize? */
+C4_ALWAYS_INLINE constexpr size_t min_remainder(size_t size, size_t minsize) noexcept
+{
+    return size < minsize ? minsize-size : 0;
+}
+
+/** how many bytes must be added to size such that the result is a multiple of multipleof?  */
+C4_ALWAYS_INLINE constexpr size_t mult_remainder(size_t size, size_t multipleof) noexcept
+{
+    return (((size % multipleof) != 0) ? (multipleof-(size % multipleof)) : 0);
+}
+
+/* force the following class to be tightly packed. */
+#pragma pack(push, 1)
+/** pad a class with more bytes at the end.
+ * @see http://stackoverflow.com/questions/21092415/force-c-structure-to-pack-tightly */
+template<class T, size_t BytesToPadAtEnd>
+struct Padded : public T
+{
+    using T::T;
+    using T::operator=;
+    Padded(T const& val) : T(val) {}
+    Padded(T && val) : T(val) {}
+    char ___c4padspace___[BytesToPadAtEnd];
+};
+#pragma pack(pop)
+/** When the padding argument is 0, we cannot declare the char[] array. */
+template<class T>
+struct Padded<T, 0> : public T
+{
+    using T::T;
+    using T::operator=;
+    Padded(T const& val) : T(val) {}
+    Padded(T && val) : T(val) {}
+};
+
+/** make T have a size which is at least Min bytes */
+template<class T, size_t Min>
+using MinSized = Padded<T, min_remainder(sizeof(T), Min)>;
+
+/** make T have a size which is a multiple of Mult bytes */
+template<class T, size_t Mult>
+using MultSized = Padded<T, mult_remainder(sizeof(T), Mult)>;
+
+/** make T have a size which is simultaneously:
+ *  -bigger or equal than Min
+ *  -a multiple of Mult */
+template<class T, size_t Min, size_t Mult>
+using MinMultSized = MultSized<MinSized<T, Min>, Mult>;
+
+/** make T be suitable for use as a uniform buffer. (at least with DirectX). */
+template<class T>
+using UbufSized = MinMultSized<T, 64, 16>;
+
+
+//-----------------------------------------------------------------------------
+
+#define C4_NO_COPY_CTOR(ty) ty(ty const&) = delete
+#define C4_NO_MOVE_CTOR(ty) ty(ty     &&) = delete
+#define C4_NO_COPY_ASSIGN(ty) ty& operator=(ty const&) = delete
+#define C4_NO_MOVE_ASSIGN(ty) ty& operator=(ty     &&) = delete
+#define C4_DEFAULT_COPY_CTOR(ty) ty(ty const&) noexcept = default
+#define C4_DEFAULT_MOVE_CTOR(ty) ty(ty     &&) noexcept = default
+#define C4_DEFAULT_COPY_ASSIGN(ty) ty& operator=(ty const&) noexcept = default
+#define C4_DEFAULT_MOVE_ASSIGN(ty) ty& operator=(ty     &&) noexcept = default
+
+#define C4_NO_COPY_OR_MOVE_CTOR(ty) \
+    C4_NO_COPY_CTOR(ty); \
+    C4_NO_MOVE_CTOR(ty)
+
+#define C4_NO_COPY_OR_MOVE_ASSIGN(ty) \
+    C4_NO_COPY_ASSIGN(ty); \
+    C4_NO_MOVE_ASSIGN(ty)
+
+#define C4_NO_COPY_OR_MOVE(ty) \
+    C4_NO_COPY_OR_MOVE_CTOR(ty); \
+    C4_NO_COPY_OR_MOVE_ASSIGN(ty)
+
+#define C4_DEFAULT_COPY_AND_MOVE_CTOR(ty) \
+    C4_DEFAULT_COPY_CTOR(ty); \
+    C4_DEFAULT_MOVE_CTOR(ty)
+
+#define C4_DEFAULT_COPY_AND_MOVE_ASSIGN(ty) \
+    C4_DEFAULT_COPY_ASSIGN(ty); \
+    C4_DEFAULT_MOVE_ASSIGN(ty)
+
+#define C4_DEFAULT_COPY_AND_MOVE(ty) \
+    C4_DEFAULT_COPY_AND_MOVE_CTOR(ty); \
+    C4_DEFAULT_COPY_AND_MOVE_ASSIGN(ty)
+
+/** @see https://en.cppreference.com/w/cpp/named_req/TriviallyCopyable */
+#define C4_MUST_BE_TRIVIAL_COPY(ty) \
+    static_assert(std::is_trivially_copyable<ty>::value, #ty " must be trivially copyable")
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup traits_types Type traits utilities
+ * @ingroup types
+ * @{ */
+
+// http://stackoverflow.com/questions/10821380/is-t-an-instance-of-a-template-in-c
+template<template<typename...> class X, typename    T> struct is_instance_of_tpl             : std::false_type {};
+template<template<typename...> class X, typename... Y> struct is_instance_of_tpl<X, X<Y...>> : std::true_type {};
+
+//-----------------------------------------------------------------------------
+
+/** SFINAE. use this macro to enable a template function overload
+based on a compile-time condition.
+@code
+// define an overload for a non-pod type
+template<class T, C4_REQUIRE_T(std::is_pod<T>::value)>
+void foo() { std::cout << "pod type\n"; }
+
+// define an overload for a non-pod type
+template<class T, C4_REQUIRE_T(!std::is_pod<T>::value)>
+void foo() { std::cout << "nonpod type\n"; }
+
+struct non_pod
+{
+    non_pod() : name("asdfkjhasdkjh") {}
+    const char *name;
+};
+
+int main()
+{
+    foo<float>(); // prints "pod type"
+    foo<non_pod>(); // prints "nonpod type"
+}
+@endcode */
+#define C4_REQUIRE_T(cond) typename std::enable_if<cond, bool>::type* = nullptr
+
+/** enable_if for a return type
+ * @see C4_REQUIRE_T */
+#define C4_REQUIRE_R(cond, type_) typename std::enable_if<cond, type_>::type
+
+//-----------------------------------------------------------------------------
+/** define a traits class reporting whether a type provides a member typedef */
+#define C4_DEFINE_HAS_TYPEDEF(member_typedef)               \
+template<typename T>                                        \
+struct has_##stype                                          \
+{                                                           \
+private:                                                    \
+                                                            \
+    typedef char                      yes;                  \
+    typedef struct { char array[2]; } no;                   \
+                                                            \
+    template<typename C>                                    \
+    static yes _test(typename C::member_typedef*);          \
+                                                            \
+    template<typename C>                                    \
+    static no  _test(...);                                  \
+                                                            \
+public:                                                     \
+                                                            \
+    enum { value = (sizeof(_test<T>(0)) == sizeof(yes)) };  \
+                                                            \
+}
+
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup type_declarations Type declaration utilities
+ * @ingroup types
+ * @{ */
+
+#define _c4_DEFINE_ARRAY_TYPES_WITHOUT_ITERATOR(T, I)           \
+                                                                \
+    using size_type = I;                                        \
+    using ssize_type = typename std::make_signed<I>::type;      \
+    using difference_type = typename std::make_signed<I>::type; \
+                                                                \
+    using value_type = T;                                       \
+    using pointer = T*;                                         \
+    using const_pointer = T const*;                             \
+    using reference = T&;                                       \
+    using const_reference = T const&
+
+#define _c4_DEFINE_TUPLE_ARRAY_TYPES_WITHOUT_ITERATOR(interior_types, I) \
+                                                                        \
+    using size_type = I;                                                \
+    using ssize_type = typename std::make_signed<I>::type;              \
+    using difference_type = typename std::make_signed<I>::type;         \
+                                                                        \
+    template<I n> using value_type = typename std::tuple_element< n, std::tuple<interior_types...>>::type; \
+    template<I n> using pointer = value_type<n>*;                       \
+    template<I n> using const_pointer = value_type<n> const*;           \
+    template<I n> using reference = value_type<n>&;                     \
+    template<I n> using const_reference = value_type<n> const&
+
+
+#define _c4_DEFINE_ARRAY_TYPES(T, I)                                \
+                                                                    \
+    _c4_DEFINE_ARRAY_TYPES_WITHOUT_ITERATOR(T, I);                  \
+                                                                    \
+    using iterator = T*;                                            \
+    using const_iterator = T const*;                                \
+    using reverse_iterator = std::reverse_iterator<T*>;             \
+    using const_reverse_iterator = std::reverse_iterator<T const*>
+
+
+#define _c4_DEFINE_TUPLE_ARRAY_TYPES(interior_types, I)                 \
+                                                                        \
+    _c4_DEFINE_TUPLE_ARRAY_TYPES_WITHOUT_ITERATOR(interior_types, I);   \
+                                                                        \
+    template<I n> using iterator = value_type<n>*;                      \
+    template<I n> using const_iterator = value_type<n> const*;          \
+    template<I n> using reverse_iterator = std::reverse_iterator< value_type<n>*>; \
+    template<I n> using const_reverse_iterator = std::reverse_iterator< value_type<n> const*>
+
+
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup compatility_utilities Backport implementation of some Modern C++ utilities
+ * @ingroup types
+ * @{ */
+
+//-----------------------------------------------------------------------------
+// index_sequence and friends are available only for C++14 and later.
+// A C++11 implementation is provided here.
+// This implementation was copied over from clang.
+// see http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687
+
+#if __cplusplus > 201103L
+
+using std::integer_sequence;
+using std::index_sequence;
+using std::make_integer_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+/** C++11 implementation of integer sequence
+ * @see https://en.cppreference.com/w/cpp/utility/integer_sequence
+ * @see taken from clang: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687 */
+template<class _Tp, _Tp... _Ip>
+struct integer_sequence
+{
+    static_assert(std::is_integral<_Tp>::value,
+                  "std::integer_sequence can only be instantiated with an integral type" );
+    using value_type = _Tp;
+    static constexpr size_t size() noexcept { return sizeof...(_Ip); }
+};
+
+/** C++11 implementation of index sequence
+ * @see https://en.cppreference.com/w/cpp/utility/integer_sequence
+ * @see taken from clang: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687 */
+template<size_t... _Ip>
+using index_sequence = integer_sequence<size_t, _Ip...>;
+
+/** @cond DONT_DOCUMENT_THIS */
+namespace __detail {
+
+template<typename _Tp, size_t ..._Extra>
+struct __repeat;
+
+template<typename _Tp, _Tp ..._Np, size_t ..._Extra>
+struct __repeat<integer_sequence<_Tp, _Np...>, _Extra...>
+{
+    using type = integer_sequence<_Tp,
+                            _Np...,
+                            sizeof...(_Np) + _Np...,
+                            2 * sizeof...(_Np) + _Np...,
+                            3 * sizeof...(_Np) + _Np...,
+                            4 * sizeof...(_Np) + _Np...,
+                            5 * sizeof...(_Np) + _Np...,
+                            6 * sizeof...(_Np) + _Np...,
+                            7 * sizeof...(_Np) + _Np...,
+                            _Extra...>;
+};
+
+template<size_t _Np> struct __parity;
+template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
+
+template<> struct __make<0> { using type = integer_sequence<size_t>; };
+template<> struct __make<1> { using type = integer_sequence<size_t, 0>; };
+template<> struct __make<2> { using type = integer_sequence<size_t, 0, 1>; };
+template<> struct __make<3> { using type = integer_sequence<size_t, 0, 1, 2>; };
+template<> struct __make<4> { using type = integer_sequence<size_t, 0, 1, 2, 3>; };
+template<> struct __make<5> { using type = integer_sequence<size_t, 0, 1, 2, 3, 4>; };
+template<> struct __make<6> { using type = integer_sequence<size_t, 0, 1, 2, 3, 4, 5>; };
+template<> struct __make<7> { using type = integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6>; };
+
+template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
+template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
+template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
+
+template<typename _Tp, typename _Up>
+struct __convert
+{
+    template<typename> struct __result;
+    template<_Tp ..._Np> struct __result<integer_sequence<_Tp, _Np...>>
+    {
+        using type = integer_sequence<_Up, _Np...>;
+    };
+};
+
+template<typename _Tp>
+struct __convert<_Tp, _Tp>
+{
+    template<typename _Up> struct __result
+    {
+         using type = _Up;
+    };
+};
+
+template<typename _Tp, _Tp _Np>
+using __make_integer_sequence_unchecked = typename __detail::__convert<size_t, _Tp>::template __result<typename __detail::__make<_Np>::type>::type;
+
+template<class _Tp, _Tp _Ep>
+struct __make_integer_sequence
+{
+    static_assert(std::is_integral<_Tp>::value,
+                  "std::make_integer_sequence can only be instantiated with an integral type" );
+    static_assert(0 <= _Ep, "std::make_integer_sequence input shall not be negative");
+    typedef __make_integer_sequence_unchecked<_Tp, _Ep> type;
+};
+
+} // namespace __detail
+/** @endcond */
+
+
+/** C++11 implementation of index sequence
+ * @see https://en.cppreference.com/w/cpp/utility/integer_sequence
+ * @see taken from clang: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687 */
+template<class _Tp, _Tp _Np>
+using make_integer_sequence = typename __detail::__make_integer_sequence<_Tp, _Np>::type;
+
+/** C++11 implementation of index sequence
+ * @see https://en.cppreference.com/w/cpp/utility/integer_sequence
+ * @see taken from clang: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687 */
+template<size_t _Np>
+using make_index_sequence = make_integer_sequence<size_t, _Np>;
+
+/** C++11 implementation of index sequence
+ * @see https://en.cppreference.com/w/cpp/utility/integer_sequence
+ * @see taken from clang: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?revision=211563&view=markup#l687 */
+template<class... _Tp>
+using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
+#endif
+
+/** @} */
+
+
+} // namespace c4
+
+#endif /* _C4_TYPES_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/types.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/config.hpp
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_CONFIG_HPP_
+#define _C4_CONFIG_HPP_
+
+/** @defgroup basic_headers Basic headers
+ * @brief Headers providing basic macros, platform+cpu+compiler information,
+ * C++ facilities and basic typedefs. */
+
+/** @file config.hpp Contains configuration defines and includes the basic_headers.
+ * @ingroup basic_headers */
+
+//#define C4_DEBUG
+
+#define C4_ERROR_SHOWS_FILELINE
+//#define C4_ERROR_SHOWS_FUNC
+//#define C4_ERROR_THROWS_EXCEPTION
+//#define C4_NO_ALLOC_DEFAULTS
+//#define C4_REDEFINE_CPPNEW
+
+#ifndef C4_SIZE_TYPE
+#   define C4_SIZE_TYPE size_t
+#endif
+
+#ifndef C4_STR_SIZE_TYPE
+#   define C4_STR_SIZE_TYPE C4_SIZE_TYPE
+#endif
+
+#ifndef C4_TIME_TYPE
+#   define C4_TIME_TYPE double
+#endif
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/export.hpp
+//#include "c4/export.hpp"
+#if !defined(C4_EXPORT_HPP_) && !defined(_C4_EXPORT_HPP_)
+#error "amalgamate: file c4/export.hpp must have been included at this point"
+#endif /* C4_EXPORT_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/preprocessor.hpp
+//#include "c4/preprocessor.hpp"
+#if !defined(C4_PREPROCESSOR_HPP_) && !defined(_C4_PREPROCESSOR_HPP_)
+#error "amalgamate: file c4/preprocessor.hpp must have been included at this point"
+#endif /* C4_PREPROCESSOR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/platform.hpp
+//#include "c4/platform.hpp"
+#if !defined(C4_PLATFORM_HPP_) && !defined(_C4_PLATFORM_HPP_)
+#error "amalgamate: file c4/platform.hpp must have been included at this point"
+#endif /* C4_PLATFORM_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/cpu.hpp
+//#include "c4/cpu.hpp"
+//#if !defined(C4_CPU_HPP_) && !defined(_C4_CPU_HPP_)
+//#error "amalgamate: file c4/cpu.hpp must have been included at this point"
+//#endif /* C4_CPU_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/compiler.hpp
+//#include "c4/compiler.hpp"
+#if !defined(C4_COMPILER_HPP_) && !defined(_C4_COMPILER_HPP_)
+#error "amalgamate: file c4/compiler.hpp must have been included at this point"
+#endif /* C4_COMPILER_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/types.hpp
+//#include "c4/types.hpp"
+#if !defined(C4_TYPES_HPP_) && !defined(_C4_TYPES_HPP_)
+#error "amalgamate: file c4/types.hpp must have been included at this point"
+#endif /* C4_TYPES_HPP_ */
+
+
+#endif // _C4_CONFIG_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/config.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/ext/debugbreak/debugbreak.h
+// https://github.com/biojppm/c4core/src/c4/ext/debugbreak/debugbreak.h
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+/* Copyright (c) 2011-2021, Scott Tsai
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef DEBUG_BREAK_H
+#define DEBUG_BREAK_H
+
+#ifdef _MSC_VER
+
+#define debug_break __debugbreak
+
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DEBUG_BREAK_USE_TRAP_INSTRUCTION 1
+#define DEBUG_BREAK_USE_BULTIN_TRAP      2
+#define DEBUG_BREAK_USE_SIGTRAP          3
+
+#if defined(__i386__) || defined(__x86_64__)
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__inline__ static void trap_instruction(void)
+{
+	__asm__ volatile("int $0x03");
+}
+#elif defined(__thumb__)
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+/* FIXME: handle __THUMB_INTERWORK__ */
+__attribute__((always_inline))
+__inline__ static void trap_instruction(void)
+{
+	/* See 'arm-linux-tdep.c' in GDB source.
+	 * Both instruction sequences below work. */
+#if 1
+	/* 'eabi_linux_thumb_le_breakpoint' */
+	__asm__ volatile(".inst 0xde01");
+#else
+	/* 'eabi_linux_thumb2_le_breakpoint' */
+	__asm__ volatile(".inst.w 0xf7f0a000");
+#endif
+
+	/* Known problem:
+	 * After a breakpoint hit, can't 'stepi', 'step', or 'continue' in GDB.
+	 * 'step' would keep getting stuck on the same instruction.
+	 *
+	 * Workaround: use the new GDB commands 'debugbreak-step' and
+	 * 'debugbreak-continue' that become available
+	 * after you source the script from GDB:
+	 *
+	 * $ gdb -x debugbreak-gdb.py <... USUAL ARGUMENTS ...>
+	 *
+	 * 'debugbreak-step' would jump over the breakpoint instruction with
+	 * roughly equivalent of:
+	 * (gdb) set $instruction_len = 2
+	 * (gdb) tbreak *($pc + $instruction_len)
+	 * (gdb) jump   *($pc + $instruction_len)
+	 */
+}
+#elif defined(__arm__) && !defined(__thumb__)
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__attribute__((always_inline))
+__inline__ static void trap_instruction(void)
+{
+	/* See 'arm-linux-tdep.c' in GDB source,
+	 * 'eabi_linux_arm_le_breakpoint' */
+	__asm__ volatile(".inst 0xe7f001f0");
+	/* Known problem:
+	 * Same problem and workaround as Thumb mode */
+}
+#elif defined(__aarch64__) && defined(__APPLE__)
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_BULTIN_DEBUGTRAP
+#elif defined(__aarch64__)
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__attribute__((always_inline))
+__inline__ static void trap_instruction(void)
+{
+	/* See 'aarch64-tdep.c' in GDB source,
+	 * 'aarch64_default_breakpoint' */
+	__asm__ volatile(".inst 0xd4200000");
+}
+#elif defined(__powerpc__)
+	/* PPC 32 or 64-bit, big or little endian */
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__attribute__((always_inline))
+__inline__ static void trap_instruction(void)
+{
+	/* See 'rs6000-tdep.c' in GDB source,
+	 * 'rs6000_breakpoint' */
+	__asm__ volatile(".4byte 0x7d821008");
+
+	/* Known problem:
+	 * After a breakpoint hit, can't 'stepi', 'step', or 'continue' in GDB.
+	 * 'step' stuck on the same instruction ("twge r2,r2").
+	 *
+	 * The workaround is the same as ARM Thumb mode: use debugbreak-gdb.py
+	 * or manually jump over the instruction. */
+}
+#elif defined(__riscv)
+	/* RISC-V 32 or 64-bit, whether the "C" extension
+	 * for compressed, 16-bit instructions are supported or not */
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__attribute__((always_inline))
+__inline__ static void trap_instruction(void)
+{
+	/* See 'riscv-tdep.c' in GDB source,
+	 * 'riscv_sw_breakpoint_from_kind' */
+	__asm__ volatile(".4byte 0x00100073");
+}
+#else
+	#define DEBUG_BREAK_IMPL DEBUG_BREAK_USE_SIGTRAP
+#endif
+
+
+#ifndef DEBUG_BREAK_IMPL
+#error "debugbreak.h is not supported on this target"
+#elif DEBUG_BREAK_IMPL == DEBUG_BREAK_USE_TRAP_INSTRUCTION
+__attribute__((always_inline))
+__inline__ static void debug_break(void)
+{
+	trap_instruction();
+}
+#elif DEBUG_BREAK_IMPL == DEBUG_BREAK_USE_BULTIN_DEBUGTRAP
+__attribute__((always_inline))
+__inline__ static void debug_break(void)
+{
+	__builtin_debugtrap();
+}
+#elif DEBUG_BREAK_IMPL == DEBUG_BREAK_USE_BULTIN_TRAP
+__attribute__((always_inline))
+__inline__ static void debug_break(void)
+{
+	__builtin_trap();
+}
+#elif DEBUG_BREAK_IMPL == DEBUG_BREAK_USE_SIGTRAP
+#include <signal.h>
+__attribute__((always_inline))
+__inline__ static void debug_break(void)
+{
+	raise(SIGTRAP);
+}
+#else
+#error "invalid DEBUG_BREAK_IMPL value"
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifdef _MSC_VER */
+
+#endif /* ifndef DEBUG_BREAK_H */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/ext/debugbreak/debugbreak.h)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/error.hpp
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_ERROR_HPP_
+#define _C4_ERROR_HPP_
+
+/** @file error.hpp Facilities for error reporting and runtime assertions. */
+
+/** @defgroup error_checking Error checking */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+
+#ifdef _DOXYGEN_
+    /** if this is defined and exceptions are enabled, then calls to C4_ERROR()
+     * will throw an exception
+     * @ingroup error_checking */
+#   define C4_EXCEPTIONS_ENABLED
+    /** if this is defined and exceptions are enabled, then calls to C4_ERROR()
+     *  will throw an exception
+     * @see C4_EXCEPTIONS_ENABLED
+     * @ingroup error_checking */
+#   define C4_ERROR_THROWS_EXCEPTION
+    /** evaluates to noexcept when C4_ERROR might be called and
+     * exceptions are disabled. Otherwise, defaults to nothing.
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT
+#endif // _DOXYGEN_
+
+#if defined(C4_EXCEPTIONS_ENABLED) && defined(C4_ERROR_THROWS_EXCEPTION)
+#   define C4_NOEXCEPT
+#else
+#   define C4_NOEXCEPT noexcept
+#endif
+
+
+namespace c4 {
+namespace detail {
+struct fail_type__ {};
+} // detail
+} // c4
+#define C4_STATIC_ERROR(dummy_type, errmsg)                             \
+    static_assert(std::is_same<dummy_type, c4::detail::fail_type__>::value, errmsg)
+
+
+//-----------------------------------------------------------------------------
+
+#define C4_ASSERT_SAME_TYPE(ty1, ty2)                       \
+    C4_STATIC_ASSERT(std::is_same<ty1 C4_COMMA_X ty2>::value)
+
+#define C4_ASSERT_DIFF_TYPE(ty1, ty2)                       \
+    C4_STATIC_ASSERT( ! std::is_same<ty1 C4_COMMA_X ty2>::value)
+
+
+//-----------------------------------------------------------------------------
+
+#ifdef _DOXYGEN_
+/** utility macro that triggers a breakpoint when
+ * the debugger is attached and NDEBUG is not defined.
+ * @ingroup error_checking */
+#   define C4_DEBUG_BREAK()
+#endif // _DOXYGEN_
+
+
+#ifdef NDEBUG
+#   define C4_DEBUG_BREAK()
+#else
+#   ifdef __clang__
+#       pragma clang diagnostic push
+#       if !defined(__APPLE_CC__)
+#           if __clang_major__ >= 10
+#               pragma clang diagnostic ignored "-Wgnu-inline-cpp-without-extern" // debugbreak/debugbreak.h:50:16: error: 'gnu_inline' attribute without 'extern' in C++ treated as externally available, this changed in Clang 10 [-Werror,-Wgnu-inline-cpp-without-extern]
+#           endif
+#       else
+#           if __clang_major__ >= 13
+#               pragma clang diagnostic ignored "-Wgnu-inline-cpp-without-extern" // debugbreak/debugbreak.h:50:16: error: 'gnu_inline' attribute without 'extern' in C++ treated as externally available, this changed in Clang 10 [-Werror,-Wgnu-inline-cpp-without-extern]
+#           endif
+#       endif
+#   elif defined(__GNUC__)
+#   endif
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/ext/debugbreak/debugbreak.h
+//#   include <c4/ext/debugbreak/debugbreak.h>
+#if !defined(DEBUG_BREAK_H) && !defined(_DEBUG_BREAK_H)
+#error "amalgamate: file c4/ext/debugbreak/debugbreak.h must have been included at this point"
+#endif /* DEBUG_BREAK_H */
+
+#   define C4_DEBUG_BREAK() if(c4::is_debugger_attached()) { ::debug_break(); }
+#   ifdef __clang__
+#       pragma clang diagnostic pop
+#   elif defined(__GNUC__)
+#   endif
+#endif
+
+namespace c4 {
+C4CORE_EXPORT bool is_debugger_attached();
+} // namespace c4
+
+
+//-----------------------------------------------------------------------------
+
+#ifdef __clang__
+    /* NOTE: using , ## __VA_ARGS__ to deal with zero-args calls to
+     * variadic macros is not portable, but works in clang, gcc, msvc, icc.
+     * clang requires switching off compiler warnings for pedantic mode.
+     * @see http://stackoverflow.com/questions/32047685/variadic-macro-without-arguments */
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" // warning: token pasting of ',' and __VA_ARGS__ is a GNU extension
+#elif defined(__GNUC__)
+    /* GCC also issues a warning for zero-args calls to variadic macros.
+     * This warning is switched on with -pedantic and apparently there is no
+     * easy way to turn it off as with clang. But marking this as a system
+     * header works.
+     * @see https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html
+     * @see http://stackoverflow.com/questions/35587137/ */
+#   pragma GCC system_header
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+
+typedef enum : uint32_t {
+    /** when an error happens and the debugger is attached, call C4_DEBUG_BREAK().
+     * Without effect otherwise. */
+    ON_ERROR_DEBUGBREAK = 0x01 << 0,
+    /** when an error happens log a message. */
+    ON_ERROR_LOG = 0x01 << 1,
+    /** when an error happens invoke a callback if it was set with
+     * set_error_callback(). */
+    ON_ERROR_CALLBACK = 0x01 << 2,
+    /** when an error happens call std::terminate(). */
+    ON_ERROR_ABORT = 0x01 << 3,
+    /** when an error happens and exceptions are enabled throw an exception.
+     * Without effect otherwise. */
+    ON_ERROR_THROW = 0x01 << 4,
+    /** the default flags. */
+    ON_ERROR_DEFAULTS = ON_ERROR_DEBUGBREAK|ON_ERROR_LOG|ON_ERROR_CALLBACK|ON_ERROR_ABORT
+} ErrorFlags_e;
+using error_flags = uint32_t;
+C4CORE_EXPORT void set_error_flags(error_flags f);
+C4CORE_EXPORT error_flags get_error_flags();
+
+
+using error_callback_type = void (*)(const char* msg, size_t msg_size);
+C4CORE_EXPORT void set_error_callback(error_callback_type cb);
+C4CORE_EXPORT error_callback_type get_error_callback();
+
+
+//-----------------------------------------------------------------------------
+/** RAII class controling the error settings inside a scope. */
+struct ScopedErrorSettings
+{
+    error_flags m_flags;
+    error_callback_type m_callback;
+
+    explicit ScopedErrorSettings(error_callback_type cb)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_callback(cb);
+    }
+    explicit ScopedErrorSettings(error_flags flags)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_flags(flags);
+    }
+    explicit ScopedErrorSettings(error_flags flags, error_callback_type cb)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_flags(flags);
+        set_error_callback(cb);
+    }
+    ~ScopedErrorSettings()
+    {
+        set_error_flags(m_flags);
+        set_error_callback(m_callback);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+
+/** source location */
+struct srcloc;
+
+C4CORE_EXPORT void handle_error(srcloc s, const char *fmt, ...);
+C4CORE_EXPORT void handle_warning(srcloc s, const char *fmt, ...);
+
+
+#   define C4_ERROR(msg, ...)                               \
+    do {                                                    \
+        if(c4::get_error_flags() & c4::ON_ERROR_DEBUGBREAK) \
+        {                                                   \
+            C4_DEBUG_BREAK()                                \
+        }                                                   \
+        c4::handle_error(C4_SRCLOC(), msg, ## __VA_ARGS__); \
+    } while(0)
+
+
+#   define C4_WARNING(msg, ...)                             \
+    c4::handle_warning(C4_SRCLOC(), msg, ## __VA_ARGS__)
+
+
+#if defined(C4_ERROR_SHOWS_FILELINE) && defined(C4_ERROR_SHOWS_FUNC)
+
+struct srcloc
+{
+    const char *file = "";
+    const char *func = "";
+    int line = 0;
+};
+#define C4_SRCLOC() c4::srcloc{__FILE__, C4_PRETTY_FUNC, __LINE__}
+
+#elif defined(C4_ERROR_SHOWS_FILELINE)
+
+struct srcloc
+{
+    const char *file;
+    int line;
+};
+#define C4_SRCLOC() c4::srcloc{__FILE__, __LINE__}
+
+#elif ! defined(C4_ERROR_SHOWS_FUNC)
+
+struct srcloc
+{
+};
+#define C4_SRCLOC() c4::srcloc()
+
+#else
+#   error not implemented
+#endif
+
+
+//-----------------------------------------------------------------------------
+// assertions
+
+// Doxygen needs this so that only one definition counts
+#ifdef _DOXYGEN_
+    /** Explicitly enables assertions, independently of NDEBUG status.
+     * This is meant to allow enabling assertions even when NDEBUG is defined.
+     * Defaults to undefined.
+     * @ingroup error_checking */
+#   define C4_USE_ASSERT
+    /** assert that a condition is true; this is turned off when NDEBUG
+     * is defined and C4_USE_ASSERT is not true.
+     * @ingroup error_checking  */
+#   define C4_ASSERT
+    /** same as C4_ASSERT(), additionally prints a printf-formatted message
+     * @ingroup error_checking */
+#   define C4_ASSERT_MSG
+    /** evaluates to C4_NOEXCEPT when C4_XASSERT is disabled; otherwise, defaults
+     * to noexcept
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT_A
+#endif // _DOXYGEN_
+
+#ifndef C4_USE_ASSERT
+#   ifdef NDEBUG
+#       define C4_USE_ASSERT 0
+#   else
+#       define C4_USE_ASSERT 1
+#   endif
+#endif
+
+#if C4_USE_ASSERT
+#   define C4_ASSERT(cond) C4_CHECK(cond)
+#   define C4_ASSERT_MSG(cond, /*fmt, */...) C4_CHECK_MSG(cond, ## __VA_ARGS__)
+#   define C4_ASSERT_IF(predicate, cond) if(predicate) { C4_ASSERT(cond); }
+#   define C4_NOEXCEPT_A C4_NOEXCEPT
+#else
+#   define C4_ASSERT(cond)
+#   define C4_ASSERT_MSG(cond, /*fmt, */...)
+#   define C4_ASSERT_IF(predicate, cond)
+#   define C4_NOEXCEPT_A noexcept
+#endif
+
+
+//-----------------------------------------------------------------------------
+// extreme assertions
+
+// Doxygen needs this so that only one definition counts
+#ifdef _DOXYGEN_
+    /** Explicitly enables extreme assertions; this is meant to allow enabling
+     * assertions even when NDEBUG is defined. Defaults to undefined.
+     * @ingroup error_checking */
+#   define C4_USE_XASSERT
+    /** extreme assertion: can be switched off independently of
+     * the regular assertion; use for example for bounds checking in hot code.
+     * Turned on only when C4_USE_XASSERT is defined
+     * @ingroup error_checking */
+#   define C4_XASSERT
+    /** same as C4_XASSERT(), and additionally prints a printf-formatted message
+     * @ingroup error_checking */
+#   define C4_XASSERT_MSG
+    /** evaluates to C4_NOEXCEPT when C4_XASSERT is disabled; otherwise, defaults to noexcept
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT_X
+#endif // _DOXYGEN_
+
+#ifndef C4_USE_XASSERT
+#   define C4_USE_XASSERT C4_USE_ASSERT
+#endif
+
+#if C4_USE_XASSERT
+#   define C4_XASSERT(cond) C4_CHECK(cond)
+#   define C4_XASSERT_MSG(cond, /*fmt, */...) C4_CHECK_MSG(cond, ## __VA_ARGS__)
+#   define C4_XASSERT_IF(predicate, cond) if(predicate) { C4_XASSERT(cond); }
+#   define C4_NOEXCEPT_X C4_NOEXCEPT
+#else
+#   define C4_XASSERT(cond)
+#   define C4_XASSERT_MSG(cond, /*fmt, */...)
+#   define C4_XASSERT_IF(predicate, cond)
+#   define C4_NOEXCEPT_X noexcept
+#endif
+
+
+//-----------------------------------------------------------------------------
+// checks: never switched-off
+
+/** Check that a condition is true, or raise an error when not
+ * true. Unlike C4_ASSERT(), this check is not disabled in non-debug
+ * builds.
+ * @see C4_ASSERT
+ * @ingroup error_checking
+ *
+ * @todo add constexpr-compatible compile-time assert:
+ * https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+ */
+#define C4_CHECK(cond)                              \
+    do {                                            \
+        if(C4_UNLIKELY(!(cond)))                    \
+        {                                           \
+            C4_ERROR("check failed: %s", #cond);    \
+        }                                           \
+    } while(0)
+
+
+/** like C4_CHECK(), and additionally log a printf-style message.
+ * @see C4_CHECK
+ * @ingroup error_checking */
+#define C4_CHECK_MSG(cond, fmt, ...)                                    \
+    do {                                                                \
+        if(C4_UNLIKELY(!(cond)))                                        \
+        {                                                               \
+            C4_ERROR("check failed: " #cond "\n" fmt, ## __VA_ARGS__);  \
+        }                                                               \
+    } while(0)
+
+
+//-----------------------------------------------------------------------------
+// Common error conditions
+
+#define C4_NOT_IMPLEMENTED() C4_ERROR("NOT IMPLEMENTED")
+#define C4_NOT_IMPLEMENTED_MSG(/*msg, */...) C4_ERROR("NOT IMPLEMENTED: " ## __VA_ARGS__)
+#define C4_NOT_IMPLEMENTED_IF(condition) do { if(C4_UNLIKELY(condition)) { C4_ERROR("NOT IMPLEMENTED"); } } while(0)
+#define C4_NOT_IMPLEMENTED_IF_MSG(condition, /*msg, */...) do { if(C4_UNLIKELY(condition)) { C4_ERROR("NOT IMPLEMENTED: " ## __VA_ARGS__); } } while(0)
+
+#define C4_NEVER_REACH() do { C4_ERROR("never reach this point"); C4_UNREACHABLE(); } while(0)
+#define C4_NEVER_REACH_MSG(/*msg, */...) do { C4_ERROR("never reach this point: " ## __VA_ARGS__); C4_UNREACHABLE(); } while(0)
+
+
+
+//-----------------------------------------------------------------------------
+// helpers for warning suppression
+// idea adapted from https://github.com/onqtam/doctest/
+
+
+#ifdef C4_MSVC
+#define C4_SUPPRESS_WARNING_MSVC_PUSH __pragma(warning(push))
+#define C4_SUPPRESS_WARNING_MSVC(w)  __pragma(warning(disable : w))
+#define C4_SUPPRESS_WARNING_MSVC_POP __pragma(warning(pop))
+#define C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(w)   \
+    C4_SUPPRESS_WARNING_MSVC_PUSH               \
+    C4_SUPPRESS_WARNING_MSVC(w)
+#else // C4_MSVC
+#define C4_SUPPRESS_WARNING_MSVC_PUSH
+#define C4_SUPPRESS_WARNING_MSVC(w)
+#define C4_SUPPRESS_WARNING_MSVC_POP
+#define C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(w)
+#endif // C4_MSVC
+
+
+#ifdef C4_CLANG
+#define C4_PRAGMA_TO_STR(x) _Pragma(#x)
+#define C4_SUPPRESS_WARNING_CLANG_PUSH _Pragma("clang diagnostic push")
+#define C4_SUPPRESS_WARNING_CLANG(w) C4_PRAGMA_TO_STR(clang diagnostic ignored w)
+#define C4_SUPPRESS_WARNING_CLANG_POP _Pragma("clang diagnostic pop")
+#define C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)  \
+    C4_SUPPRESS_WARNING_CLANG_PUSH              \
+    C4_SUPPRESS_WARNING_CLANG(w)
+#else // C4_CLANG
+#define C4_SUPPRESS_WARNING_CLANG_PUSH
+#define C4_SUPPRESS_WARNING_CLANG(w)
+#define C4_SUPPRESS_WARNING_CLANG_POP
+#define C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)
+#endif // C4_CLANG
+
+
+#ifdef C4_GCC
+#define C4_PRAGMA_TO_STR(x) _Pragma(#x)
+#define C4_SUPPRESS_WARNING_GCC_PUSH _Pragma("GCC diagnostic push")
+#define C4_SUPPRESS_WARNING_GCC(w) C4_PRAGMA_TO_STR(GCC diagnostic ignored w)
+#define C4_SUPPRESS_WARNING_GCC_POP _Pragma("GCC diagnostic pop")
+#define C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)    \
+    C4_SUPPRESS_WARNING_GCC_PUSH                \
+    C4_SUPPRESS_WARNING_GCC(w)
+#else // C4_GCC
+#define C4_SUPPRESS_WARNING_GCC_PUSH
+#define C4_SUPPRESS_WARNING_GCC(w)
+#define C4_SUPPRESS_WARNING_GCC_POP
+#define C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)
+#endif // C4_GCC
+
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_PUSH \
+    C4_SUPPRESS_WARNING_GCC_PUSH     \
+    C4_SUPPRESS_WARNING_CLANG_PUSH
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG(w) \
+    C4_SUPPRESS_WARNING_GCC(w)     \
+    C4_SUPPRESS_WARNING_CLANG(w)
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH(w) \
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)     \
+    C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_POP \
+    C4_SUPPRESS_WARNING_GCC_POP     \
+    C4_SUPPRESS_WARNING_CLANG_POP
+
+} // namespace c4
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif /* _C4_ERROR_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/error.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/memory_util.hpp
+// https://github.com/biojppm/c4core/src/c4/memory_util.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_MEMORY_UTIL_HPP_
+#define _C4_MEMORY_UTIL_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+
+//included above:
+//#include <string.h>
+
+/** @file memory_util.hpp Some memory utilities. */
+
+namespace c4 {
+
+/** set the given memory to zero */
+C4_ALWAYS_INLINE void mem_zero(void* mem, size_t num_bytes)
+{
+    memset(mem, 0, num_bytes);
+}
+/** set the given memory to zero */
+template<class T>
+C4_ALWAYS_INLINE void mem_zero(T* mem, size_t num_elms)
+{
+    memset(mem, 0, sizeof(T) * num_elms);
+}
+/** set the given memory to zero */
+template<class T>
+C4_ALWAYS_INLINE void mem_zero(T* mem)
+{
+    memset(mem, 0, sizeof(T));
+}
+
+bool mem_overlaps(void const* a, void const* b, size_t sza, size_t szb);
+
+void mem_repeat(void* dest, void const* pattern, size_t pattern_size, size_t num_times);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class T>
+bool is_aligned(T *ptr, size_t alignment=alignof(T))
+{
+    return (uintptr_t(ptr) & (alignment - 1)) == 0u;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// least significant bit
+
+/** least significant bit; this function is constexpr-14 because of the local
+ * variable */
+template<class I>
+C4_CONSTEXPR14 I lsb(I v)
+{
+    if(!v) return 0;
+    I b = 0;
+    while((v & I(1)) == I(0))
+    {
+        v >>= 1;
+        ++b;
+    }
+    return b;
+}
+
+namespace detail {
+
+template<class I, I val, I num_bits, bool finished>
+struct _lsb11;
+
+template<class I, I val, I num_bits>
+struct _lsb11< I, val, num_bits, false>
+{
+    enum : I { num = _lsb11<I, (val>>1), num_bits+I(1), (((val>>1)&I(1))!=I(0))>::num };
+};
+
+template<class I, I val, I num_bits>
+struct _lsb11<I, val, num_bits, true>
+{
+    enum : I { num = num_bits };
+};
+
+} // namespace detail
+
+
+/** TMP version of lsb(); this needs to be implemented with template
+ * meta-programming because C++11 cannot use a constexpr function with
+ * local variables
+ * @see lsb */
+template<class I, I number>
+struct lsb11
+{
+    static_assert(number != 0, "lsb: number must be nonzero");
+    enum : I { value = detail::_lsb11<I, number, 0, ((number&I(1))!=I(0))>::num};
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// most significant bit
+
+/** most significant bit; this function is constexpr-14 because of the local
+ * variable
+ * @todo implement faster version
+ * @see https://stackoverflow.com/questions/2589096/find-most-significant-bit-left-most-that-is-set-in-a-bit-array
+ */
+template<class I>
+C4_CONSTEXPR14 I msb(I v)
+{
+    // TODO:
+    //
+    //int n;
+    //if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, n |= 32;
+    //if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, n |= 16;
+    //if(input_num & uint64_t(            0xff00)) input_num >>=  8, n |=  8;
+    //if(input_num & uint64_t(              0xf0)) input_num >>=  4, n |=  4;
+    //if(input_num & uint64_t(               0xc)) input_num >>=  2, n |=  2;
+    //if(input_num & uint64_t(               0x2)) input_num >>=  1, n |=  1;
+    if(!v) return static_cast<I>(-1);
+    I b = 0;
+    while(v != 0)
+    {
+        v >>= 1;
+        ++b;
+    }
+    return b-1;
+}
+
+namespace detail {
+
+template<class I, I val, I num_bits, bool finished>
+struct _msb11;
+
+template<class I, I val, I num_bits>
+struct _msb11< I, val, num_bits, false>
+{
+    enum : I { num = _msb11<I, (val>>1), num_bits+I(1), ((val>>1)==I(0))>::num };
+};
+
+template<class I, I val, I num_bits>
+struct _msb11<I, val, num_bits, true>
+{
+    static_assert(val == 0, "bad implementation");
+    enum : I { num = num_bits-1 };
+};
+
+} // namespace detail
+
+
+/** TMP version of msb(); this needs to be implemented with template
+ * meta-programming because C++11 cannot use a constexpr function with
+ * local variables
+ * @see msb */
+template<class I, I number>
+struct msb11
+{
+    enum : I { value = detail::_msb11<I, number, 0, (number==I(0))>::num };
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** return a mask with all bits set [first_bit,last_bit[; this function
+ * is constexpr-14 because of the local variables */
+template<class I>
+C4_CONSTEXPR14 I contiguous_mask(I first_bit, I last_bit)
+{
+    I r = 0;
+    constexpr const I o = 1;
+    for(I i = first_bit; i < last_bit; ++i)
+    {
+        r |= (o << i);
+    }
+    return r;
+}
+
+
+namespace detail {
+
+template<class I, I val, I first, I last, bool finished>
+struct _ctgmsk11;
+
+template<class I, I val, I first, I last>
+struct _ctgmsk11< I, val, first, last, true>
+{
+    enum : I { value = _ctgmsk11<I, val|(I(1)<<first), first+I(1), last, (first+1!=last)>::value };
+};
+
+template<class I, I val, I first, I last>
+struct _ctgmsk11< I, val, first, last, false>
+{
+    enum : I { value = val };
+};
+
+} // namespace detail
+
+
+/** TMP version of contiguous_mask(); this needs to be implemented with template
+ * meta-programming because C++11 cannot use a constexpr function with
+ * local variables
+ * @see contiguous_mask */
+template<class I, I first_bit, I last_bit>
+struct contiguous_mask11
+{
+    enum : I { value = detail::_ctgmsk11<I, I(0), first_bit, last_bit, (first_bit!=last_bit)>::value };
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** use Empty Base Class Optimization to reduce the size of a pair of
+ * potentially empty types*/
+
+namespace detail {
+typedef enum {
+    tpc_same,
+    tpc_same_empty,
+    tpc_both_empty,
+    tpc_first_empty,
+    tpc_second_empty,
+    tpc_general
+} TightPairCase_e;
+
+template<class First, class Second>
+constexpr TightPairCase_e tpc_which_case()
+{
+    return std::is_same<First, Second>::value ?
+               std::is_empty<First>::value ?
+                   tpc_same_empty
+                   :
+                   tpc_same
+               :
+               std::is_empty<First>::value && std::is_empty<Second>::value ?
+                   tpc_both_empty
+                   :
+                   std::is_empty<First>::value ?
+                       tpc_first_empty
+                       :
+                       std::is_empty<Second>::value ?
+                           tpc_second_empty
+                           :
+                           tpc_general
+           ;
+}
+
+template<class First, class Second, TightPairCase_e Case>
+struct tight_pair
+{
+private:
+
+    First m_first;
+    Second m_second;
+
+public:
+
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : m_first(), m_second() {}
+    tight_pair(First const& f, Second const& s) : m_first(f), m_second(s) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First       & first ()       { return m_first; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First  const& first () const { return m_first; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return m_second; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return m_second; }
+};
+
+template<class First, class Second>
+struct tight_pair<First, Second, tpc_same_empty> : public First
+{
+    static_assert(std::is_same<First, Second>::value, "bad implementation");
+
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : First() {}
+    tight_pair(First const& f, Second const& /*s*/) : First(f) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First      & first ()       { return static_cast<First      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First const& first () const { return static_cast<First const&>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return reinterpret_cast<Second      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return reinterpret_cast<Second const&>(*this); }
+};
+
+template<class First, class Second>
+struct tight_pair<First, Second, tpc_both_empty> : public First, public Second
+{
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : First(), Second() {}
+    tight_pair(First const& f, Second const& s) : First(f), Second(s) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First      & first ()       { return static_cast<First      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First const& first () const { return static_cast<First const&>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return static_cast<Second      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return static_cast<Second const&>(*this); }
+};
+
+template<class First, class Second>
+struct tight_pair<First, Second, tpc_same> : public First
+{
+    Second m_second;
+
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : First() {}
+    tight_pair(First const& f, Second const& s) : First(f), m_second(s) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First      & first ()       { return static_cast<First      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First const& first () const { return static_cast<First const&>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return m_second; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return m_second; }
+};
+
+template<class First, class Second>
+struct tight_pair<First, Second, tpc_first_empty> : public First
+{
+    Second m_second;
+
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : First(), m_second() {}
+    tight_pair(First const& f, Second const& s) : First(f), m_second(s) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First      & first ()       { return static_cast<First      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First const& first () const { return static_cast<First const&>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return m_second; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return m_second; }
+};
+
+template<class First, class Second>
+struct tight_pair<First, Second, tpc_second_empty> : public Second
+{
+    First m_first;
+
+    using first_type = First;
+    using second_type = Second;
+
+    tight_pair() : Second(), m_first() {}
+    tight_pair(First const& f, Second const& s) : Second(s), m_first(f) {}
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First      & first ()       { return m_first; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 First const& first () const { return m_first; }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second      & second()       { return static_cast<Second      &>(*this); }
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return static_cast<Second const&>(*this); }
+};
+
+} // namespace detail
+
+template<class First, class Second>
+using tight_pair = detail::tight_pair<First, Second, detail::tpc_which_case<First,Second>()>;
+
+} // namespace c4
+
+#endif /* _C4_MEMORY_UTIL_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/memory_util.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/memory_resource.hpp
+// https://github.com/biojppm/c4core/src/c4/memory_resource.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_MEMORY_RESOURCE_HPP_
+#define _C4_MEMORY_RESOURCE_HPP_
+
+/** @file memory_resource.hpp Provides facilities to allocate typeless
+ *  memory, via the memory resource model consecrated with C++17. */
+
+/** @defgroup memory memory utilities */
+
+/** @defgroup raw_memory_alloc Raw memory allocation
+ * @ingroup memory
+ */
+
+/** @defgroup memory_resources Memory resources
+ * @ingroup memory
+ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+namespace c4 {
+
+// need these forward decls here
+struct MemoryResource;
+struct MemoryResourceMalloc;
+struct MemoryResourceStack;
+MemoryResourceMalloc* get_memory_resource_malloc();
+MemoryResourceStack* get_memory_resource_stack();
+namespace detail { MemoryResource*& get_memory_resource(); }
+
+
+// c-style allocation ---------------------------------------------------------
+
+// this API provides aligned allocation functions.
+// These functions forward the call to a user-modifiable function.
+
+
+// aligned allocation.
+
+/** Aligned allocation. Merely calls the current get_aalloc() function.
+ * @see get_aalloc()
+ * @ingroup raw_memory_alloc */
+void* aalloc(size_t sz, size_t alignment);
+
+/** Aligned free. Merely calls the current get_afree() function.
+ * @see get_afree()
+ * @ingroup raw_memory_alloc */
+void afree(void* ptr);
+
+/** Aligned reallocation. Merely calls the current get_arealloc() function.
+ * @see get_arealloc()
+ * @ingroup raw_memory_alloc */
+void* arealloc(void* ptr, size_t oldsz, size_t newsz, size_t alignment);
+
+
+// allocation setup facilities.
+
+/** Function pointer type for aligned allocation
+ * @see set_aalloc()
+ * @ingroup raw_memory_alloc */
+using aalloc_pfn = void* (*)(size_t size, size_t alignment);
+
+/** Function pointer type for aligned deallocation
+ * @see set_afree()
+ * @ingroup raw_memory_alloc */
+using afree_pfn = void  (*)(void *ptr);
+
+/** Function pointer type for aligned reallocation
+ * @see set_arealloc()
+ * @ingroup raw_memory_alloc */
+using arealloc_pfn = void* (*)(void *ptr, size_t oldsz, size_t newsz, size_t alignment);
+
+
+// allocation function pointer setters/getters
+
+/** Set the global aligned allocation function.
+ * @see aalloc()
+ * @see get_aalloc()
+ * @ingroup raw_memory_alloc */
+void set_aalloc(aalloc_pfn fn);
+
+/** Set the global aligned deallocation function.
+ * @see afree()
+ * @see get_afree()
+ * @ingroup raw_memory_alloc */
+void set_afree(afree_pfn fn);
+
+/** Set the global aligned reallocation function.
+ * @see arealloc()
+ * @see get_arealloc()
+ * @ingroup raw_memory_alloc */
+void set_arealloc(arealloc_pfn fn);
+
+
+/** Get the global aligned reallocation function.
+ * @see arealloc()
+ * @ingroup raw_memory_alloc */
+aalloc_pfn get_aalloc();
+
+/** Get the global aligned deallocation function.
+ * @see afree()
+ * @ingroup raw_memory_alloc */
+afree_pfn get_afree();
+
+/** Get the global aligned reallocation function.
+ * @see arealloc()
+ * @ingroup raw_memory_alloc */
+arealloc_pfn get_arealloc();
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// c++-style allocation -------------------------------------------------------
+
+/** C++17-style memory_resource base class. See http://en.cppreference.com/w/cpp/experimental/memory_resource
+ * @ingroup memory_resources */
+struct MemoryResource
+{
+    const char *name = nullptr;
+    virtual ~MemoryResource() {}
+
+    void* allocate(size_t sz, size_t alignment=alignof(max_align_t), void *hint=nullptr)
+    {
+        void *mem = this->do_allocate(sz, alignment, hint);
+        C4_CHECK_MSG(mem != nullptr, "could not allocate %lu bytes", sz);
+        return mem;
+    }
+
+    void* reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment=alignof(max_align_t))
+    {
+        void *mem = this->do_reallocate(ptr, oldsz, newsz, alignment);
+        C4_CHECK_MSG(mem != nullptr, "could not reallocate from %lu to %lu bytes", oldsz, newsz);
+        return mem;
+    }
+
+    void deallocate(void* ptr, size_t sz, size_t alignment=alignof(max_align_t))
+    {
+        this->do_deallocate(ptr, sz, alignment);
+    }
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void* hint) = 0;
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) = 0;
+    virtual void  do_deallocate(void* ptr, size_t sz, size_t alignment) = 0;
+
+};
+
+/** get the current global memory resource. To avoid static initialization
+ * order problems, this is implemented using a function call to ensure
+ * that it is available when first used.
+ * @ingroup memory_resources */
+C4_ALWAYS_INLINE MemoryResource* get_memory_resource()
+{
+    return detail::get_memory_resource();
+}
+
+/** set the global memory resource
+ * @ingroup memory_resources */
+C4_ALWAYS_INLINE void set_memory_resource(MemoryResource* mr)
+{
+    C4_ASSERT(mr != nullptr);
+    detail::get_memory_resource() = mr;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A c4::aalloc-based memory resource. Thread-safe if the implementation
+ * called by c4::aalloc() is safe.
+ * @ingroup memory_resources */
+struct MemoryResourceMalloc : public MemoryResource
+{
+
+    MemoryResourceMalloc() { name = "malloc"; }
+    virtual ~MemoryResourceMalloc() override {}
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void *hint) override
+    {
+        C4_UNUSED(hint);
+        return c4::aalloc(sz, alignment);
+    }
+
+    virtual void  do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        C4_UNUSED(sz);
+        C4_UNUSED(alignment);
+        c4::afree(ptr);
+    }
+
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override
+    {
+        return c4::arealloc(ptr, oldsz, newsz, alignment);
+    }
+
+};
+
+/** returns a malloc-based memory resource
+ * @ingroup memory_resources */
+C4_ALWAYS_INLINE MemoryResourceMalloc* get_memory_resource_malloc()
+{
+    /** @todo use a nifty counter:
+     * https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Nifty_Counter */
+    static MemoryResourceMalloc mr;
+    return &mr;
+}
+
+namespace detail {
+C4_ALWAYS_INLINE MemoryResource* & get_memory_resource()
+{
+    /** @todo use a nifty counter:
+     * https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Nifty_Counter */
+    thread_local static MemoryResource* mr = get_memory_resource_malloc();
+    return mr;
+}
+} // namespace detail
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+
+/** Allows a memory resource to obtain its memory from another memory resource.
+ * @ingroup memory_resources */
+struct DerivedMemoryResource : public MemoryResource
+{
+public:
+
+    DerivedMemoryResource(MemoryResource *mr_=nullptr) : m_local(mr_ ? mr_ : get_memory_resource()) {}
+
+private:
+
+    MemoryResource *m_local;
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void* hint) override
+    {
+        return m_local->allocate(sz, alignment, hint);
+    }
+
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override
+    {
+        return m_local->reallocate(ptr, oldsz, newsz, alignment);
+    }
+
+    virtual void do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        return m_local->deallocate(ptr, sz, alignment);
+    }
+};
+
+/** Provides common facilities for memory resource consisting of a single memory block
+ * @ingroup memory_resources */
+struct _MemoryResourceSingleChunk : public DerivedMemoryResource
+{
+
+    C4_NO_COPY_OR_MOVE(_MemoryResourceSingleChunk);
+
+    using impl_type = DerivedMemoryResource;
+
+public:
+
+    _MemoryResourceSingleChunk(MemoryResource *impl=nullptr) : DerivedMemoryResource(impl) { name = "linear_malloc"; }
+
+    /** initialize with owned memory, allocated from the given (or the global) memory resource */
+    _MemoryResourceSingleChunk(size_t sz, MemoryResource *impl=nullptr) : _MemoryResourceSingleChunk(impl) { acquire(sz); }
+    /** initialize with borrowed memory */
+    _MemoryResourceSingleChunk(void *mem, size_t sz) : _MemoryResourceSingleChunk() { acquire(mem, sz); }
+
+    virtual ~_MemoryResourceSingleChunk() override { release(); }
+
+public:
+
+    void const* mem() const { return m_mem; }
+
+    size_t capacity() const { return m_size; }
+    size_t size() const { return m_pos; }
+    size_t slack() const { C4_ASSERT(m_size >= m_pos); return m_size - m_pos; }
+
+public:
+
+    char  *m_mem{nullptr};
+    size_t m_size{0};
+    size_t m_pos{0};
+    bool   m_owner;
+
+public:
+
+    /** set the internal pointer to the beginning of the linear buffer */
+    void clear() { m_pos = 0; }
+
+    /** initialize with owned memory, allocated from the global memory resource */
+    void acquire(size_t sz);
+    /** initialize with borrowed memory */
+    void acquire(void *mem, size_t sz);
+    /** release the memory */
+    void release();
+
+};
+
+} // namespace detail
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** provides a linear memory resource. Allocates incrementally from a linear
+ * buffer, without ever deallocating. Deallocations are a no-op, and the
+ * memory is freed only when the resource is release()d. The memory used by
+ * this object can be either owned or borrowed. When borrowed, no calls to
+ * malloc/free take place.
+ *
+ * @ingroup memory_resources */
+struct MemoryResourceLinear : public detail::_MemoryResourceSingleChunk
+{
+
+    C4_NO_COPY_OR_MOVE(MemoryResourceLinear);
+
+public:
+
+    using detail::_MemoryResourceSingleChunk::_MemoryResourceSingleChunk;
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void *hint) override;
+    virtual void  do_deallocate(void* ptr, size_t sz, size_t alignment) override;
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override;
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** provides a stack-type malloc-based memory resource.
+ * @ingroup memory_resources */
+struct MemoryResourceStack : public detail::_MemoryResourceSingleChunk
+{
+
+    C4_NO_COPY_OR_MOVE(MemoryResourceStack);
+
+public:
+
+    using detail::_MemoryResourceSingleChunk::_MemoryResourceSingleChunk;
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void *hint) override;
+    virtual void  do_deallocate(void* ptr, size_t sz, size_t alignment) override;
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override;
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** provides a linear array-based memory resource.
+ * @see MemoryResourceLinear
+ * @ingroup memory_resources */
+template<size_t N>
+struct MemoryResourceLinearArr : public MemoryResourceLinear
+{
+    #ifdef _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable: 4324) // structure was padded due to alignment specifier
+    #endif
+    alignas(alignof(max_align_t)) char m_arr[N];
+    #ifdef _MSC_VER
+    #pragma warning(pop)
+    #endif
+    MemoryResourceLinearArr() : MemoryResourceLinear(m_arr, N) { name = "linear_arr"; }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+struct AllocationCounts
+{
+    struct Item
+    {
+        ssize_t allocs;
+        ssize_t size;
+
+        void add(size_t sz)
+        {
+            ++allocs;
+            size += static_cast<ssize_t>(sz);
+        }
+        void rem(size_t sz)
+        {
+            --allocs;
+            size -= static_cast<ssize_t>(sz);
+        }
+        Item max(Item const& that) const
+        {
+            Item r(*this);
+            r.allocs = r.allocs > that.allocs ? r.allocs : that.allocs;
+            r.size = r.size > that.size ? r.size : that.size;
+            return r;
+        }
+    };
+
+    Item curr  = {0, 0};
+    Item total = {0, 0};
+    Item max   = {0, 0};
+
+    void clear_counts()
+    {
+        curr  = {0, 0};
+        total = {0, 0};
+        max   = {0, 0};
+    }
+
+    void update(AllocationCounts const& that)
+    {
+        curr.allocs += that.curr.allocs;
+        curr.size += that.curr.size;
+        total.allocs += that.total.allocs;
+        total.size += that.total.size;
+        max.allocs += that.max.allocs;
+        max.size += that.max.size;
+    }
+
+    void add_counts(void* ptr, size_t sz)
+    {
+        if(ptr == nullptr) return;
+        curr.add(sz);
+        total.add(sz);
+        max = max.max(curr);
+    }
+
+    void rem_counts(void *ptr, size_t sz)
+    {
+        if(ptr == nullptr) return;
+        curr.rem(sz);
+    }
+
+    AllocationCounts operator- (AllocationCounts const& that) const
+    {
+        AllocationCounts r(*this);
+        r.curr.allocs -= that.curr.allocs;
+        r.curr.size -= that.curr.size;
+        r.total.allocs -= that.total.allocs;
+        r.total.size -= that.total.size;
+        r.max.allocs -= that.max.allocs;
+        r.max.size -= that.max.size;
+        return r;
+    }
+
+    AllocationCounts operator+ (AllocationCounts const& that) const
+    {
+        AllocationCounts r(*this);
+        r.curr.allocs += that.curr.allocs;
+        r.curr.size += that.curr.size;
+        r.total.allocs += that.total.allocs;
+        r.total.size += that.total.size;
+        r.max.allocs += that.max.allocs;
+        r.max.size += that.max.size;
+        return r;
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** a MemoryResource which latches onto another MemoryResource
+ * and counts allocations and sizes.
+ * @ingroup memory_resources */
+class MemoryResourceCounts : public MemoryResource
+{
+public:
+
+    MemoryResourceCounts() : m_resource(get_memory_resource())
+    {
+        C4_ASSERT(m_resource != this);
+        name = "MemoryResourceCounts";
+    }
+    MemoryResourceCounts(MemoryResource *res) : m_resource(res)
+    {
+        C4_ASSERT(m_resource != this);
+        name = "MemoryResourceCounts";
+    }
+
+    MemoryResource *resource() { return m_resource; }
+    AllocationCounts const& counts() const { return m_counts; }
+
+protected:
+
+    MemoryResource *m_resource;
+    AllocationCounts m_counts;
+
+protected:
+
+    virtual void* do_allocate(size_t sz, size_t alignment, void * /*hint*/) override
+    {
+        void *ptr = m_resource->allocate(sz, alignment);
+        m_counts.add_counts(ptr, sz);
+        return ptr;
+    }
+
+    virtual void  do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        m_counts.rem_counts(ptr, sz);
+        m_resource->deallocate(ptr, sz, alignment);
+    }
+
+    virtual void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override
+    {
+        m_counts.rem_counts(ptr, oldsz);
+        void* nptr = m_resource->reallocate(ptr, oldsz, newsz, alignment);
+        m_counts.add_counts(nptr, newsz);
+        return nptr;
+    }
+
+};
+
+//-----------------------------------------------------------------------------
+/** RAII class which binds a memory resource with a scope duration.
+ * @ingroup memory_resources */
+struct ScopedMemoryResource
+{
+    MemoryResource *m_original;
+
+    ScopedMemoryResource(MemoryResource *r)
+    :
+        m_original(get_memory_resource())
+    {
+        set_memory_resource(r);
+    }
+
+    ~ScopedMemoryResource()
+    {
+        set_memory_resource(m_original);
+    }
+};
+
+//-----------------------------------------------------------------------------
+/** RAII class which counts allocations and frees inside a scope. Can
+ * optionally set also the memory resource to be used.
+ * @ingroup memory_resources */
+struct ScopedMemoryResourceCounts
+{
+    MemoryResourceCounts mr;
+
+    ScopedMemoryResourceCounts() : mr()
+    {
+        set_memory_resource(&mr);
+    }
+    ScopedMemoryResourceCounts(MemoryResource *m) : mr(m)
+    {
+        set_memory_resource(&mr);
+    }
+    ~ScopedMemoryResourceCounts()
+    {
+        set_memory_resource(mr.resource());
+    }
+};
+
+} // namespace c4
+
+#endif /* _C4_MEMORY_RESOURCE_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/memory_resource.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/ctor_dtor.hpp
+// https://github.com/biojppm/c4core/src/c4/ctor_dtor.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_CTOR_DTOR_HPP_
+#define _C4_CTOR_DTOR_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/preprocessor.hpp
+//#include "c4/preprocessor.hpp"
+#if !defined(C4_PREPROCESSOR_HPP_) && !defined(_C4_PREPROCESSOR_HPP_)
+#error "amalgamate: file c4/preprocessor.hpp must have been included at this point"
+#endif /* C4_PREPROCESSOR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_util.hpp
+//#include "c4/memory_util.hpp"
+#if !defined(C4_MEMORY_UTIL_HPP_) && !defined(_C4_MEMORY_UTIL_HPP_)
+#error "amalgamate: file c4/memory_util.hpp must have been included at this point"
+#endif /* C4_MEMORY_UTIL_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+//included above:
+//#include <type_traits>
+//included above:
+//#include <utility> // std::forward
+
+/** @file ctor_dtor.hpp object construction and destruction facilities.
+ * Some of these are not yet available in C++11. */
+
+namespace c4 {
+
+/** default-construct an object, trivial version */
+template <class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_default_constructible<U>::value, void>::type
+construct(U *ptr) noexcept
+{
+    memset(ptr, 0, sizeof(U));
+}
+/** default-construct an object, non-trivial version */
+template<class U> C4_ALWAYS_INLINE typename std ::enable_if< ! std::is_trivially_default_constructible<U>::value, void>::type
+construct(U* ptr) noexcept
+{
+    new ((void*)ptr) U();
+}
+
+/** default-construct n objects, trivial version */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_default_constructible<U>::value, void>::type
+construct_n(U* ptr, I n) noexcept
+{
+    memset(ptr, 0, n * sizeof(U));
+}
+/** default-construct n objects, non-trivial version */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_default_constructible<U>::value, void>::type
+construct_n(U* ptr, I n) noexcept
+{
+    for(I i = 0; i < n; ++i)
+    {
+        new ((void*)(ptr + i)) U();
+    }
+}
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   if __GNUC__ >= 6
+#       pragma GCC diagnostic ignored "-Wnull-dereference"
+#   endif
+#endif
+
+template<class U, class ...Args>
+inline void construct(U* ptr, Args&&... args)
+{
+    new ((void*)ptr) U(std::forward<Args>(args)...);
+}
+template<class U, class I, class ...Args>
+inline void construct_n(U* ptr, I n, Args&&... args)
+{
+    for(I i = 0; i < n; ++i)
+    {
+        new ((void*)(ptr + i)) U(args...);
+    }
+}
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+
+//-----------------------------------------------------------------------------
+// copy-construct
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copy_constructible<U>::value, void>::type
+copy_construct(U* dst, U const* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, sizeof(U));
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_copy_constructible<U>::value, void>::type
+copy_construct(U* dst, U const* src)
+{
+    C4_ASSERT(dst != src);
+    new ((void*)dst) U(*src);
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copy_constructible<U>::value, void>::type
+copy_construct_n(U* dst, U const* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, n * sizeof(U));
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_copy_constructible<U>::value, void>::type
+copy_construct_n(U* dst, U const* src, I n)
+{
+    C4_ASSERT(dst != src);
+    for(I i = 0; i < n; ++i)
+    {
+        new ((void*)(dst + i)) U(*(src + i));
+    }
+}
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_scalar<U>::value, void>::type
+copy_construct(U* dst, U src) noexcept // pass by value for scalar types
+{
+    *dst = src;
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_scalar<U>::value, void>::type
+copy_construct(U* dst, U const& src) // pass by reference for non-scalar types
+{
+    C4_ASSERT(dst != &src);
+    new ((void*)dst) U(src);
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_scalar<U>::value, void>::type
+copy_construct_n(U* dst, U src, I n) noexcept // pass by value for scalar types
+{
+    for(I i = 0; i < n; ++i)
+    {
+        dst[i] = src;
+    }
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_scalar<U>::value, void>::type
+copy_construct_n(U* dst, U const& src, I n) // pass by reference for non-scalar types
+{
+    C4_ASSERT(dst != &src);
+    for(I i = 0; i < n; ++i)
+    {
+        new ((void*)(dst + i)) U(src);
+    }
+}
+
+template<class U, size_t N>
+C4_ALWAYS_INLINE void copy_construct(U (&dst)[N], U const (&src)[N]) noexcept
+{
+    copy_construct_n(dst, src, N);
+}
+
+//-----------------------------------------------------------------------------
+// copy-assign
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copy_assignable<U>::value, void>::type
+copy_assign(U* dst, U const* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, sizeof(U));
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_copy_assignable<U>::value, void>::type
+copy_assign(U* dst, U const* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    *dst = *src;
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copy_assignable<U>::value, void>::type
+copy_assign_n(U* dst, U const* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, n * sizeof(U));
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_copy_assignable<U>::value, void>::type
+copy_assign_n(U* dst, U const* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    for(I i = 0; i < n; ++i)
+    {
+        dst[i] = src[i];
+    }
+}
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_scalar<U>::value, void>::type
+copy_assign(U* dst, U src) noexcept // pass by value for scalar types
+{
+    *dst = src;
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_scalar<U>::value, void>::type
+copy_assign(U* dst, U const& src) noexcept // pass by reference for non-scalar types
+{
+    C4_ASSERT(dst != &src);
+    *dst = src;
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_scalar<U>::value, void>::type
+copy_assign_n(U* dst, U src, I n) noexcept // pass by value for scalar types
+{
+    for(I i = 0; i < n; ++i)
+    {
+        dst[i] = src;
+    }
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_scalar<U>::value, void>::type
+copy_assign_n(U* dst, U const& src, I n) noexcept // pass by reference for non-scalar types
+{
+    C4_ASSERT(dst != &src);
+    for(I i = 0; i < n; ++i)
+    {
+        dst[i] = src;
+    }
+}
+
+template<class U, size_t N>
+C4_ALWAYS_INLINE void copy_assign(U (&dst)[N], U const (&src)[N]) noexcept
+{
+    copy_assign_n(dst, src, N);
+}
+
+//-----------------------------------------------------------------------------
+// move-construct
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_constructible<U>::value, void>::type
+move_construct(U* dst, U* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, sizeof(U));
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_constructible<U>::value, void>::type
+move_construct(U* dst, U* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    new ((void*)dst) U(std::move(*src));
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_constructible<U>::value, void>::type
+move_construct_n(U* dst, U* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, n * sizeof(U));
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_constructible<U>::value, void>::type
+move_construct_n(U* dst, U* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    for(I i = 0; i < n; ++i)
+    {
+        new ((void*)(dst + i)) U(std::move(src[i]));
+    }
+}
+
+//-----------------------------------------------------------------------------
+// move-assign
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_assignable<U>::value, void>::type
+move_assign(U* dst, U* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, sizeof(U));
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_assignable<U>::value, void>::type
+move_assign(U* dst, U* src) noexcept
+{
+    C4_ASSERT(dst != src);
+    *dst = std::move(*src);
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_assignable<U>::value, void>::type
+move_assign_n(U* dst, U* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    memcpy(dst, src, n * sizeof(U));
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_assignable<U>::value, void>::type
+move_assign_n(U* dst, U* src, I n) noexcept
+{
+    C4_ASSERT(dst != src);
+    for(I i = 0; i < n; ++i)
+    {
+        *(dst + i) = std::move(*(src + i));
+    }
+}
+
+//-----------------------------------------------------------------------------
+// destroy
+
+template<class U> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_destructible<U>::value, void>::type
+destroy(U* ptr) noexcept
+{
+    C4_UNUSED(ptr); // nothing to do
+}
+template<class U> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_destructible<U>::value, void>::type
+destroy(U* ptr) noexcept
+{
+    ptr->~U();
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_destructible<U>::value, void>::type
+destroy_n(U* ptr, I n) noexcept
+{
+    C4_UNUSED(ptr);
+    C4_UNUSED(n); // nothing to do
+}
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_destructible<U>::value, void>::type
+destroy_n(U* ptr, I n) noexcept
+{
+    for(I i = 0; i <n; ++i)
+    {
+        ptr[i].~U();
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+/** makes room at the beginning of buf, which has a current size of n */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_constructible<U>::value, void>::type
+make_room(U *buf, I bufsz, I room) C4_NOEXCEPT_A
+{
+    C4_ASSERT(bufsz >= 0 && room >= 0);
+    if(room >= bufsz)
+    {
+        memcpy (buf + room, buf, bufsz * sizeof(U));
+    }
+    else
+    {
+        memmove(buf + room, buf, bufsz * sizeof(U));
+    }
+}
+/** makes room at the beginning of buf, which has a current size of bufsz */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_constructible<U>::value, void>::type
+make_room(U *buf, I bufsz, I room) C4_NOEXCEPT_A
+{
+    C4_ASSERT(bufsz >= 0 && room >= 0);
+    if(room >= bufsz)
+    {
+        for(I i = 0; i < bufsz; ++i)
+        {
+            new ((void*)(buf + (i + room))) U(std::move(buf[i]));
+        }
+    }
+    else
+    {
+        for(I i = 0; i < bufsz; ++i)
+        {
+            I w = bufsz-1 - i; // do a backwards loop
+            new ((void*)(buf + (w + room))) U(std::move(buf[w]));
+        }
+    }
+}
+
+/** make room to the right of pos */
+template<class U, class I>
+C4_ALWAYS_INLINE void make_room(U *buf, I bufsz, I currsz, I pos, I room)
+{
+    C4_ASSERT(pos >= 0 && pos <= currsz);
+    C4_ASSERT(currsz <= bufsz);
+    C4_ASSERT(room + currsz <= bufsz);
+    C4_UNUSED(bufsz);
+    make_room(buf + pos, currsz - pos, room);
+}
+
+
+/** make room to the right of pos, copying to the beginning of a different buffer */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_constructible<U>::value, void>::type
+make_room(U *dst, U const* src, I srcsz, I room, I pos) C4_NOEXCEPT_A
+{
+    C4_ASSERT(srcsz >= 0 && room >= 0 && pos >= 0);
+    C4_ASSERT(pos < srcsz || (pos == 0 && srcsz == 0));
+    memcpy(dst             , src      , pos           * sizeof(U));
+    memcpy(dst + room + pos, src + pos, (srcsz - pos) * sizeof(U));
+}
+/** make room to the right of pos, copying to the beginning of a different buffer */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_constructible<U>::value, void>::type
+make_room(U *dst, U const* src, I srcsz, I room, I pos)
+{
+    C4_ASSERT(srcsz >= 0 && room >= 0 && pos >= 0);
+    C4_ASSERT(pos < srcsz || (pos == 0 && srcsz == 0));
+    for(I i = 0; i < pos; ++i)
+    {
+        new ((void*)(dst + i)) U(std::move(src[i]));
+    }
+    src += pos;
+    dst += room + pos;
+    for(I i = 0, e = srcsz - pos; i < e; ++i)
+    {
+        new ((void*)(dst + i)) U(std::move(src[i]));
+    }
+}
+
+template<class U, class I>
+C4_ALWAYS_INLINE void make_room
+(
+    U      * dst, I dstsz,
+    U const* src, I srcsz,
+    I room, I pos
+)
+{
+    C4_ASSERT(pos >= 0 && pos < srcsz || (srcsz == 0 && pos == 0));
+    C4_ASSERT(pos >= 0 && pos < dstsz || (dstsz == 0 && pos == 0));
+    C4_ASSERT(srcsz+room <= dstsz);
+    C4_UNUSED(dstsz);
+    make_room(dst, src, srcsz, room, pos);
+}
+
+
+//-----------------------------------------------------------------------------
+/** destroy room at the beginning of buf, which has a current size of n */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_scalar<U>::value || (std::is_standard_layout<U>::value && std::is_trivial<U>::value), void>::type
+destroy_room(U *buf, I n, I room) C4_NOEXCEPT_A
+{
+    C4_ASSERT(n >= 0 && room >= 0);
+    C4_ASSERT(room <= n);
+    if(room < n)
+    {
+        memmove(buf, buf + room, (n - room) * sizeof(U));
+    }
+    else
+    {
+        // nothing to do - no need to destroy scalar types
+    }
+}
+/** destroy room at the beginning of buf, which has a current size of n */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! (std::is_scalar<U>::value || (std::is_standard_layout<U>::value && std::is_trivial<U>::value)), void>::type
+destroy_room(U *buf, I n, I room)
+{
+    C4_ASSERT(n >= 0 && room >= 0);
+    C4_ASSERT(room <= n);
+    if(room < n)
+    {
+        for(I i = 0, e = n - room; i < e; ++i)
+        {
+            buf[i] = std::move(buf[i + room]);
+        }
+    }
+    else
+    {
+        for(I i = 0; i < n; ++i)
+        {
+            buf[i].~U();
+        }
+    }
+}
+
+/** destroy room to the right of pos, copying to a different buffer */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if<std::is_trivially_move_constructible<U>::value, void>::type
+destroy_room(U *dst, U const* src, I n, I room, I pos) C4_NOEXCEPT_A
+{
+    C4_ASSERT(n >= 0 && room >= 0 && pos >= 0);
+    C4_ASSERT(pos <n);
+    C4_ASSERT(pos + room <= n);
+    memcpy(dst, src, pos * sizeof(U));
+    memcpy(dst + pos, src + room + pos, (n - pos - room) * sizeof(U));
+}
+/** destroy room to the right of pos, copying to a different buffer */
+template<class U, class I> C4_ALWAYS_INLINE typename std::enable_if< ! std::is_trivially_move_constructible<U>::value, void>::type
+destroy_room(U *dst, U const* src, I n, I room, I pos)
+{
+    C4_ASSERT(n >= 0 && room >= 0 && pos >= 0);
+    C4_ASSERT(pos < n);
+    C4_ASSERT(pos + room <= n);
+    for(I i = 0; i < pos; ++i)
+    {
+        new ((void*)(dst + i)) U(std::move(src[i]));
+    }
+    src += room + pos;
+    dst += pos;
+    for(I i = 0, e = n - pos - room; i < e; ++i)
+    {
+        new ((void*)(dst + i)) U(std::move(src[i]));
+    }
+}
+
+} // namespace c4
+
+#undef _C4REQUIRE
+
+#endif /* _C4_CTOR_DTOR_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/ctor_dtor.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/allocator.hpp
+// https://github.com/biojppm/c4core/src/c4/allocator.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_ALLOCATOR_HPP_
+#define _C4_ALLOCATOR_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_resource.hpp
+//#include "c4/memory_resource.hpp"
+#if !defined(C4_MEMORY_RESOURCE_HPP_) && !defined(_C4_MEMORY_RESOURCE_HPP_)
+#error "amalgamate: file c4/memory_resource.hpp must have been included at this point"
+#endif /* C4_MEMORY_RESOURCE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/ctor_dtor.hpp
+//#include "c4/ctor_dtor.hpp"
+#if !defined(C4_CTOR_DTOR_HPP_) && !defined(_C4_CTOR_DTOR_HPP_)
+#error "amalgamate: file c4/ctor_dtor.hpp must have been included at this point"
+#endif /* C4_CTOR_DTOR_HPP_ */
+
+
+#include <memory> // std::allocator_traits
+//included above:
+//#include <type_traits>
+
+/** @file allocator.hpp Contains classes to make typeful allocations (note
+ * that memory resources are typeless) */
+
+/** @defgroup mem_res_providers Memory resource providers
+ * @brief Policy classes which provide a memory resource for
+ * use in an allocator.
+ * @ingroup memory
+ */
+
+/** @defgroup allocators Allocators
+ * @brief Lightweight classes that act as handles to specific memory
+ * resources and provide typeful memory.
+ * @ingroup memory
+ */
+
+namespace c4 {
+
+namespace detail {
+template<class T> inline size_t size_for      (size_t num_objs) noexcept { return num_objs * sizeof(T); }
+template<       > inline size_t size_for<void>(size_t num_objs) noexcept { return num_objs;             }
+} // namespace detail
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** provides a per-allocator memory resource
+ * @ingroup mem_res_providers */
+class MemRes
+{
+public:
+
+    MemRes() : m_resource(get_memory_resource()) {}
+    MemRes(MemoryResource* r) noexcept : m_resource(r ? r : get_memory_resource()) {}
+
+    inline MemoryResource* resource() const { return m_resource; }
+
+private:
+
+    MemoryResource* m_resource;
+
+};
+
+
+/** the allocators using this will default to the global memory resource
+ * @ingroup mem_res_providers */
+class MemResGlobal
+{
+public:
+
+    MemResGlobal() {}
+    MemResGlobal(MemoryResource* r) noexcept { C4_UNUSED(r); C4_ASSERT(r == get_memory_resource()); }
+
+    inline MemoryResource* resource() const { return get_memory_resource(); }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+template<class MemRes>
+struct _AllocatorUtil;
+
+template<class T, class ...Args>
+struct has_no_alloc
+    : public std::integral_constant<bool,
+                                    !(std::uses_allocator<T, MemoryResource*>::value)
+                                    && std::is_constructible<T, Args...>::value> {};
+
+// std::uses_allocator_v<U, MemoryResource> && std::is_constructible<U, std::allocator_arg_t, MemoryResource*, Args...>
+// ie can construct(std::allocator_arg_t, MemoryResource*, Args...)
+template<class T, class ...Args>
+struct has_alloc_arg
+    : public std::integral_constant<bool,
+                                    std::uses_allocator<T, MemoryResource*>::value
+                                    && std::is_constructible<T, std::allocator_arg_t, MemoryResource*, Args...>::value> {};
+// std::uses_allocator<U> && std::is_constructible<U, Args..., MemoryResource*>
+// ie, can construct(Args..., MemoryResource*)
+template<class T, class ...Args>
+struct has_alloc
+    : public std::integral_constant<bool,
+                                    std::uses_allocator<T, MemoryResource*>::value
+                                    && std::is_constructible<T, Args..., MemoryResource*>::value> {};
+
+} // namespace detail
+
+
+template<class MemRes>
+struct detail::_AllocatorUtil : public MemRes
+{
+    using MemRes::MemRes;
+
+    /** for construct:
+     * @see http://en.cppreference.com/w/cpp/experimental/polymorphic_allocator/construct */
+
+    // 1. types with no allocators
+    template <class U, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_no_alloc<U, Args...>::value, void>::type
+    construct(U *ptr, Args &&...args)
+    {
+        c4::construct(ptr, std::forward<Args>(args)...);
+    }
+    template<class U, class I, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_no_alloc<U, Args...>::value, void>::type
+    construct_n(U* ptr, I n, Args&&... args)
+    {
+        c4::construct_n(ptr, n, std::forward<Args>(args)...);
+    }
+
+    // 2. types using allocators (ie, containers)
+
+    // 2.1. can construct(std::allocator_arg_t, MemoryResource*, Args...)
+    template<class U, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_alloc_arg<U, Args...>::value, void>::type
+    construct(U* ptr, Args&&... args)
+    {
+        c4::construct(ptr, std::allocator_arg, this->resource(), std::forward<Args>(args)...);
+    }
+    template<class U, class I, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_alloc_arg<U, Args...>::value, void>::type
+    construct_n(U* ptr, I n, Args&&... args)
+    {
+        c4::construct_n(ptr, n, std::allocator_arg, this->resource(), std::forward<Args>(args)...);
+    }
+
+    // 2.2. can construct(Args..., MemoryResource*)
+    template<class U, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_alloc<U, Args...>::value, void>::type
+    construct(U* ptr, Args&&... args)
+    {
+        c4::construct(ptr, std::forward<Args>(args)..., this->resource());
+    }
+    template<class U, class I, class... Args>
+    C4_ALWAYS_INLINE typename std::enable_if<detail::has_alloc<U, Args...>::value, void>::type
+    construct_n(U* ptr, I n, Args&&... args)
+    {
+        c4::construct_n(ptr, n, std::forward<Args>(args)..., this->resource());
+    }
+
+    template<class U>
+    static C4_ALWAYS_INLINE void destroy(U* ptr)
+    {
+        c4::destroy(ptr);
+    }
+    template<class U, class I>
+    static C4_ALWAYS_INLINE void destroy_n(U* ptr, I n)
+    {
+        c4::destroy_n(ptr, n);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** An allocator is simply a proxy to a memory resource.
+ * @param T
+ * @param MemResProvider
+ * @ingroup allocators */
+template<class T, class MemResProvider=MemResGlobal>
+class Allocator : public detail::_AllocatorUtil<MemResProvider>
+{
+public:
+
+    using impl_type = detail::_AllocatorUtil<MemResProvider>;
+
+    using value_type = T;
+    using pointer = T*;
+    using const_pointer = T const*;
+    using reference = T&;
+    using const_reference = T const&;
+    using size_type = size_t;
+    using difference_type = std::ptrdiff_t;
+    using propagate_on_container_move_assigment = std::true_type;
+
+public:
+
+    template<class U, class MRProv>
+    bool operator== (Allocator<U, MRProv> const& that) const
+    {
+        return this->resource() == that.resource();
+    }
+    template<class U, class MRProv>
+    bool operator!= (Allocator<U, MRProv> const& that) const
+    {
+        return this->resource() != that.resource();
+    }
+
+public:
+
+    template<class U, class MRProv> friend class Allocator;
+    template<class U>
+    struct rebind
+    {
+        using other = Allocator<U, MemResProvider>;
+    };
+    template<class U>
+    typename rebind<U>::other rebound()
+    {
+        return typename rebind<U>::other(*this);
+    }
+
+public:
+
+    using impl_type::impl_type;
+    Allocator() : impl_type() {} // VS demands this
+
+    template<class U> Allocator(Allocator<U, MemResProvider> const& that) : impl_type(that.resource()) {}
+
+    Allocator(Allocator const&) = default;
+    Allocator(Allocator     &&) = default;
+
+    Allocator& operator= (Allocator const&) = default; // WTF? why? @see http://en.cppreference.com/w/cpp/memory/polymorphic_allocator
+    Allocator& operator= (Allocator     &&) = default;
+
+    /** returns a default-constructed polymorphic allocator object
+     * @see http://en.cppreference.com/w/cpp/memory/polymorphic_allocator/select_on_container_copy_construction      */
+    Allocator select_on_container_copy_construct() const { return Allocator(*this); }
+
+    T* allocate(size_t num_objs, size_t alignment=alignof(T))
+    {
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment >= alignof(T));
+        void* vmem = this->resource()->allocate(detail::size_for<T>(num_objs), alignment);
+        T* mem = static_cast<T*>(vmem);
+        return mem;
+    }
+
+    void deallocate(T * ptr, size_t num_objs, size_t alignment=alignof(T))
+    {
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment>= alignof(T));
+        this->resource()->deallocate(ptr, detail::size_for<T>(num_objs), alignment);
+    }
+
+    T* reallocate(T* ptr, size_t oldnum, size_t newnum, size_t alignment=alignof(T))
+    {
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment >= alignof(T));
+        void* vmem = this->resource()->reallocate(ptr, detail::size_for<T>(oldnum), detail::size_for<T>(newnum), alignment);
+        T* mem = static_cast<T*>(vmem);
+        return mem;
+    }
+
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @ingroup allocators */
+template<class T, size_t N=16, size_t Alignment=alignof(T), class MemResProvider=MemResGlobal>
+class SmallAllocator : public detail::_AllocatorUtil<MemResProvider>
+{
+    static_assert(Alignment >= alignof(T), "invalid alignment");
+
+    using impl_type = detail::_AllocatorUtil<MemResProvider>;
+
+    alignas(Alignment) char m_arr[N * sizeof(T)];
+    size_t m_num{0};
+
+public:
+
+    using value_type = T;
+    using pointer = T*;
+    using const_pointer = T const*;
+    using reference = T&;
+    using const_reference = T const&;
+    using size_type = size_t;
+    using difference_type = std::ptrdiff_t;
+    using propagate_on_container_move_assigment = std::true_type;
+
+    template<class U>
+    bool operator== (SmallAllocator<U,N,Alignment,MemResProvider> const&) const
+    {
+        return false;
+    }
+    template<class U>
+    bool operator!= (SmallAllocator<U,N,Alignment,MemResProvider> const&) const
+    {
+        return true;
+    }
+
+public:
+
+    template<class U, size_t, size_t, class> friend class SmallAllocator;
+    template<class U>
+    struct rebind
+    {
+        using other = SmallAllocator<U, N, alignof(U), MemResProvider>;
+    };
+    template<class U>
+    typename rebind<U>::other rebound()
+    {
+        return typename rebind<U>::other(*this);
+    }
+
+public:
+
+    using impl_type::impl_type;
+    SmallAllocator() : impl_type() {} // VS demands this
+
+    template<class U, size_t N2, size_t A2, class MP2>
+    SmallAllocator(SmallAllocator<U,N2,A2,MP2> const& that) : impl_type(that.resource())
+    {
+        C4_ASSERT(that.m_num == 0);
+    }
+
+    SmallAllocator(SmallAllocator const&) = default;
+    SmallAllocator(SmallAllocator     &&) = default;
+
+    SmallAllocator& operator= (SmallAllocator const&) = default; // WTF? why? @see http://en.cppreference.com/w/cpp/memory/polymorphic_allocator
+    SmallAllocator& operator= (SmallAllocator     &&) = default;
+
+    /** returns a default-constructed polymorphic allocator object
+     * @see http://en.cppreference.com/w/cpp/memory/polymorphic_allocator/select_on_container_copy_construction      */
+    SmallAllocator select_on_container_copy_construct() const { return SmallAllocator(*this); }
+
+    T* allocate(size_t num_objs, size_t alignment=Alignment)
+    {
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment >= alignof(T));
+        void *vmem;
+        if(m_num + num_objs <= N)
+        {
+            vmem = (m_arr + m_num * sizeof(T));
+        }
+        else
+        {
+            vmem = this->resource()->allocate(num_objs * sizeof(T), alignment);
+        }
+        m_num += num_objs;
+        T *mem = static_cast<T*>(vmem);
+        return mem;
+    }
+
+    void deallocate(T * ptr, size_t num_objs, size_t alignment=Alignment)
+    {
+        C4_ASSERT(m_num >= num_objs);
+        m_num -= num_objs;
+        if((char*)ptr >= m_arr && (char*)ptr < m_arr + (N * sizeof(T)))
+        {
+            return;
+        }
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment >= alignof(T));
+        this->resource()->deallocate(ptr, num_objs * sizeof(T), alignment);
+    }
+
+    T* reallocate(T * ptr, size_t oldnum, size_t newnum, size_t alignment=Alignment)
+    {
+        C4_ASSERT(this->resource() != nullptr);
+        C4_ASSERT(alignment >= alignof(T));
+        if(oldnum <= N && newnum <= N)
+        {
+            return m_arr;
+        }
+        else if(oldnum <= N && newnum > N)
+        {
+            return allocate(newnum, alignment);
+        }
+        else if(oldnum > N && newnum <= N)
+        {
+            deallocate(ptr, oldnum, alignment);
+            return m_arr;
+        }
+        void* vmem = this->resource()->reallocate(ptr, oldnum * sizeof(T), newnum * sizeof(T), alignment);
+        T* mem = static_cast<T*>(vmem);
+        return mem;
+    }
+
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** An allocator making use of the global memory resource.
+ * @ingroup allocators */
+template<class T> using allocator = Allocator<T, MemResGlobal>;
+/** An allocator with a per-instance memory resource
+ * @ingroup allocators */
+template<class T> using allocator_mr = Allocator<T, MemRes>;
+
+/** @ingroup allocators */
+template<class T, size_t N=16, size_t Alignment=alignof(T)> using small_allocator = SmallAllocator<T, N, Alignment, MemResGlobal>;
+/** @ingroup allocators */
+template<class T, size_t N=16, size_t Alignment=alignof(T)> using small_allocator_mr = SmallAllocator<T, N, Alignment, MemRes>;
+
+} // namespace c4
+
+#endif /* _C4_ALLOCATOR_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/allocator.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/char_traits.hpp
+// https://github.com/biojppm/c4core/src/c4/char_traits.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_CHAR_TRAITS_HPP_
+#define _C4_CHAR_TRAITS_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+
+#include <string> // needed because of std::char_traits
+#include <cctype>
+#include <cwctype>
+
+namespace c4 {
+
+C4_ALWAYS_INLINE bool isspace(char c) { return std::isspace(c) != 0; }
+C4_ALWAYS_INLINE bool isspace(wchar_t c) { return std::iswspace(static_cast<wint_t>(c)) != 0; }
+
+//-----------------------------------------------------------------------------
+template<typename C>
+struct char_traits;
+
+template<>
+struct char_traits<char> : public std::char_traits<char>
+{
+    constexpr static const char whitespace_chars[] = " \f\n\r\t\v";
+    constexpr static const size_t num_whitespace_chars = sizeof(whitespace_chars) - 1;
+};
+
+template<>
+struct char_traits<wchar_t> : public std::char_traits<wchar_t>
+{
+    constexpr static const wchar_t whitespace_chars[] = L" \f\n\r\t\v";
+    constexpr static const size_t num_whitespace_chars = sizeof(whitespace_chars) - 1;
+};
+
+
+//-----------------------------------------------------------------------------
+namespace detail {
+template<typename C>
+struct needed_chars;
+template<>
+struct needed_chars<char>
+{
+    template<class SizeType>
+    C4_ALWAYS_INLINE constexpr static SizeType for_bytes(SizeType num_bytes)
+    {
+        return num_bytes;
+    }
+};
+template<>
+struct needed_chars<wchar_t>
+{
+    template<class SizeType>
+    C4_ALWAYS_INLINE constexpr static SizeType for_bytes(SizeType num_bytes)
+    {
+        // wchar_t is not necessarily 2 bytes.
+        return (num_bytes / static_cast<SizeType>(sizeof(wchar_t))) + ((num_bytes & static_cast<SizeType>(SizeType(sizeof(wchar_t)) - SizeType(1))) != 0);
+    }
+};
+} // namespace detail
+
+/** get the number of C characters needed to store a number of bytes */
+template<typename C, typename SizeType>
+C4_ALWAYS_INLINE constexpr SizeType num_needed_chars(SizeType num_bytes)
+{
+    return detail::needed_chars<C>::for_bytes(num_bytes);
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** get the given text string as either char or wchar_t according to the given type */
+#define C4_TXTTY(txt, type) \
+    /* is there a smarter way to do this? */\
+    c4::detail::literal_as<type>::get(txt, C4_WIDEN(txt))
+
+namespace detail {
+template<typename C>
+struct literal_as;
+
+template<>
+struct literal_as<char>
+{
+    C4_ALWAYS_INLINE static constexpr const char* get(const char* str, const wchar_t *)
+    {
+        return str;
+    }
+};
+template<>
+struct literal_as<wchar_t>
+{
+    C4_ALWAYS_INLINE static constexpr const wchar_t* get(const char*, const wchar_t *wstr)
+    {
+        return wstr;
+    }
+};
+} // namespace detail
+
+} // namespace c4
+
+#endif /* _C4_CHAR_TRAITS_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/char_traits.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/hash.hpp
+// https://github.com/biojppm/c4core/src/c4/hash.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_HASH_HPP_
+#define _C4_HASH_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+#include <climits>
+
+/** @file hash.hpp */
+
+/** @defgroup hash Hash utils
+ * @see http://aras-p.info/blog/2016/08/02/Hash-Functions-all-the-way-down/ */
+
+namespace c4 {
+
+namespace detail {
+
+/** @internal
+ * @ingroup hash
+ * @see this was taken a great answer in stackoverflow:
+ * https://stackoverflow.com/a/34597785/5875572
+ * @see http://aras-p.info/blog/2016/08/02/Hash-Functions-all-the-way-down/ */
+template<typename ResultT, ResultT OffsetBasis, ResultT Prime>
+class basic_fnv1a final
+{
+
+  static_assert(std::is_unsigned<ResultT>::value, "need unsigned integer");
+
+public:
+
+    using result_type = ResultT;
+
+private:
+
+    result_type state_ {};
+
+public:
+
+    C4_CONSTEXPR14 basic_fnv1a() noexcept : state_ {OffsetBasis} {}
+
+    C4_CONSTEXPR14 void update(const void *const data, const size_t size) noexcept
+    {
+        auto cdata = static_cast<const unsigned char *>(data);
+        auto acc = this->state_;
+        for(size_t i = 0; i < size; ++i)
+        {
+            const auto next = size_t(cdata[i]);
+            acc = (acc ^ next) * Prime;
+        }
+        this->state_ = acc;
+    }
+
+    C4_CONSTEXPR14 result_type digest() const noexcept
+    {
+        return this->state_;
+    }
+
+};
+
+using fnv1a_32 = basic_fnv1a<uint32_t, UINT32_C(          2166136261), UINT32_C(     16777619)>;
+using fnv1a_64 = basic_fnv1a<uint64_t, UINT64_C(14695981039346656037), UINT64_C(1099511628211)>;
+
+template<size_t Bits> struct fnv1a;
+template<> struct fnv1a<32> { using type = fnv1a_32; };
+template<> struct fnv1a<64> { using type = fnv1a_64; };
+
+} // namespace detail
+
+
+/** @ingroup hash */
+template<size_t Bits>
+using fnv1a_t = typename detail::fnv1a<Bits>::type;
+
+
+/** @ingroup hash */
+C4_CONSTEXPR14 inline size_t hash_bytes(const void *const data, const size_t size) noexcept
+{
+    fnv1a_t<CHAR_BIT * sizeof(size_t)> fn{};
+    fn.update(data, size);
+    return fn.digest();
+}
+
+/**
+ * @overload hash_bytes
+ * @ingroup hash */
+template<size_t N>
+C4_CONSTEXPR14 inline size_t hash_bytes(const char (&str)[N]) noexcept
+{
+    fnv1a_t<CHAR_BIT * sizeof(size_t)> fn{};
+    fn.update(str, N);
+    return fn.digest();
+}
+
+} // namespace c4
+
+
+#endif // _C4_HASH_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/hash.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/szconv.hpp
+// https://github.com/biojppm/c4core/src/c4/szconv.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_SZCONV_HPP_
+#define _C4_SZCONV_HPP_
+
+/** @file szconv.hpp utilities to deal safely with narrowing conversions */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+#include <limits>
+
+namespace c4 {
+
+/** @todo this would be so much easier with calls to numeric_limits::max()... */
+template<class SizeOut, class SizeIn>
+struct is_narrower_size : std::conditional
+<
+   (std::is_signed<SizeOut>::value == std::is_signed<SizeIn>::value)
+   ?
+   (sizeof(SizeOut) < sizeof(SizeIn))
+   :
+   (
+       (sizeof(SizeOut) < sizeof(SizeIn))
+       ||
+       (
+           (sizeof(SizeOut) == sizeof(SizeIn))
+           &&
+           (std::is_signed<SizeOut>::value && std::is_unsigned<SizeIn>::value)
+       )
+   ),
+   std::true_type,
+   std::false_type
+>::type
+{
+    static_assert(std::is_integral<SizeIn >::value, "must be integral type");
+    static_assert(std::is_integral<SizeOut>::value, "must be integral type");
+};
+
+
+/** when SizeOut is wider than SizeIn, assignment can occur without reservations */
+template<class SizeOut, class SizeIn>
+C4_ALWAYS_INLINE
+typename std::enable_if< ! is_narrower_size<SizeOut, SizeIn>::value, SizeOut>::type
+szconv(SizeIn sz) noexcept
+{
+    return static_cast<SizeOut>(sz);
+}
+
+/** when SizeOut is narrower than SizeIn, narrowing will occur, so we check
+ * for overflow. Note that this check is done only if C4_XASSERT is enabled.
+ * @see C4_XASSERT */
+template<class SizeOut, class SizeIn>
+C4_ALWAYS_INLINE
+typename std::enable_if<is_narrower_size<SizeOut, SizeIn>::value, SizeOut>::type
+szconv(SizeIn sz) C4_NOEXCEPT_X
+{
+    C4_XASSERT(sz >= 0);
+    C4_XASSERT_MSG((SizeIn)sz <= (SizeIn)std::numeric_limits<SizeOut>::max(), "size conversion overflow: in=%zu", (size_t)sz);
+    SizeOut szo = static_cast<SizeOut>(sz);
+    return szo;
+}
+
+} // namespace c4
+
+#endif /* _C4_SZCONV_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/szconv.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/blob.hpp
+// https://github.com/biojppm/c4core/src/c4/blob.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_BLOB_HPP_
+#define _C4_BLOB_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/types.hpp
+//#include "c4/types.hpp"
+#if !defined(C4_TYPES_HPP_) && !defined(_C4_TYPES_HPP_)
+#error "amalgamate: file c4/types.hpp must have been included at this point"
+#endif /* C4_TYPES_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+/** @file blob.hpp Mutable and immutable binary data blobs.
+*/
+
+namespace c4 {
+
+template<class T>
+struct blob_
+{
+    T *    buf;
+    size_t len;
+
+    C4_ALWAYS_INLINE blob_() noexcept : buf(), len() {}
+
+    C4_ALWAYS_INLINE blob_(blob_ const& that) noexcept = default;
+    C4_ALWAYS_INLINE blob_(blob_     && that) noexcept = default;
+    C4_ALWAYS_INLINE blob_& operator=(blob_     && that) noexcept = default;
+    C4_ALWAYS_INLINE blob_& operator=(blob_ const& that) noexcept = default;
+
+    // need to sfinae out copy constructors! (why? isn't the above sufficient?)
+    #define _C4_REQUIRE_NOT_SAME class=typename std::enable_if<( ! std::is_same<U, blob_>::value) && ( ! std::is_pointer<U>::value), T>::type
+    template<class U, _C4_REQUIRE_NOT_SAME> C4_ALWAYS_INLINE blob_(U &var) noexcept : buf(reinterpret_cast<T*>(&var)), len(sizeof(U)) {}
+    template<class U, _C4_REQUIRE_NOT_SAME> C4_ALWAYS_INLINE blob_& operator= (U &var) noexcept { buf = reinterpret_cast<T*>(&var); len = sizeof(U); return *this; }
+    #undef _C4_REQUIRE_NOT_SAME
+
+    template<class U, size_t N> C4_ALWAYS_INLINE blob_(U (&arr)[N]) noexcept : buf(reinterpret_cast<T*>(arr)), len(sizeof(U) * N) {}
+    template<class U, size_t N> C4_ALWAYS_INLINE blob_& operator= (U (&arr)[N]) noexcept { buf = reinterpret_cast<T*>(arr); len = sizeof(U) * N; return *this; }
+
+    template<class U>
+    C4_ALWAYS_INLINE blob_(U          *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(sizeof(U) * n) { C4_ASSERT(is_aligned(ptr)); }
+    C4_ALWAYS_INLINE blob_(void       *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {}
+    C4_ALWAYS_INLINE blob_(void const *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {}
+};
+
+/** an immutable binary blob */
+using cblob = blob_<cbyte>;
+/** a mutable binary blob */
+using  blob = blob_< byte>;
+
+C4_MUST_BE_TRIVIAL_COPY(blob);
+C4_MUST_BE_TRIVIAL_COPY(cblob);
+
+} // namespace c4
+
+#endif // _C4_BLOB_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/blob.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/substr_fwd.hpp
+// https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_SUBSTR_FWD_HPP_
+#define _C4_SUBSTR_FWD_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/export.hpp
+//#include "c4/export.hpp"
+#if !defined(C4_EXPORT_HPP_) && !defined(_C4_EXPORT_HPP_)
+#error "amalgamate: file c4/export.hpp must have been included at this point"
+#endif /* C4_EXPORT_HPP_ */
+
+
+namespace c4 {
+
+#ifndef DOXYGEN
+template<class C> struct basic_substring;
+using csubstr = C4CORE_EXPORT basic_substring<const char>;
+using substr = C4CORE_EXPORT basic_substring<char>;
+#endif // !DOXYGEN
+
+} // namespace c4
+
+#endif /* _C4_SUBSTR_FWD_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/substr.hpp
+// https://github.com/biojppm/c4core/src/c4/substr.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_SUBSTR_HPP_
+#define _C4_SUBSTR_HPP_
+
+/** @file substr.hpp read+write string views */
+
+//included above:
+//#include <string.h>
+//included above:
+//#include <ctype.h>
+//included above:
+//#include <type_traits>
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp
+//#include "c4/substr_fwd.hpp"
+#if !defined(C4_SUBSTR_FWD_HPP_) && !defined(_C4_SUBSTR_FWD_HPP_)
+#error "amalgamate: file c4/substr_fwd.hpp must have been included at this point"
+#endif /* C4_SUBSTR_FWD_HPP_ */
+
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wtype-limits" // disable warnings on size_t>=0, used heavily in assertions below. These assertions are a preparation step for providing the index type as a template parameter.
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+
+
+namespace c4 {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+
+template<typename C>
+static inline void _do_reverse(C *C4_RESTRICT first, C *C4_RESTRICT last)
+{
+    while(last > first)
+    {
+        C tmp = *last;
+        *last-- = *first;
+        *first++ = tmp;
+    }
+}
+
+} // namespace detail
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// utility macros to deuglify SFINAE code; undefined after the class.
+// https://stackoverflow.com/questions/43051882/how-to-disable-a-class-member-funrtion-for-certain-template-types
+#define C4_REQUIRE_RW(ret_type) \
+    template <typename U=C> \
+    typename std::enable_if< ! std::is_const<U>::value, ret_type>::type
+// non-const-to-const
+#define C4_NC2C(ty) \
+    typename std::enable_if<std::is_const<C>::value && ( ! std::is_const<ty>::value), ty>::type
+
+
+/** a non-owning string-view, consisting of a character pointer
+ * and a length.
+ *
+ * @note The pointer is explicitly restricted.
+ * @note Because of a C++ limitation, there cannot coexist overloads for
+ * constructing from a char[N] and a char*; the latter will always be chosen
+ * by the compiler. To construct an object of this type, call to_substr() or
+ * to_csubstr(). For a more detailed explanation on why the overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html
+ *
+ * @see to_substr()
+ * @see to_csubstr()
+ */
+template<class C>
+struct C4CORE_EXPORT basic_substring
+{
+public:
+
+    /** a restricted pointer to the first character of the substring */
+    C * C4_RESTRICT str;
+    /** the length of the substring */
+    size_t          len;
+
+public:
+
+    /** @name Types */
+    /** @{ */
+
+    using  CC  = typename std::add_const<C>::type;     //!< CC=const char
+    using NCC_ = typename std::remove_const<C>::type; //!< NCC_=non const char
+
+    using ro_substr = basic_substring<CC>;
+    using rw_substr = basic_substring<NCC_>;
+
+    using char_type = C;
+    using size_type = size_t;
+
+    using iterator = C*;
+    using const_iterator = CC*;
+
+    enum : size_t { npos = (size_t)-1, NONE = (size_t)-1 };
+
+    /// convert automatically to substring of const C
+    operator ro_substr () const { ro_substr s(str, len); return s; }
+
+    /** @} */
+
+public:
+
+    /** @name Default construction and assignment */
+    /** @{ */
+
+    constexpr basic_substring() : str(nullptr), len(0) {}
+
+    constexpr basic_substring(basic_substring const&) = default;
+    constexpr basic_substring(basic_substring     &&) = default;
+    constexpr basic_substring(std::nullptr_t) : str(nullptr), len(0) {}
+
+    basic_substring& operator= (basic_substring const&) = default;
+    basic_substring& operator= (basic_substring     &&) = default;
+    basic_substring& operator= (std::nullptr_t) { str = nullptr; len = 0; return *this; }
+
+    /** @} */
+
+public:
+
+    /** @name Construction and assignment from characters with the same type */
+    /** @{ */
+
+    //basic_substring(C *s_) : str(s_), len(s_ ? strlen(s_) : 0) {}
+    /** the overload for receiving a single C* pointer will always
+     * hide the array[N] overload. So it is disabled. If you want to
+     * construct a substr from a single pointer containing a C-style string,
+     * you can call c4::to_substr()/c4::to_csubstr().
+     * @see c4::to_substr()
+     * @see c4::to_csubstr() */
+    template<size_t N>
+    constexpr basic_substring(C (&s_)[N]) noexcept : str(s_), len(N-1) {}
+    basic_substring(C *s_, size_t len_) : str(s_), len(len_) { C4_ASSERT(str || !len_); }
+    basic_substring(C *beg_, C *end_) : str(beg_), len(static_cast<size_t>(end_ - beg_)) { C4_ASSERT(end_ >= beg_); }
+
+    //basic_substring& operator= (C *s_) { this->assign(s_); return *this; }
+    template<size_t N>
+    basic_substring& operator= (C (&s_)[N]) { this->assign<N>(s_); return *this; }
+
+    //void assign(C *s_) { str = (s_); len = (s_ ? strlen(s_) : 0); }
+    /** the overload for receiving a single C* pointer will always
+     * hide the array[N] overload. So it is disabled. If you want to
+     * construct a substr from a single pointer containing a C-style string,
+     * you can call c4::to_substr()/c4::to_csubstr().
+     * @see c4::to_substr()
+     * @see c4::to_csubstr() */
+    template<size_t N>
+    void assign(C (&s_)[N]) { str = (s_); len = (N-1); }
+    void assign(C *s_, size_t len_) { str = s_; len = len_; C4_ASSERT(str || !len_); }
+    void assign(C *beg_, C *end_) { C4_ASSERT(end_ >= beg_); str = (beg_); len = (end_ - beg_); }
+
+    void clear() { str = nullptr; len = 0; }
+
+    /** @} */
+
+public:
+
+    /** @name Construction from non-const characters */
+    /** @{ */
+
+    // when the char type is const, allow construction and assignment from non-const chars
+
+    /** only available when the char type is const */
+    template<size_t N, class U=NCC_> explicit basic_substring(C4_NC2C(U) (&s_)[N]) { str = s_; len = N-1; }
+    /** only available when the char type is const */
+    template<          class U=NCC_>          basic_substring(C4_NC2C(U) *s_, size_t len_) { str = s_; len = len_; }
+    /** only available when the char type is const */
+    template<          class U=NCC_>          basic_substring(C4_NC2C(U) *beg_, C4_NC2C(U) *end_) { C4_ASSERT(end_ >= beg_); str = beg_; len = end_ - beg_;  }
+
+    /** only available when the char type is const */
+    template<size_t N, class U=NCC_> void assign(C4_NC2C(U) (&s_)[N]) { str = s_; len = N-1; }
+    /** only available when the char type is const */
+    template<          class U=NCC_> void assign(C4_NC2C(U) *s_, size_t len_) { str = s_; len = len_; }
+    /** only available when the char type is const */
+    template<          class U=NCC_> void assign(C4_NC2C(U) *beg_, C4_NC2C(U) *end_) { C4_ASSERT(end_ >= beg_); str = beg_; len = end_ - beg_;  }
+
+    /** only available when the char type is const */
+    template<size_t N, class U=NCC_>
+    basic_substring& operator=(C4_NC2C(U) (&s_)[N]) { str = s_; len = N-1; return *this; }
+
+    /** @} */
+
+public:
+
+    /** @name Standard accessor methods */
+    /** @{ */
+
+    bool   has_str()   const { return ! empty() && str[0] != C(0); }
+    bool   empty()     const { return (len == 0 || str == nullptr); }
+    bool   not_empty() const { return (len != 0 && str != nullptr); }
+    size_t size()      const { return len; }
+
+    iterator begin() { return str; }
+    iterator end  () { return str + len; }
+
+    const_iterator begin() const { return str; }
+    const_iterator end  () const { return str + len; }
+
+    C      * data()       { return str; }
+    C const* data() const { return str; }
+
+    inline C      & operator[] (size_t i)       { C4_ASSERT(i >= 0 && i < len); return str[i]; }
+    inline C const& operator[] (size_t i) const { C4_ASSERT(i >= 0 && i < len); return str[i]; }
+
+    inline C      & front()       { C4_ASSERT(len > 0 && str != nullptr); return *str; }
+    inline C const& front() const { C4_ASSERT(len > 0 && str != nullptr); return *str; }
+
+    inline C      & back()       { C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }
+    inline C const& back() const { C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }
+
+    /** @} */
+
+public:
+
+    /** @name Comparison methods */
+    /** @{ */
+
+    int compare(C const c) const
+    {
+        C4_XASSERT((str != nullptr) || len == 0);
+        if( ! len)
+            return -1;
+        if(*str == c)
+            return static_cast<int>(len - 1);
+        return *str - c;
+    }
+
+    int compare(const char *that, size_t sz) const
+    {
+        C4_XASSERT(that || sz  == 0);
+        C4_XASSERT(str  || len == 0);
+        if(C4_LIKELY(str && that))
+        {
+            int ret = strncmp(str, that, len < sz ? len : sz);
+            if(ret == 0 && len != sz)
+                ret = len < sz ? -1 : 1;
+            return ret;
+        }
+        if((!str && !that) || (len == sz))
+        {
+            C4_XASSERT(len == 0 && sz == 0);
+            return 0;
+        }
+        return len < sz ? -1 : 1;
+    }
+
+    C4_ALWAYS_INLINE int compare(ro_substr const that) const { return this->compare(that.str, that.len); }
+
+    C4_ALWAYS_INLINE bool operator== (std::nullptr_t) const { return str == nullptr || len == 0; }
+    C4_ALWAYS_INLINE bool operator!= (std::nullptr_t) const { return str != nullptr || len == 0; }
+
+    C4_ALWAYS_INLINE bool operator== (C const c) const { return this->compare(c) == 0; }
+    C4_ALWAYS_INLINE bool operator!= (C const c) const { return this->compare(c) != 0; }
+    C4_ALWAYS_INLINE bool operator<  (C const c) const { return this->compare(c) <  0; }
+    C4_ALWAYS_INLINE bool operator>  (C const c) const { return this->compare(c) >  0; }
+    C4_ALWAYS_INLINE bool operator<= (C const c) const { return this->compare(c) <= 0; }
+    C4_ALWAYS_INLINE bool operator>= (C const c) const { return this->compare(c) >= 0; }
+
+    template<class U> C4_ALWAYS_INLINE bool operator== (basic_substring<U> const that) const { return this->compare(that) == 0; }
+    template<class U> C4_ALWAYS_INLINE bool operator!= (basic_substring<U> const that) const { return this->compare(that) != 0; }
+    template<class U> C4_ALWAYS_INLINE bool operator<  (basic_substring<U> const that) const { return this->compare(that) <  0; }
+    template<class U> C4_ALWAYS_INLINE bool operator>  (basic_substring<U> const that) const { return this->compare(that) >  0; }
+    template<class U> C4_ALWAYS_INLINE bool operator<= (basic_substring<U> const that) const { return this->compare(that) <= 0; }
+    template<class U> C4_ALWAYS_INLINE bool operator>= (basic_substring<U> const that) const { return this->compare(that) >= 0; }
+
+    template<size_t N> C4_ALWAYS_INLINE bool operator== (const char (&that)[N]) const { return this->compare(that, N-1) == 0; }
+    template<size_t N> C4_ALWAYS_INLINE bool operator!= (const char (&that)[N]) const { return this->compare(that, N-1) != 0; }
+    template<size_t N> C4_ALWAYS_INLINE bool operator<  (const char (&that)[N]) const { return this->compare(that, N-1) <  0; }
+    template<size_t N> C4_ALWAYS_INLINE bool operator>  (const char (&that)[N]) const { return this->compare(that, N-1) >  0; }
+    template<size_t N> C4_ALWAYS_INLINE bool operator<= (const char (&that)[N]) const { return this->compare(that, N-1) <= 0; }
+    template<size_t N> C4_ALWAYS_INLINE bool operator>= (const char (&that)[N]) const { return this->compare(that, N-1) >= 0; }
+
+    /** @} */
+
+public:
+
+    /** @name Sub-selection methods */
+    /** @{ */
+
+    /** true if *this is a substring of that (ie, from the same buffer) */
+    inline bool is_sub(ro_substr const that) const
+    {
+        return that.is_super(*this);
+    }
+
+    /** true if that is a substring of *this (ie, from the same buffer) */
+    inline bool is_super(ro_substr const that) const
+    {
+        if(C4_UNLIKELY(len == 0))
+        {
+            return that.len == 0 && that.str == str && str != nullptr;
+        }
+        return that.begin() >= begin() && that.end() <= end();
+    }
+
+    /** true if there is overlap of at least one element between that and *this */
+    inline bool overlaps(ro_substr const that) const
+    {
+        // thanks @timwynants
+        return (that.end() > begin() && that.begin() < end());
+    }
+
+public:
+
+    /** return [first,len[ */
+    basic_substring sub(size_t first) const
+    {
+        C4_ASSERT(first >= 0 && first <= len);
+        return basic_substring(str + first, len - first);
+    }
+
+    /** return [first,first+num[. If num==npos, return [first,len[ */
+    basic_substring sub(size_t first, size_t num) const
+    {
+        C4_ASSERT(first >= 0 && first <= len);
+        C4_ASSERT((num >= 0 && num <= len) || (num == npos));
+        size_t rnum = num != npos ? num : len - first;
+        C4_ASSERT((first >= 0 && first + rnum <= len) || (num == 0));
+        return basic_substring(str + first, rnum);
+    }
+
+    /** return [first,last[. If last==npos, return [first,len[ */
+    basic_substring range(size_t first, size_t last=npos) const
+    {
+        C4_ASSERT(first >= 0 && first <= len);
+        last = last != npos ? last : len;
+        C4_ASSERT(first <= last);
+        C4_ASSERT(last  >= 0 && last  <= len);
+        return basic_substring(str + first, last - first);
+    }
+
+    /** return [0,num[*/
+    basic_substring first(size_t num) const
+    {
+        return sub(0, num);
+    }
+
+    /** return [len-num,len[*/
+    basic_substring last(size_t num) const
+    {
+        if(num == npos)
+            return *this;
+        return sub(len - num);
+    }
+
+    /** offset from the ends: return [left,len-right[ ; ie, trim a
+        number of characters from the left and right. This is
+        equivalent to python's negative list indices. */
+    basic_substring offs(size_t left, size_t right) const
+    {
+        C4_ASSERT(left  >= 0 && left  <= len);
+        C4_ASSERT(right >= 0 && right <= len);
+        C4_ASSERT(left  <= len - right + 1);
+        return basic_substring(str + left, len - right - left);
+    }
+
+    /** return [0, pos+include_pos[ */
+    basic_substring left_of(size_t pos, bool include_pos=false) const
+    {
+        if(pos == npos)
+            return *this;
+        return first(pos + include_pos);
+    }
+
+    /** return [pos+!include_pos, len[ */
+    basic_substring right_of(size_t pos, bool include_pos=false) const
+    {
+        if(pos == npos)
+            return sub(len, 0);
+        return sub(pos + !include_pos);
+    }
+
+public:
+
+    /** given @p subs a substring of the current string, get the
+     * portion of the current string to the left of it */
+    basic_substring left_of(ro_substr const subs) const
+    {
+        C4_ASSERT(is_super(subs) || subs.empty());
+        auto ssb = subs.begin();
+        auto b = begin();
+        auto e = end();
+        if(ssb >= b && ssb <= e)
+            return sub(0, static_cast<size_t>(ssb - b));
+        else
+            return sub(0, 0);
+    }
+
+    /** given @p subs a substring of the current string, get the
+     * portion of the current string to the right of it */
+    basic_substring right_of(ro_substr const subs) const
+    {
+        C4_ASSERT(is_super(subs) || subs.empty());
+        auto sse = subs.end();
+        auto b = begin();
+        auto e = end();
+        if(sse >= b && sse <= e)
+            return sub(static_cast<size_t>(sse - b), static_cast<size_t>(e - sse));
+        else
+            return sub(0, 0);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Removing characters (trim()) / patterns (strip()) from the tips of the string */
+    /** @{ */
+
+    /** trim left */
+    basic_substring triml(const C c) const
+    {
+        if( ! empty())
+        {
+            size_t pos = first_not_of(c);
+            if(pos != npos)
+                return sub(pos);
+        }
+        return sub(0, 0);
+    }
+    /** trim left ANY of the characters.
+     * @see stripl() to remove a pattern from the left */
+    basic_substring triml(ro_substr chars) const
+    {
+        if( ! empty())
+        {
+            size_t pos = first_not_of(chars);
+            if(pos != npos)
+                return sub(pos);
+        }
+        return sub(0, 0);
+    }
+
+    /** trim the character c from the right */
+    basic_substring trimr(const C c) const
+    {
+        if( ! empty())
+        {
+            size_t pos = last_not_of(c, npos);
+            if(pos != npos)
+                return sub(0, pos+1);
+        }
+        return sub(0, 0);
+    }
+    /** trim right ANY of the characters
+     * @see stripr() to remove a pattern from the right  */
+    basic_substring trimr(ro_substr chars) const
+    {
+        if( ! empty())
+        {
+            size_t pos = last_not_of(chars, npos);
+            if(pos != npos)
+                return sub(0, pos+1);
+        }
+        return sub(0, 0);
+    }
+
+    /** trim the character c left and right */
+    basic_substring trim(const C c) const
+    {
+        return triml(c).trimr(c);
+    }
+    /** trim left and right ANY of the characters
+     * @see strip() to remove a pattern from the left and right */
+    basic_substring trim(ro_substr const chars) const
+    {
+        return triml(chars).trimr(chars);
+    }
+
+    /** remove a pattern from the left
+     * @see triml() to remove characters*/
+    basic_substring stripl(ro_substr pattern) const
+    {
+        if( ! begins_with(pattern))
+            return *this;
+        return sub(pattern.len < len ? pattern.len : len);
+    }
+
+    /** remove a pattern from the right
+     * @see trimr() to remove characters*/
+    basic_substring stripr(ro_substr pattern) const
+    {
+        if( ! ends_with(pattern))
+            return *this;
+        return left_of(len - (pattern.len < len ? pattern.len : len));
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Lookup methods */
+    /** @{ */
+
+    inline size_t find(const C c, size_t start_pos=0) const
+    {
+        return first_of(c, start_pos);
+    }
+    inline size_t find(ro_substr pattern, size_t start_pos=0) const
+    {
+        C4_ASSERT(start_pos == npos || (start_pos >= 0 && start_pos <= len));
+        if(len < pattern.len) return npos;
+        for(size_t i = start_pos, e = len - pattern.len + 1; i < e; ++i)
+        {
+            bool gotit = true;
+            for(size_t j = 0; j < pattern.len; ++j)
+            {
+                C4_ASSERT(i + j < len);
+                if(str[i + j] != pattern.str[j])
+                {
+                    gotit = false;
+                    break;
+                }
+            }
+            if(gotit)
+            {
+                return i;
+            }
+        }
+        return npos;
+    }
+
+public:
+
+    /** count the number of occurrences of c */
+    inline size_t count(const C c, size_t pos=0) const
+    {
+        C4_ASSERT(pos >= 0 && pos <= len);
+        size_t num = 0;
+        pos = find(c, pos);
+        while(pos != npos)
+        {
+            ++num;
+            pos = find(c, pos + 1);
+        }
+        return num;
+    }
+
+    /** count the number of occurrences of s */
+    inline size_t count(ro_substr c, size_t pos=0) const
+    {
+        C4_ASSERT(pos >= 0 && pos <= len);
+        size_t num = 0;
+        pos = find(c, pos);
+        while(pos != npos)
+        {
+            ++num;
+            pos = find(c, pos + c.len);
+        }
+        return num;
+    }
+
+    /** get the substr consisting of the first occurrence of @p c after @p pos, or an empty substr if none occurs */
+    inline basic_substring select(const C c, size_t pos=0) const
+    {
+        pos = find(c, pos);
+        return pos != npos ? sub(pos, 1) : basic_substring();
+    }
+
+    /** get the substr consisting of the first occurrence of @p pattern after @p pos, or an empty substr if none occurs */
+    inline basic_substring select(ro_substr pattern, size_t pos=0) const
+    {
+        pos = find(pattern, pos);
+        return pos != npos ? sub(pos, pattern.len) : basic_substring();
+    }
+
+public:
+
+    struct first_of_any_result
+    {
+        size_t which;
+        size_t pos;
+        inline operator bool() const { return which != NONE && pos != npos; }
+    };
+
+    first_of_any_result first_of_any(ro_substr s0, ro_substr s1) const
+    {
+        ro_substr s[2] = {s0, s1};
+        return first_of_any_iter(&s[0], &s[0] + 2);
+    }
+
+    first_of_any_result first_of_any(ro_substr s0, ro_substr s1, ro_substr s2) const
+    {
+        ro_substr s[3] = {s0, s1, s2};
+        return first_of_any_iter(&s[0], &s[0] + 3);
+    }
+
+    first_of_any_result first_of_any(ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3) const
+    {
+        ro_substr s[4] = {s0, s1, s2, s3};
+        return first_of_any_iter(&s[0], &s[0] + 4);
+    }
+
+    first_of_any_result first_of_any(ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3, ro_substr s4) const
+    {
+        ro_substr s[5] = {s0, s1, s2, s3, s4};
+        return first_of_any_iter(&s[0], &s[0] + 5);
+    }
+
+    template<class It>
+    first_of_any_result first_of_any_iter(It first_span, It last_span) const
+    {
+        for(size_t i = 0; i < len; ++i)
+        {
+            size_t curr = 0;
+            for(It it = first_span; it != last_span; ++curr, ++it)
+            {
+                auto const& chars = *it;
+                if((i + chars.len) > len) continue;
+                bool gotit = true;
+                for(size_t j = 0; j < chars.len; ++j)
+                {
+                    C4_ASSERT(i + j < len);
+                    if(str[i + j] != chars[j])
+                    {
+                        gotit = false;
+                        break;
+                    }
+                }
+                if(gotit)
+                {
+                    return {curr, i};
+                }
+            }
+        }
+        return {NONE, npos};
+    }
+
+public:
+
+    /** true if the first character of the string is @p c */
+    bool begins_with(const C c) const
+    {
+        return len > 0 ? str[0] == c : false;
+    }
+
+    /** true if the first @p num characters of the string are @p c */
+    bool begins_with(const C c, size_t num) const
+    {
+        if(len < num)
+        {
+            return false;
+        }
+        for(size_t i = 0; i < num; ++i)
+        {
+            if(str[i] != c)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /** true if the string begins with the given @p pattern */
+    bool begins_with(ro_substr pattern) const
+    {
+        if(len < pattern.len)
+        {
+            return false;
+        }
+        for(size_t i = 0; i < pattern.len; ++i)
+        {
+            if(str[i] != pattern[i])
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /** true if the first character of the string is any of the given @p chars */
+    bool begins_with_any(ro_substr chars) const
+    {
+        if(len == 0)
+        {
+            return false;
+        }
+        for(size_t i = 0; i < chars.len; ++i)
+        {
+            if(str[0] == chars.str[i])
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** true if the last character of the string is @p c */
+    bool ends_with(const C c) const
+    {
+        return len > 0 ? str[len-1] == c : false;
+    }
+
+    /** true if the last @p num characters of the string are @p c */
+    bool ends_with(const C c, size_t num) const
+    {
+        if(len < num)
+        {
+            return false;
+        }
+        for(size_t i = len - num; i < len; ++i)
+        {
+            if(str[i] != c)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /** true if the string ends with the given @p pattern */
+    bool ends_with(ro_substr pattern) const
+    {
+        if(len < pattern.len)
+        {
+            return false;
+        }
+        for(size_t i = 0, s = len-pattern.len; i < pattern.len; ++i)
+        {
+            if(str[s+i] != pattern[i])
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /** true if the last character of the string is any of the given @p chars */
+    bool ends_with_any(ro_substr chars) const
+    {
+        if(len == 0)
+        {
+            return false;
+        }
+        for(size_t i = 0; i < chars.len; ++i)
+        {
+            if(str[len - 1] == chars[i])
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+public:
+
+    /** @return the first position where c is found in the string, or npos if none is found */
+    size_t first_of(const C c, size_t start=0) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        for(size_t i = start; i < len; ++i)
+        {
+            if(str[i] == c)
+                return i;
+        }
+        return npos;
+    }
+
+    /** @return the last position where c is found in the string, or npos if none is found */
+    size_t last_of(const C c, size_t start=npos) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        if(start == npos)
+            start = len;
+        for(size_t i = start-1; i != size_t(-1); --i)
+        {
+            if(str[i] == c)
+                return i;
+        }
+        return npos;
+    }
+
+    /** @return the first position where ANY of the chars is found in the string, or npos if none is found */
+    size_t first_of(ro_substr chars, size_t start=0) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        for(size_t i = start; i < len; ++i)
+        {
+            for(size_t j = 0; j < chars.len; ++j)
+            {
+                if(str[i] == chars[j])
+                    return i;
+            }
+        }
+        return npos;
+    }
+
+    /** @return the last position where ANY of the chars is found in the string, or npos if none is found */
+    size_t last_of(ro_substr chars, size_t start=npos) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        if(start == npos)
+            start = len;
+        for(size_t i = start-1; i != size_t(-1); --i)
+        {
+            for(size_t j = 0; j < chars.len; ++j)
+            {
+                if(str[i] == chars[j])
+                    return i;
+            }
+        }
+        return npos;
+    }
+
+public:
+
+    size_t first_not_of(const C c, size_t start=0) const
+    {
+        C4_ASSERT((start >= 0 && start <= len) || (start == len && len == 0));
+        for(size_t i = start; i < len; ++i)
+        {
+            if(str[i] != c)
+                return i;
+        }
+        return npos;
+    }
+
+    size_t last_not_of(const C c, size_t start=npos) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        if(start == npos)
+            start = len;
+        for(size_t i = start-1; i != size_t(-1); --i)
+        {
+            if(str[i] != c)
+                return i;
+        }
+        return npos;
+    }
+
+    size_t first_not_of(ro_substr chars, size_t start=0) const
+    {
+        C4_ASSERT((start >= 0 && start <= len) || (start == len && len == 0));
+        for(size_t i = start; i < len; ++i)
+        {
+            bool gotit = true;
+            for(size_t j = 0; j < chars.len; ++j)
+            {
+                if(str[i] == chars.str[j])
+                {
+                    gotit = false;
+                    break;
+                }
+            }
+            if(gotit)
+            {
+                return i;
+            }
+        }
+        return npos;
+    }
+
+    size_t last_not_of(ro_substr chars, size_t start=npos) const
+    {
+        C4_ASSERT(start == npos || (start >= 0 && start <= len));
+        if(start == npos)
+            start = len;
+        for(size_t i = start-1; i != size_t(-1); --i)
+        {
+            bool gotit = true;
+            for(size_t j = 0; j < chars.len; ++j)
+            {
+                if(str[i] == chars.str[j])
+                {
+                    gotit = false;
+                    break;
+                }
+            }
+            if(gotit)
+            {
+                return i;
+            }
+        }
+        return npos;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Range lookup methods */
+    /** @{ */
+
+    /** get the range delimited by an open-close pair of characters.
+     * @note There must be no nested pairs.
+     * @note No checks for escapes are performed. */
+    basic_substring pair_range(CC open, CC close) const
+    {
+        size_t b = find(open);
+        if(b == npos)
+            return basic_substring();
+        size_t e = find(close, b+1);
+        if(e == npos)
+            return basic_substring();
+        basic_substring ret = range(b, e+1);
+        C4_ASSERT(ret.sub(1).find(open) == npos);
+        return ret;
+    }
+
+    /** get the range delimited by a single open-close character (eg, quotes).
+     * @note The open-close character can be escaped. */
+    basic_substring pair_range_esc(CC open_close, CC escape=CC('\\'))
+    {
+        size_t b = find(open_close);
+        if(b == npos) return basic_substring();
+        for(size_t i = b+1; i < len; ++i)
+        {
+            CC c = str[i];
+            if(c == open_close)
+            {
+                if(str[i-1] != escape)
+                {
+                    return range(b, i+1);
+                }
+            }
+        }
+        return basic_substring();
+    }
+
+    /** get the range delimited by an open-close pair of characters,
+     * with possibly nested occurrences. No checks for escapes are
+     * performed. */
+    basic_substring pair_range_nested(CC open, CC close) const
+    {
+        size_t b = find(open);
+        if(b == npos) return basic_substring();
+        size_t e, curr = b+1, count = 0;
+        const char both[] = {open, close, '\0'};
+        while((e = first_of(both, curr)) != npos)
+        {
+            if(str[e] == open)
+            {
+                ++count;
+                curr = e+1;
+            }
+            else if(str[e] == close)
+            {
+                if(count == 0) return range(b, e+1);
+                --count;
+                curr = e+1;
+            }
+        }
+        return basic_substring();
+    }
+
+    basic_substring unquoted() const
+    {
+        constexpr const C dq('"'), sq('\'');
+        if(len >= 2 && (str[len - 2] != C('\\')) &&
+           ((begins_with(sq) && ends_with(sq))
+            ||
+            (begins_with(dq) && ends_with(dq))))
+        {
+            return range(1, len -1);
+        }
+        return *this;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Number-matching query methods */
+    /** @{ */
+
+    /** @return true if the substring contents are a floating-point or integer number.
+     * @note any leading or trailing whitespace will return false. */
+    bool is_number() const
+    {
+        if(empty() || (first_non_empty_span().empty()))
+            return false;
+        if(first_uint_span() == *this)
+            return true;
+        if(first_int_span() == *this)
+            return true;
+        if(first_real_span() == *this)
+            return true;
+        return false;
+    }
+
+    /** @return true if the substring contents are a real number.
+     * @note any leading or trailing whitespace will return false. */
+    bool is_real() const
+    {
+        if(empty() || (first_non_empty_span().empty()))
+            return false;
+        if(first_real_span() == *this)
+            return true;
+        return false;
+    }
+
+    /** @return true if the substring contents are an integer number.
+     * @note any leading or trailing whitespace will return false. */
+    bool is_integer() const
+    {
+        if(empty() || (first_non_empty_span().empty()))
+            return false;
+        if(first_uint_span() == *this)
+            return true;
+        if(first_int_span() == *this)
+            return true;
+        return false;
+    }
+
+    /** @return true if the substring contents are an unsigned integer number.
+     * @note any leading or trailing whitespace will return false. */
+    bool is_unsigned_integer() const
+    {
+        if(empty() || (first_non_empty_span().empty()))
+            return false;
+        if(first_uint_span() == *this)
+            return true;
+        return false;
+    }
+
+    /** get the first span consisting exclusively of non-empty characters */
+    basic_substring first_non_empty_span() const
+    {
+        constexpr const ro_substr empty_chars(" \n\r\t");
+        size_t pos = first_not_of(empty_chars);
+        if(pos == npos)
+            return first(0);
+        auto ret = sub(pos);
+        pos = ret.first_of(empty_chars);
+        return ret.first(pos);
+    }
+
+    /** get the first span which can be interpreted as an unsigned integer */
+    basic_substring first_uint_span() const
+    {
+        basic_substring ne = first_non_empty_span();
+        if(ne.empty())
+            return ne;
+        if(ne.str[0] == '-')
+            return first(0);
+        size_t skip_start = (ne.str[0] == '+') ? 1 : 0;
+        return ne._first_integral_span(skip_start);
+    }
+
+    /** get the first span which can be interpreted as a signed integer */
+    basic_substring first_int_span() const
+    {
+        basic_substring ne = first_non_empty_span();
+        if(ne.empty())
+            return ne;
+        size_t skip_start = (ne.str[0] == '+' || ne.str[0] == '-') ? 1 : 0;
+        return ne._first_integral_span(skip_start);
+    }
+
+    basic_substring _first_integral_span(size_t skip_start) const
+    {
+        C4_ASSERT(!empty());
+        if(skip_start == len) {
+            return first(0);
+        }
+        C4_ASSERT(skip_start < len);
+        if(first_of_any("0x", "0X")) // hexadecimal
+        {
+            skip_start += 2;
+            if(len == skip_start)
+                return first(0);
+            for(size_t i = skip_start; i < len; ++i)
+            {
+                if( ! _is_hex_char(str[i]))
+                    return _is_delim_char(str[i]) ? first(i) : first(0);
+            }
+        }
+        else if(first_of_any("0o", "0O")) // octal
+        {
+            skip_start += 2;
+            if(len == skip_start)
+                return first(0);
+            for(size_t i = skip_start; i < len; ++i)
+            {
+                char c = str[i];
+                if(c < '0' || c > '7')
+                    return _is_delim_char(str[i]) ? first(i) : first(0);
+            }
+        }
+        else if(first_of_any("0b", "0B")) // binary
+        {
+            skip_start += 2;
+            if(len == skip_start)
+                return first(0);
+            for(size_t i = skip_start; i < len; ++i)
+            {
+                char c = str[i];
+                if(c != '0' && c != '1')
+                    return _is_delim_char(c) ? first(i) : first(0);
+            }
+        }
+        else // otherwise, decimal
+        {
+            if(len == skip_start)
+                return first(0);
+            for(size_t i = skip_start; i < len; ++i)
+            {
+                char c = str[i];
+                if(c < '0' || c > '9')
+                    return _is_delim_char(c) ? first(i) : first(0);
+            }
+        }
+        return *this;
+    }
+
+    /** get the first span which can be interpreted as a real (floating-point) number */
+    basic_substring first_real_span() const
+    {
+        basic_substring ne = first_non_empty_span();
+        if(ne.empty())
+            return ne;
+        size_t skip_start = (ne.str[0] == '+' || ne.str[0] == '-') ? 1 : 0;
+        if(ne.first_of_any("0x", "0X")) // hexadecimal
+        {
+            skip_start += 2;
+            if(ne.len == skip_start)
+                return ne.first(0);
+            for(size_t i = skip_start; i < ne.len; ++i)
+            {
+                char c = ne.str[i];
+                if(( ! _is_hex_char(c)) && c != '.' && c != 'p' && c != 'P')
+                {
+                    if(c == '-' || c == '+')
+                    {
+                        // we can also have a sign for the exponent
+                        if(i > 1 && (ne[i-1] == 'p' || ne[i-1] == 'P'))
+                        {
+                            continue;
+                        }
+                    }
+                    return _is_delim_char(c) ? ne.first(i) : ne.first(0);
+                }
+            }
+        }
+        else if(ne.first_of_any("0b", "0B")) // binary
+        {
+            skip_start += 2;
+            if(ne.len == skip_start)
+                return ne.first(0);
+            for(size_t i = skip_start; i < ne.len; ++i)
+            {
+                char c = ne.str[i];
+                if(c != '0' && c != '1' && c != '.')
+                {
+                    return _is_delim_char(c) ? ne.first(i) : ne.first(0);
+                }
+            }
+        }
+        else if(ne.first_of_any("0o", "0O")) // octal
+        {
+            skip_start += 2;
+            if(ne.len == skip_start)
+                return ne.first(0);
+            for(size_t i = skip_start; i < ne.len; ++i)
+            {
+                char c = ne.str[i];
+                if((c < '0' || c > '7') && c != '.')
+                {
+                    return _is_delim_char(c) ? ne.first(i) : ne.first(0);
+                }
+            }
+        }
+        else // assume decimal
+        {
+            if(ne.len == skip_start)
+                return ne.first(0);
+            for(size_t i = skip_start; i < ne.len; ++i)
+            {
+                char c = ne.str[i];
+                if((c < '0' || c > '9') && (c != '.' && c != 'e' && c != 'E'))
+                {
+                    if(c == '-' || c == '+')
+                    {
+                        // we can also have a sign for the exponent
+                        if(i > 1 && (ne[i-1] == 'e' || ne[i-1] == 'E'))
+                        {
+                            continue;
+                        }
+                    }
+                    else if(i == skip_start)
+                    {
+                        if(c == 'i')
+                        {
+                            if(ne.len >= skip_start + 8 && ne.sub(skip_start, 8) == "infinity")
+                                return _is_delim_char(ne.str[skip_start + 8]) ? ne.first(skip_start + 8) : ne.first(0);
+                            else if(ne.len >= skip_start + 3 && ne.sub(skip_start, 3) == "inf")
+                                return _is_delim_char(ne.str[skip_start + 3]) ? ne.first(skip_start + 3) : ne.first(0);
+                            else
+                                return ne.first(0);
+                        }
+                        else if(c == 'n')
+                        {
+                            if(ne.len >= skip_start + 3 && ne.sub(skip_start, 3) == "nan")
+                                return _is_delim_char(ne.str[skip_start + 3]) ? ne.first(skip_start + 3) : ne.first(0);
+                            else
+                                return ne.first(0);
+                        }
+                        else
+                        {
+                            return ne.first(0);
+                        }
+                    }
+                    else
+                    {
+                        return _is_delim_char(c) ? ne.first(i) : ne.first(0);
+                    }
+                }
+            }
+        }
+        return ne;
+    }
+
+    /** true if the character is a delimiter character *at the end* */
+    static constexpr C4_ALWAYS_INLINE bool _is_delim_char(char c) noexcept
+    {
+        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\0'
+            || c == ']' || c == ')'  || c == '}'
+            || c == ',' || c == ';';
+    }
+
+    /** true if the character is in [0-9a-fA-F] */
+    static constexpr C4_ALWAYS_INLINE bool _is_hex_char(char c) noexcept
+    {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+    }
+
+    /** true if the character is in [0-9a-fA-F] */
+    static constexpr C4_ALWAYS_INLINE bool _is_oct_char(char c) noexcept
+    {
+        return (c >= '0' && c <= '7');
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Splitting methods */
+    /** @{ */
+
+    /** returns true if the string has not been exhausted yet, meaning
+     * it's ok to call next_split() again. When no instance of sep
+     * exists in the string, returns the full string. When the input
+     * is an empty string, the output string is the empty string. */
+    bool next_split(C sep, size_t *C4_RESTRICT start_pos, basic_substring *C4_RESTRICT out) const
+    {
+        if(C4_LIKELY(*start_pos < len))
+        {
+            for(size_t i = *start_pos, e = len; i < e; i++)
+            {
+                if(str[i] == sep)
+                {
+                    out->assign(str + *start_pos, i - *start_pos);
+                    *start_pos = i+1;
+                    return true;
+                }
+            }
+            out->assign(str + *start_pos, len - *start_pos);
+            *start_pos = len + 1;
+            return true;
+        }
+        else
+        {
+            bool valid = len > 0 && (*start_pos == len);
+            if(valid && !empty() && str[len-1] == sep)
+            {
+                out->assign(str + len, (size_t)0); // the cast is needed to prevent overload ambiguity
+            }
+            else
+            {
+                out->assign(str + len + 1, (size_t)0); // the cast is needed to prevent overload ambiguity
+            }
+            *start_pos = len + 1;
+            return valid;
+        }
+    }
+
+private:
+
+    struct split_proxy_impl
+    {
+        struct split_iterator_impl
+        {
+            split_proxy_impl const* m_proxy;
+            basic_substring m_str;
+            size_t m_pos;
+            NCC_ m_sep;
+
+            split_iterator_impl(split_proxy_impl const* proxy, size_t pos, C sep)
+                : m_proxy(proxy), m_pos(pos), m_sep(sep)
+            {
+                _tick();
+            }
+
+            void _tick()
+            {
+                m_proxy->m_str.next_split(m_sep, &m_pos, &m_str);
+            }
+
+            split_iterator_impl& operator++ () { _tick(); return *this; }
+            split_iterator_impl  operator++ (int) { split_iterator_impl it = *this; _tick(); return it; }
+
+            basic_substring& operator*  () { return  m_str; }
+            basic_substring* operator-> () { return &m_str; }
+
+            bool operator!= (split_iterator_impl const& that) const
+            {
+                return !(this->operator==(that));
+            }
+            bool operator== (split_iterator_impl const& that) const
+            {
+                C4_XASSERT((m_sep == that.m_sep) && "cannot compare split iterators with different separators");
+                if(m_str.size() != that.m_str.size())
+                    return false;
+                if(m_str.data() != that.m_str.data())
+                    return false;
+                return m_pos == that.m_pos;
+            }
+        };
+
+        basic_substring m_str;
+        size_t m_start_pos;
+        C m_sep;
+
+        split_proxy_impl(basic_substring str_, size_t start_pos, C sep)
+            : m_str(str_), m_start_pos(start_pos), m_sep(sep)
+        {
+        }
+
+        split_iterator_impl begin() const
+        {
+            auto it = split_iterator_impl(this, m_start_pos, m_sep);
+            return it;
+        }
+        split_iterator_impl end() const
+        {
+            size_t pos = m_str.size() + 1;
+            auto it = split_iterator_impl(this, pos, m_sep);
+            return it;
+        }
+    };
+
+public:
+
+    using split_proxy = split_proxy_impl;
+
+    /** a view into the splits */
+    split_proxy split(C sep, size_t start_pos=0) const
+    {
+        C4_XASSERT((start_pos >= 0 && start_pos < len) || empty());
+        auto ss = sub(0, len);
+        auto it = split_proxy(ss, start_pos, sep);
+        return it;
+    }
+
+public:
+
+    /** pop right: return the first split from the right. Use
+     * gpop_left() to get the reciprocal part.
+     */
+    basic_substring pop_right(C sep=C('/'), bool skip_empty=false) const
+    {
+        if(C4_LIKELY(len > 1))
+        {
+            auto pos = last_of(sep);
+            if(pos != npos)
+            {
+                if(pos + 1 < len) // does not end with sep
+                {
+                    return sub(pos + 1); // return from sep to end
+                }
+                else // the string ends with sep
+                {
+                    if( ! skip_empty)
+                    {
+                        return sub(pos + 1, 0);
+                    }
+                    auto ppos = last_not_of(sep); // skip repeated seps
+                    if(ppos == npos) // the string is all made of seps
+                    {
+                        return sub(0, 0);
+                    }
+                    // find the previous sep
+                    auto pos0 = last_of(sep, ppos);
+                    if(pos0 == npos) // only the last sep exists
+                    {
+                        return sub(0); // return the full string (because skip_empty is true)
+                    }
+                    ++pos0;
+                    return sub(pos0);
+                }
+            }
+            else // no sep was found, return the full string
+            {
+                return *this;
+            }
+        }
+        else if(len == 1)
+        {
+            if(begins_with(sep))
+            {
+                return sub(0, 0);
+            }
+            return *this;
+        }
+        else // an empty string
+        {
+            return basic_substring();
+        }
+    }
+
+    /** return the first split from the left. Use gpop_right() to get
+     * the reciprocal part. */
+    basic_substring pop_left(C sep = C('/'), bool skip_empty=false) const
+    {
+        if(C4_LIKELY(len > 1))
+        {
+            auto pos = first_of(sep);
+            if(pos != npos)
+            {
+                if(pos > 0)  // does not start with sep
+                {
+                    return sub(0, pos); //  return everything up to it
+                }
+                else  // the string starts with sep
+                {
+                    if( ! skip_empty)
+                    {
+                        return sub(0, 0);
+                    }
+                    auto ppos = first_not_of(sep); // skip repeated seps
+                    if(ppos == npos) // the string is all made of seps
+                    {
+                        return sub(0, 0);
+                    }
+                    // find the next sep
+                    auto pos0 = first_of(sep, ppos);
+                    if(pos0 == npos) // only the first sep exists
+                    {
+                        return sub(0); // return the full string (because skip_empty is true)
+                    }
+                    C4_XASSERT(pos0 > 0);
+                    // return everything up to the second sep
+                    return sub(0, pos0);
+                }
+            }
+            else // no sep was found, return the full string
+            {
+                return sub(0);
+            }
+        }
+        else if(len == 1)
+        {
+            if(begins_with(sep))
+            {
+                return sub(0, 0);
+            }
+            return sub(0);
+        }
+        else // an empty string
+        {
+            return basic_substring();
+        }
+    }
+
+public:
+
+    /** greedy pop left. eg, csubstr("a/b/c").gpop_left('/')="c" */
+    basic_substring gpop_left(C sep = C('/'), bool skip_empty=false) const
+    {
+        auto ss = pop_right(sep, skip_empty);
+        ss = left_of(ss);
+        if(ss.find(sep) != npos)
+        {
+            if(ss.ends_with(sep))
+            {
+                if(skip_empty)
+                {
+                    ss = ss.trimr(sep);
+                }
+                else
+                {
+                    ss = ss.sub(0, ss.len-1); // safe to subtract because ends_with(sep) is true
+                }
+            }
+        }
+        return ss;
+    }
+
+    /** greedy pop right. eg, csubstr("a/b/c").gpop_right('/')="a" */
+    basic_substring gpop_right(C sep = C('/'), bool skip_empty=false) const
+    {
+        auto ss = pop_left(sep, skip_empty);
+        ss = right_of(ss);
+        if(ss.find(sep) != npos)
+        {
+            if(ss.begins_with(sep))
+            {
+                if(skip_empty)
+                {
+                    ss = ss.triml(sep);
+                }
+                else
+                {
+                    ss = ss.sub(1);
+                }
+            }
+        }
+        return ss;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Path-like manipulation methods */
+    /** @{ */
+
+    basic_substring basename(C sep=C('/')) const
+    {
+        auto ss = pop_right(sep, /*skip_empty*/true);
+        ss = ss.trimr(sep);
+        return ss;
+    }
+
+    basic_substring dirname(C sep=C('/')) const
+    {
+        auto ss = basename(sep);
+        ss = ss.empty() ? *this : left_of(ss);
+        return ss;
+    }
+
+    C4_ALWAYS_INLINE basic_substring name_wo_extshort() const
+    {
+        return gpop_left('.');
+    }
+
+    C4_ALWAYS_INLINE basic_substring name_wo_extlong() const
+    {
+        return pop_left('.');
+    }
+
+    C4_ALWAYS_INLINE basic_substring extshort() const
+    {
+        return pop_right('.');
+    }
+
+    C4_ALWAYS_INLINE basic_substring extlong() const
+    {
+        return gpop_right('.');
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Content-modification methods (only for non-const C) */
+    /** @{ */
+
+    /** convert the string to upper-case
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) toupper()
+    {
+        for(size_t i = 0; i < len; ++i)
+        {
+            str[i] = static_cast<C>(::toupper(str[i]));
+        }
+    }
+
+    /** convert the string to lower-case
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) tolower()
+    {
+        for(size_t i = 0; i < len; ++i)
+        {
+            str[i] = static_cast<C>(::tolower(str[i]));
+        }
+    }
+
+public:
+
+    /** fill the entire contents with the given @p val
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) fill(C val)
+    {
+        for(size_t i = 0; i < len; ++i)
+        {
+            str[i] = val;
+        }
+    }
+
+public:
+
+    /** set the current substring to a copy of the given csubstr
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) copy_from(ro_substr that, size_t ifirst=0, size_t num=npos)
+    {
+        C4_ASSERT(ifirst >= 0 && ifirst <= len);
+        num = num != npos ? num : len - ifirst;
+        num = num < that.len ? num : that.len;
+        C4_ASSERT(ifirst + num >= 0 && ifirst + num <= len);
+        memcpy(str + sizeof(C) * ifirst, that.str, sizeof(C) * num);
+    }
+
+public:
+
+    /** reverse in place
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) reverse()
+    {
+        if(len == 0) return;
+        detail::_do_reverse(str, str + len - 1);
+    }
+
+    /** revert a subpart in place
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) reverse_sub(size_t ifirst, size_t num)
+    {
+        C4_ASSERT(ifirst >= 0 && ifirst <= len);
+        C4_ASSERT(ifirst + num >= 0 && ifirst + num <= len);
+        if(num == 0) return;
+        detail::_do_reverse(str + ifirst, str + ifirst + num - 1);
+    }
+
+    /** revert a range in place
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(void) reverse_range(size_t ifirst, size_t ilast)
+    {
+        C4_ASSERT(ifirst >= 0 && ifirst <= len);
+        C4_ASSERT(ilast  >= 0 && ilast  <= len);
+        if(ifirst == ilast) return;
+        detail::_do_reverse(str + ifirst, str + ilast - 1);
+    }
+
+public:
+
+    /** erase part of the string. eg, with char s[] = "0123456789",
+     * substr(s).erase(3, 2) = "01256789", and s is now "01245678989"
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(basic_substring) erase(size_t pos, size_t num)
+    {
+        C4_ASSERT(pos >= 0 && pos+num <= len);
+        size_t num_to_move = len - pos - num;
+        memmove(str + pos, str + pos + num, sizeof(C) * num_to_move);
+        return basic_substring{str, len - num};
+    }
+
+    /** @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(basic_substring) erase_range(size_t first, size_t last)
+    {
+        C4_ASSERT(first <= last);
+        return erase(first, static_cast<size_t>(last-first));
+    }
+
+    /** erase a part of the string.
+     * @note @p sub must be a substring of this string
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(basic_substring) erase(ro_substr sub)
+    {
+        C4_ASSERT(is_super(sub));
+        C4_ASSERT(sub.str >= str);
+        return erase(static_cast<size_t>(sub.str - str), sub.len);
+    }
+
+public:
+
+    /** replace every occurrence of character @p value with the character @p repl
+     * @return the number of characters that were replaced
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(size_t) replace(C value, C repl, size_t pos=0)
+    {
+        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
+        size_t did_it = 0;
+        while((pos = find(value, pos)) != npos)
+        {
+            str[pos++] = repl;
+            ++did_it;
+        }
+        return did_it;
+    }
+
+    /** replace every occurrence of each character in @p value with
+     * the character @p repl.
+     * @return the number of characters that were replaced
+     * @note this method requires that the string memory is writeable and is SFINAEd out for const C */
+    C4_REQUIRE_RW(size_t) replace(ro_substr chars, C repl, size_t pos=0)
+    {
+        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
+        size_t did_it = 0;
+        while((pos = first_of(chars, pos)) != npos)
+        {
+            str[pos++] = repl;
+            ++did_it;
+        }
+        return did_it;
+    }
+
+    /** replace @p pattern with @p repl, and write the result into
+     * @dst. pattern and repl don't need equal sizes.
+     *
+     * @return the required size for dst. No overflow occurs if
+     * dst.len is smaller than the required size; this can be used to
+     * determine the required size for an existing container. */
+    size_t replace_all(rw_substr dst, ro_substr pattern, ro_substr repl, size_t pos=0) const
+    {
+        C4_ASSERT( ! pattern.empty()); //!< @todo relax this precondition
+        C4_ASSERT( ! this  ->overlaps(dst)); //!< @todo relax this precondition
+        C4_ASSERT( ! pattern.overlaps(dst));
+        C4_ASSERT( ! repl   .overlaps(dst));
+        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
+        C4_SUPPRESS_WARNING_GCC_PUSH
+        C4_SUPPRESS_WARNING_GCC("-Warray-bounds")  // gcc11 has a false positive here
+        #if (!defined(__clang__)) && (defined(__GNUC__) && (__GNUC__ >= 7))
+        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc11 has a false positive here
+        #endif
+        #define _c4append(first, last)                                  \
+            {                                                           \
+                C4_ASSERT((last) >= (first));                           \
+                size_t num = static_cast<size_t>((last) - (first));     \
+                if(sz + num <= dst.len)                                 \
+                {                                                       \
+                    memcpy(dst.str + sz, first, num * sizeof(C));       \
+                }                                                       \
+                sz += num;                                              \
+            }
+        size_t sz = 0;
+        size_t b = pos;
+        _c4append(str, str + pos);
+        do {
+            size_t e = find(pattern, b);
+            if(e == npos)
+            {
+                _c4append(str + b, str + len);
+                break;
+            }
+            _c4append(str + b, str + e);
+            _c4append(repl.begin(), repl.end());
+            b = e + pattern.size();
+        } while(b < len && b != npos);
+        return sz;
+        #undef _c4append
+        C4_SUPPRESS_WARNING_GCC_POP
+    }
+
+    /** @} */
+
+}; // template class basic_substring
+
+
+#undef C4_REQUIRE_RW
+#undef C4_REQUIRE_RO
+#undef C4_NC2C
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** Because of a C++ limitation, substr cannot provide simultaneous
+ * overloads for constructing from a char[N] and a char*; the latter
+ * will always be chosen by the compiler. So this specialization is
+ * provided to simplify obtaining a substr from a char*. Being a
+ * function has the advantage of highlighting the strlen() cost.
+ *
+ * @see to_csubstr
+ * @see For a more detailed explanation on why the overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+inline substr to_substr(char *s)
+{
+    return substr(s, s ? strlen(s) : 0);
+}
+
+/** Because of a C++ limitation, substr cannot provide simultaneous
+ * overloads for constructing from a char[N] and a char*; the latter
+ * will always be chosen by the compiler. So this specialization is
+ * provided to simplify obtaining a substr from a char*. Being a
+ * function has the advantage of highlighting the strlen() cost.
+ *
+ * @see to_substr
+ * @see For a more detailed explanation on why the overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+inline csubstr to_csubstr(char *s)
+{
+    return csubstr(s, s ? strlen(s) : 0);
+}
+
+/** Because of a C++ limitation, substr cannot provide simultaneous
+ * overloads for constructing from a const char[N] and a const char*;
+ * the latter will always be chosen by the compiler. So this
+ * specialization is provided to simplify obtaining a substr from a
+ * char*. Being a function has the advantage of highlighting the
+ * strlen() cost.
+ *
+ * @overload to_csubstr
+ * @see to_substr
+ * @see For a more detailed explanation on why the overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+inline csubstr to_csubstr(const char *s)
+{
+    return csubstr(s, s ? strlen(s) : 0);
+}
+
+
+/** neutral version for use in generic code */
+inline csubstr to_csubstr(csubstr s)
+{
+    return s;
+}
+
+/** neutral version for use in generic code */
+inline csubstr to_csubstr(substr s)
+{
+    return s;
+}
+
+/** neutral version for use in generic code */
+inline substr to_substr(substr s)
+{
+    return s;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<typename C, size_t N> inline bool operator== (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) == 0; }
+template<typename C, size_t N> inline bool operator!= (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) != 0; }
+template<typename C, size_t N> inline bool operator<  (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) >  0; }
+template<typename C, size_t N> inline bool operator>  (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) <  0; }
+template<typename C, size_t N> inline bool operator<= (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) >= 0; }
+template<typename C, size_t N> inline bool operator>= (const C (&s)[N], basic_substring<C> const that) { return that.compare(s) <= 0; }
+
+template<typename C> inline bool operator== (C const c, basic_substring<C> const that) { return that.compare(c) == 0; }
+template<typename C> inline bool operator!= (C const c, basic_substring<C> const that) { return that.compare(c) != 0; }
+template<typename C> inline bool operator<  (C const c, basic_substring<C> const that) { return that.compare(c) >  0; }
+template<typename C> inline bool operator>  (C const c, basic_substring<C> const that) { return that.compare(c) <  0; }
+template<typename C> inline bool operator<= (C const c, basic_substring<C> const that) { return that.compare(c) >= 0; }
+template<typename C> inline bool operator>= (C const c, basic_substring<C> const that) { return that.compare(c) <= 0; }
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @define C4_SUBSTR_NO_OSTREAM_LSHIFT doctest does not deal well with
+ * template operator<<
+ * @see https://github.com/onqtam/doctest/pull/431 */
+#ifndef C4_SUBSTR_NO_OSTREAM_LSHIFT
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+/** output the string to a stream */
+template<class OStream, class C>
+inline OStream& operator<< (OStream& os, basic_substring<C> s)
+{
+    os.write(s.str, s.len);
+    return os;
+}
+
+// this causes ambiguity
+///** this is used by google test */
+//template<class OStream, class C>
+//inline void PrintTo(basic_substring<C> s, OStream* os)
+//{
+//    os->write(s.str, s.len);
+//}
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+#endif // !C4_SUBSTR_NO_OSTREAM_LSHIFT
+
+} // namespace c4
+
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* _C4_SUBSTR_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/substr.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/ext/fast_float.hpp
+// https://github.com/biojppm/c4core/src/c4/ext/fast_float.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_EXT_FAST_FLOAT_HPP_
+#define _C4_EXT_FAST_FLOAT_HPP_
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   pragma warning(disable: 4996) // snprintf/scanf: this function or variable may be unsafe
+#elif defined(__clang__) || defined(__APPLE_CC__) || defined(_LIBCPP_VERSION)
+#   pragma clang diagnostic push
+#   if (defined(__clang_major__) && _clang_major__ >= 9) || defined(__APPLE_CC__)
+#       pragma clang diagnostic ignored "-Wfortify-source"
+#   endif
+#   pragma clang diagnostic ignored "-Wshift-count-overflow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+
+// fast_float by Daniel Lemire
+// fast_float by João Paulo Magalhaes
+//
+// with contributions from Eugene Golushkov
+// with contributions from Maksim Kita
+// with contributions from Marcin Wojdyr
+// with contributions from Neal Richardson
+// with contributions from Tim Paine
+// with contributions from Fabio Pellacini
+//
+// MIT License Notice
+//
+//    MIT License
+//    
+//    Copyright (c) 2021 The fast_float authors
+//    
+//    Permission is hereby granted, free of charge, to any
+//    person obtaining a copy of this software and associated
+//    documentation files (the "Software"), to deal in the
+//    Software without restriction, including without
+//    limitation the rights to use, copy, modify, merge,
+//    publish, distribute, sublicense, and/or sell copies of
+//    the Software, and to permit persons to whom the Software
+//    is furnished to do so, subject to the following
+//    conditions:
+//    
+//    The above copyright notice and this permission notice
+//    shall be included in all copies or substantial portions
+//    of the Software.
+//    
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+//    ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//    TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+//    SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+//    DEALINGS IN THE SOFTWARE.
+//
+
+#ifndef FASTFLOAT_FAST_FLOAT_H
+#define FASTFLOAT_FAST_FLOAT_H
+
+#include <system_error>
+
+namespace fast_float {
+enum chars_format {
+    scientific = 1<<0,
+    fixed = 1<<2,
+    hex = 1<<3,
+    general = fixed | scientific
+};
+
+
+struct from_chars_result {
+  const char *ptr;
+  std::errc ec;
+};
+
+struct parse_options {
+  constexpr explicit parse_options(chars_format fmt = chars_format::general,
+                         char dot = '.')
+    : format(fmt), decimal_point(dot) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  char decimal_point;
+};
+
+/**
+ * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
+ * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
+ * The resulting floating-point value is the closest floating-point values (using either float or double),
+ * using the "round to even" convention for values that would otherwise fall right in-between two values.
+ * That is, we provide exact parsing according to the IEEE standard.
+ *
+ * Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
+ * parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
+ * `ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
+ *
+ * The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
+ *
+ * Like the C++17 standard, the `fast_float::from_chars` functions take an optional last argument of
+ * the type `fast_float::chars_format`. It is a bitset value: we check whether
+ * `fmt & fast_float::chars_format::fixed` and `fmt & fast_float::chars_format::scientific` are set
+ * to determine whether we allowe the fixed point and scientific notation respectively.
+ * The default is  `fast_float::chars_format::general` which allows both `fixed` and `scientific`.
+ */
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+                             T &value, chars_format fmt = chars_format::general)  noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept;
+
+}
+#endif // FASTFLOAT_FAST_FLOAT_H
+
+#ifndef FASTFLOAT_FLOAT_COMMON_H
+#define FASTFLOAT_FLOAT_COMMON_H
+
+#include <cfloat>
+//included above:
+//#include <cstdint>
+#include <cassert>
+//included above:
+//#include <cstring>
+//included above:
+//#include <type_traits>
+
+#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
+       || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
+       || defined(__MINGW64__)                                          \
+       || defined(__s390x__)                                            \
+       || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) \
+       || defined(__EMSCRIPTEN__))
+#define FASTFLOAT_64BIT
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
+     || defined(__arm__) || defined(_M_ARM)                   \
+     || defined(__MINGW32__))
+#define FASTFLOAT_32BIT
+#else
+  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+  // We can never tell the register width, but the SIZE_MAX is a good approximation.
+  // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
+  #if SIZE_MAX == 0xffff
+    #error Unknown platform (16-bit, unsupported)
+  #elif SIZE_MAX == 0xffffffff
+    #define FASTFLOAT_32BIT
+  #elif SIZE_MAX == 0xffffffffffffffff
+    #define FASTFLOAT_64BIT
+  #else
+    #error Unknown platform (not 32-bit, not 64-bit?)
+  #endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define FASTFLOAT_VISUAL_STUDIO 1
+#endif
+
+#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#elif defined _WIN32
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#elif defined(sun) || defined(__sun)
+#include <sys/byteorder.h>
+#else
+#include <endian.h>
+#endif
+#
+#ifndef __BYTE_ORDER__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#ifndef __ORDER_LITTLE_ENDIAN__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#define FASTFLOAT_IS_BIG_ENDIAN 1
+#endif
+#endif
+
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#define fastfloat_really_inline __forceinline
+#else
+#define fastfloat_really_inline inline __attribute__((always_inline))
+#endif
+
+#ifndef FASTFLOAT_ASSERT
+#define FASTFLOAT_ASSERT(x)  { if (!(x)) abort(); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+//included above:
+//#include <cassert>
+#define FASTFLOAT_DEBUG_ASSERT(x) assert(x)
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x) { if (!(x)) return false; }
+
+namespace fast_float {
+
+// Compares two ASCII strings in a case insensitive manner.
+inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
+                                  size_t length) {
+  char running_diff{0};
+  for (size_t i = 0; i < length; i++) {
+    running_diff |= (input1[i] ^ input2[i]);
+  }
+  return (running_diff == 0) || (running_diff == 32);
+}
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD should be defined, please include cfloat."
+#endif
+
+// a pointer and a length to a contiguous block of memory
+template <typename T>
+struct span {
+  const T* ptr;
+  size_t length;
+  span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
+  span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+
+  const T& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
+
+struct value128 {
+  uint64_t low;
+  uint64_t high;
+  value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+  value128() : low(0), high(0) {}
+};
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
+  assert(input_num > 0);
+#ifdef FASTFLOAT_VISUAL_STUDIO
+  #if defined(_M_X64) || defined(_M_ARM64)
+  unsigned long leading_zero = 0;
+  // Search the mask data from most significant bit (MSB)
+  // to least significant bit (LSB) for a set bit (1).
+  _BitScanReverse64(&leading_zero, input_num);
+  return (int)(63 - leading_zero);
+  #else
+  int last_bit = 0;
+  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
+  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
+  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
+  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
+  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
+  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
+  return 63 - last_bit;
+  #endif
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
+    return x * (uint64_t)y;
+}
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
+                                          uint64_t *hi) {
+  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+  uint64_t adbc_carry = !!(adbc < ad);
+  uint64_t lo = bd + (adbc << 32);
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+        (adbc_carry << 32) + !!(lo < bd);
+  return lo;
+}
+#endif // !__MINGW64__
+
+#endif // FASTFLOAT_32BIT
+
+
+// compute 64-bit a*b
+fastfloat_really_inline value128 full_multiplication(uint64_t a,
+                                                     uint64_t b) {
+  value128 answer;
+#ifdef _M_ARM64
+  // ARM64 has native support for 64-bit multiplications, no need to emulate
+  answer.high = __umulh(a, b);
+  answer.low = a * b;
+#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
+  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(FASTFLOAT_64BIT)
+  __uint128_t r = ((__uint128_t)a) * b;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+#else
+  #error Not implemented
+#endif
+  return answer;
+}
+
+struct adjusted_mantissa {
+  uint64_t mantissa{0};
+  int32_t power2{0}; // a negative value indicates an invalid result
+  adjusted_mantissa() = default;
+  bool operator==(const adjusted_mantissa &o) const {
+    return mantissa == o.mantissa && power2 == o.power2;
+  }
+  bool operator!=(const adjusted_mantissa &o) const {
+    return mantissa != o.mantissa || power2 != o.power2;
+  }
+};
+
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
+
+constexpr static double powers_of_ten_double[] = {
+    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
+                                                1e6, 1e7, 1e8, 1e9, 1e10};
+
+template <typename T> struct binary_format {
+  using equiv_uint = typename std::conditional<sizeof(T) == 4, uint32_t, uint64_t>::type;
+
+  static inline constexpr int mantissa_explicit_bits();
+  static inline constexpr int minimum_exponent();
+  static inline constexpr int infinite_power();
+  static inline constexpr int sign_index();
+  static inline constexpr int min_exponent_fast_path();
+  static inline constexpr int max_exponent_fast_path();
+  static inline constexpr int max_exponent_round_to_even();
+  static inline constexpr int min_exponent_round_to_even();
+  static inline constexpr uint64_t max_mantissa_fast_path();
+  static inline constexpr int largest_power_of_ten();
+  static inline constexpr int smallest_power_of_ten();
+  static inline constexpr T exact_power_of_ten(int64_t power);
+  static inline constexpr size_t max_digits();
+  static inline constexpr equiv_uint exponent_mask();
+  static inline constexpr equiv_uint mantissa_mask();
+  static inline constexpr equiv_uint hidden_bit_mask();
+};
+
+template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
+  return 52;
+}
+template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
+  return 23;
+}
+
+template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
+  return 23;
+}
+
+template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
+  return 10;
+}
+
+template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
+  return -4;
+}
+
+template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
+  return -17;
+}
+
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
+  return -1023;
+}
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
+  return -127;
+}
+
+template <> inline constexpr int binary_format<double>::infinite_power() {
+  return 0x7FF;
+}
+template <> inline constexpr int binary_format<float>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
+template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
+
+template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -22;
+#endif
+}
+template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return 0;
+#else
+  return -10;
+#endif
+}
+
+template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
+  return 22;
+}
+template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
+  return 10;
+}
+
+template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
+  return powers_of_ten_double[power];
+}
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+
+  return powers_of_ten_float[power];
+}
+
+
+template <>
+inline constexpr int binary_format<double>::largest_power_of_ten() {
+  return 308;
+}
+template <>
+inline constexpr int binary_format<float>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
+  return -342;
+}
+template <>
+inline constexpr int binary_format<float>::smallest_power_of_ten() {
+  return -65;
+}
+
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+  return 769;
+}
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+  return 114;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::exponent_mask() {
+  return 0x7F800000;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::exponent_mask() {
+  return 0x7FF0000000000000;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::mantissa_mask() {
+  return 0x007FFFFF;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::mantissa_mask() {
+  return 0x000FFFFFFFFFFFFF;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::hidden_bit_mask() {
+  return 0x00800000;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::hidden_bit_mask() {
+  return 0x0010000000000000;
+}
+
+template<typename T>
+fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
+  uint64_t word = am.mantissa;
+  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
+  word = negative
+  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+   if (std::is_same<T, float>::value) {
+     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
+   } else {
+     ::memcpy(&value, &word, sizeof(T));
+   }
+#else
+   // For little-endian systems:
+   ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+//included above:
+//#include <cctype>
+//included above:
+//#include <cstdint>
+//included above:
+//#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56
+    | (val & 0x00FF000000000000) >> 40
+    | (val & 0x0000FF0000000000) >> 24
+    | (val & 0x000000FF00000000) >> 8
+    | (val & 0x00000000FF000000) << 8
+    | (val & 0x0000000000FF0000) << 24
+    | (val & 0x000000000000FF00) << 40
+    | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit  @aqrit
+fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
+  const uint64_t mask = 0x000000FF000000FF;
+  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
+  return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+     0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
+  return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  const char *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  byte_span integer{};  // non-nullable
+  byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
+  parsed_number_string answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  answer.negative = (*p == '-');
+  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+    ++p;
+    if (p == pend) {
+      return answer;
+    }
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+      return answer;
+    }
+  }
+  const char *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  const char *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = byte_span(start_digits, size_t(digit_count));
+  int64_t exponent = 0;
+  if ((p != pend) && (*p == decimal_point)) {
+    ++p;
+    const char* before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+      p += 8;
+    }
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - '0');
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = byte_span(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  // we must have encountered at least one integer!
+  if (digit_count == 0) {
+    return answer;
+  }
+  int64_t exp_number = 0;            // explicit exponential part
+  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+    const char * location_of_e = p;
+    ++p;
+    bool neg_exp = false;
+    if ((p != pend) && ('-' == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if(!(fmt & chars_format::fixed)) {
+        // We are in error.
+        return answer;
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - '0');
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if(neg_exp) { exp_number = - exp_number; }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    const char *start = start_digits;
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+      if(*start == '0') { digit_count --; }
+      start++;
+    }
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      const char* int_end = p + answer.integer.len();
+      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - '0');
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+          p = answer.fraction.ptr;
+          const char* frac_end = p + answer.fraction.len();
+          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+            i = i * 10 + uint64_t(*p - '0');
+            ++p;
+          }
+          exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_FAST_TABLE_H
+#define FASTFLOAT_FAST_TABLE_H
+
+//included above:
+//#include <cstdint>
+
+namespace fast_float {
+
+/**
+ * When mapping numbers from decimal to binary,
+ * we go from w * 10^q to m * 2^p but we have
+ * 10^q = 5^q * 2^q, so effectively
+ * we are trying to match
+ * w * 2^q * 5^q to m * 2^p. Thus the powers of two
+ * are not a concern since they can be represented
+ * exactly using the binary notation, only the powers of five
+ * affect the binary significand.
+ */
+
+/**
+ * The smallest non-zero float (binary64) is 2^−1074.
+ * We take as input numbers of the form w x 10^q where w < 2^64.
+ * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
+ * However, we have that
+ * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^−1074.
+ * Thus it is possible for a number of the form w * 10^-342 where
+ * w is a 64-bit value to be a non-zero floating-point number.
+ *********
+ * Any number of form w * 10^309 where w>= 1 is going to be
+ * infinite in binary64 so we never need to worry about powers
+ * of 5 greater than 308.
+ */
+template <class unused = void>
+struct powers_template {
+
+constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
+constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
+constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
+// Powers of five from 5^-342 all the way to 5^308 rounded toward one.
+static const uint64_t power_of_five_128[number_of_entries];
+};
+
+template <class unused>
+const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
+        0xeef453d6923bd65a,0x113faa2906a13b3f,
+        0x9558b4661b6565f8,0x4ac7ca59a424c507,
+        0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
+        0xe95a99df8ace6f53,0xf4d82c2c107973dc,
+        0x91d8a02bb6c10594,0x79071b9b8a4be869,
+        0xb64ec836a47146f9,0x9748e2826cdee284,
+        0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
+        0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
+        0xb208ef855c969f4f,0xbdbd2d335e51a935,
+        0xde8b2b66b3bc4723,0xad2c788035e61382,
+        0x8b16fb203055ac76,0x4c3bcb5021afcc31,
+        0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
+        0xd953e8624b85dd78,0xd71d6dad34a2af0d,
+        0x87d4713d6f33aa6b,0x8672648c40e5ad68,
+        0xa9c98d8ccb009506,0x680efdaf511f18c2,
+        0xd43bf0effdc0ba48,0x212bd1b2566def2,
+        0x84a57695fe98746d,0x14bb630f7604b57,
+        0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
+        0xcf42894a5dce35ea,0x52064cac828675b9,
+        0x818995ce7aa0e1b2,0x7343efebd1940993,
+        0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
+        0xca66fa129f9b60a6,0xd41a26e077774ef6,
+        0xfd00b897478238d0,0x8920b098955522b4,
+        0x9e20735e8cb16382,0x55b46e5f5d5535b0,
+        0xc5a890362fddbc62,0xeb2189f734aa831d,
+        0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
+        0x9a6bb0aa55653b2d,0x47b233c92125366e,
+        0xc1069cd4eabe89f8,0x999ec0bb696e840a,
+        0xf148440a256e2c76,0xc00670ea43ca250d,
+        0x96cd2a865764dbca,0x380406926a5e5728,
+        0xbc807527ed3e12bc,0xc605083704f5ecf2,
+        0xeba09271e88d976b,0xf7864a44c633682e,
+        0x93445b8731587ea3,0x7ab3ee6afbe0211d,
+        0xb8157268fdae9e4c,0x5960ea05bad82964,
+        0xe61acf033d1a45df,0x6fb92487298e33bd,
+        0x8fd0c16206306bab,0xa5d3b6d479f8e056,
+        0xb3c4f1ba87bc8696,0x8f48a4899877186c,
+        0xe0b62e2929aba83c,0x331acdabfe94de87,
+        0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
+        0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
+        0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
+        0x892731ac9faf056e,0xbe311c083a225cd2,
+        0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
+        0xd64d3d9db981787d,0x92cbbccdad5b108,
+        0x85f0468293f0eb4e,0x25bbf56008c58ea5,
+        0xa76c582338ed2621,0xaf2af2b80af6f24e,
+        0xd1476e2c07286faa,0x1af5af660db4aee1,
+        0x82cca4db847945ca,0x50d98d9fc890ed4d,
+        0xa37fce126597973c,0xe50ff107bab528a0,
+        0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
+        0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
+        0x9faacf3df73609b1,0x77b191618c54e9ac,
+        0xc795830d75038c1d,0xd59df5b9ef6a2417,
+        0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
+        0x9becce62836ac577,0x4ee367f9430aec32,
+        0xc2e801fb244576d5,0x229c41f793cda73f,
+        0xf3a20279ed56d48a,0x6b43527578c1110f,
+        0x9845418c345644d6,0x830a13896b78aaa9,
+        0xbe5691ef416bd60c,0x23cc986bc656d553,
+        0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
+        0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
+        0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
+        0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
+        0x91376c36d99995be,0x23100809b9c21fa1,
+        0xb58547448ffffb2d,0xabd40a0c2832a78a,
+        0xe2e69915b3fff9f9,0x16c90c8f323f516c,
+        0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
+        0xb1442798f49ffb4a,0x99cd11cfdf41779c,
+        0xdd95317f31c7fa1d,0x40405643d711d583,
+        0x8a7d3eef7f1cfc52,0x482835ea666b2572,
+        0xad1c8eab5ee43b66,0xda3243650005eecf,
+        0xd863b256369d4a40,0x90bed43e40076a82,
+        0x873e4f75e2224e68,0x5a7744a6e804a291,
+        0xa90de3535aaae202,0x711515d0a205cb36,
+        0xd3515c2831559a83,0xd5a5b44ca873e03,
+        0x8412d9991ed58091,0xe858790afe9486c2,
+        0xa5178fff668ae0b6,0x626e974dbe39a872,
+        0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
+        0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
+        0xa139029f6a239f72,0x1c1fffc1ebc44e80,
+        0xc987434744ac874e,0xa327ffb266b56220,
+        0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
+        0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
+        0xc4ce17b399107c22,0xcb550fb4384d21d3,
+        0xf6019da07f549b2b,0x7e2a53a146606a48,
+        0x99c102844f94e0fb,0x2eda7444cbfc426d,
+        0xc0314325637a1939,0xfa911155fefb5308,
+        0xf03d93eebc589f88,0x793555ab7eba27ca,
+        0x96267c7535b763b5,0x4bc1558b2f3458de,
+        0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
+        0xea9c227723ee8bcb,0x465e15a979c1cadc,
+        0x92a1958a7675175f,0xbfacd89ec191ec9,
+        0xb749faed14125d36,0xcef980ec671f667b,
+        0xe51c79a85916f484,0x82b7e12780e7401a,
+        0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
+        0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
+        0xdfbdcece67006ac9,0x67a791e093e1d49a,
+        0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
+        0xaecc49914078536d,0x58fae9f773886e18,
+        0xda7f5bf590966848,0xaf39a475506a899e,
+        0x888f99797a5e012d,0x6d8406c952429603,
+        0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
+        0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
+        0x855c3be0a17fcd26,0x5cf2eea09a55067f,
+        0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
+        0xd0601d8efc57b08b,0xf13b94daf124da26,
+        0x823c12795db6ce57,0x76c53d08d6b70858,
+        0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
+        0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
+        0xfe5d54150b090b02,0xd3f93b35435d7c4c,
+        0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
+        0xc6b8e9b0709f109a,0x359ab6419ca1091b,
+        0xf867241c8cc6d4c0,0xc30163d203c94b62,
+        0x9b407691d7fc44f8,0x79e0de63425dcf1d,
+        0xc21094364dfb5636,0x985915fc12f542e4,
+        0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
+        0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
+        0xbd8430bd08277231,0x50c6ff782a838353,
+        0xece53cec4a314ebd,0xa4f8bf5635246428,
+        0x940f4613ae5ed136,0x871b7795e136be99,
+        0xb913179899f68584,0x28e2557b59846e3f,
+        0xe757dd7ec07426e5,0x331aeada2fe589cf,
+        0x9096ea6f3848984f,0x3ff0d2c85def7621,
+        0xb4bca50b065abe63,0xfed077a756b53a9,
+        0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
+        0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
+        0xb080392cc4349dec,0xbd8d794d96aacfb3,
+        0xdca04777f541c567,0xecf0d7a0fc5583a0,
+        0x89e42caaf9491b60,0xf41686c49db57244,
+        0xac5d37d5b79b6239,0x311c2875c522ced5,
+        0xd77485cb25823ac7,0x7d633293366b828b,
+        0x86a8d39ef77164bc,0xae5dff9c02033197,
+        0xa8530886b54dbdeb,0xd9f57f830283fdfc,
+        0xd267caa862a12d66,0xd072df63c324fd7b,
+        0x8380dea93da4bc60,0x4247cb9e59f71e6d,
+        0xa46116538d0deb78,0x52d9be85f074e608,
+        0xcd795be870516656,0x67902e276c921f8b,
+        0x806bd9714632dff6,0xba1cd8a3db53b6,
+        0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
+        0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
+        0xfad2a4b13d1b5d6c,0x796b805720085f81,
+        0x9cc3a6eec6311a63,0xcbe3303674053bb0,
+        0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
+        0xf4f1b4d515acb93b,0xee92fb5515482d44,
+        0x991711052d8bf3c5,0x751bdd152d4d1c4a,
+        0xbf5cd54678eef0b6,0xd262d45a78a0635d,
+        0xef340a98172aace4,0x86fb897116c87c34,
+        0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
+        0xbae0a846d2195712,0x8974836059cca109,
+        0xe998d258869facd7,0x2bd1a438703fc94b,
+        0x91ff83775423cc06,0x7b6306a34627ddcf,
+        0xb67f6455292cbf08,0x1a3bc84c17b1d542,
+        0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
+        0x8e938662882af53e,0x547eb47b7282ee9c,
+        0xb23867fb2a35b28d,0xe99e619a4f23aa43,
+        0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
+        0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
+        0xae0b158b4738705e,0x9624ab50b148d445,
+        0xd98ddaee19068c76,0x3badd624dd9b0957,
+        0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
+        0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
+        0xd47487cc8470652b,0x7647c3200069671f,
+        0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
+        0xa5fb0a17c777cf09,0xf468107100525890,
+        0xcf79cc9db955c2cc,0x7182148d4066eeb4,
+        0x81ac1fe293d599bf,0xc6f14cd848405530,
+        0xa21727db38cb002f,0xb8ada00e5a506a7c,
+        0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
+        0xfd442e4688bd304a,0x908f4a166d1da663,
+        0x9e4a9cec15763e2e,0x9a598e4e043287fe,
+        0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
+        0xf7549530e188c128,0xd12bee59e68ef47c,
+        0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
+        0xc13a148e3032d6e7,0xe36a52363c1faf01,
+        0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
+        0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
+        0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
+        0xebdf661791d60f56,0x111b495b3464ad21,
+        0x936b9fcebb25c995,0xcab10dd900beec34,
+        0xb84687c269ef3bfb,0x3d5d514f40eea742,
+        0xe65829b3046b0afa,0xcb4a5a3112a5112,
+        0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
+        0xb3f4e093db73a093,0x59ed216765690f56,
+        0xe0f218b8d25088b8,0x306869c13ec3532c,
+        0x8c974f7383725573,0x1e414218c73a13fb,
+        0xafbd2350644eeacf,0xe5d1929ef90898fa,
+        0xdbac6c247d62a583,0xdf45f746b74abf39,
+        0x894bc396ce5da772,0x6b8bba8c328eb783,
+        0xab9eb47c81f5114f,0x66ea92f3f326564,
+        0xd686619ba27255a2,0xc80a537b0efefebd,
+        0x8613fd0145877585,0xbd06742ce95f5f36,
+        0xa798fc4196e952e7,0x2c48113823b73704,
+        0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
+        0x82ef85133de648c4,0x9a984d73dbe722fb,
+        0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
+        0xcc963fee10b7d1b3,0x318df905079926a8,
+        0xffbbcfe994e5c61f,0xfdf17746497f7052,
+        0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
+        0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
+        0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
+        0x9c1661a651213e2d,0x6bea10ca65c084e,
+        0xc31bfa0fe5698db8,0x486e494fcff30a62,
+        0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
+        0x986ddb5c6b3a76b7,0xf89629465a75e01c,
+        0xbe89523386091465,0xf6bbb397f1135823,
+        0xee2ba6c0678b597f,0x746aa07ded582e2c,
+        0x94db483840b717ef,0xa8c2a44eb4571cdc,
+        0xba121a4650e4ddeb,0x92f34d62616ce413,
+        0xe896a0d7e51e1566,0x77b020baf9c81d17,
+        0x915e2486ef32cd60,0xace1474dc1d122e,
+        0xb5b5ada8aaff80b8,0xd819992132456ba,
+        0xe3231912d5bf60e6,0x10e1fff697ed6c69,
+        0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
+        0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
+        0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
+        0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
+        0xad4ab7112eb3929d,0x86c16c98d2c953c6,
+        0xd89d64d57a607744,0xe871c7bf077ba8b7,
+        0x87625f056c7c4a8b,0x11471cd764ad4972,
+        0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
+        0xd389b47879823479,0x4aff1d108d4ec2c3,
+        0x843610cb4bf160cb,0xcedf722a585139ba,
+        0xa54394fe1eedb8fe,0xc2974eb4ee658828,
+        0xce947a3da6a9273e,0x733d226229feea32,
+        0x811ccc668829b887,0x806357d5a3f525f,
+        0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
+        0xc9bcff6034c13052,0xfc89b393dd02f0b5,
+        0xfc2c3f3841f17c67,0xbbac2078d443ace2,
+        0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
+        0xc5029163f384a931,0xa9e795e65d4df11,
+        0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
+        0x99ea0196163fa42e,0x504bced1bf8e4e45,
+        0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
+        0xf07da27a82c37088,0x5d767327bb4e5a4c,
+        0x964e858c91ba2655,0x3a6a07f8d510f86f,
+        0xbbe226efb628afea,0x890489f70a55368b,
+        0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
+        0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
+        0xb77ada0617e3bbcb,0x9ce6ebb40173744,
+        0xe55990879ddcaabd,0xcc420a6a101d0515,
+        0x8f57fa54c2a9eab6,0x9fa946824a12232d,
+        0xb32df8e9f3546564,0x47939822dc96abf9,
+        0xdff9772470297ebd,0x59787e2b93bc56f7,
+        0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
+        0xaefae51477a06b03,0xede622920b6b23f1,
+        0xdab99e59958885c4,0xe95fab368e45eced,
+        0x88b402f7fd75539b,0x11dbcb0218ebb414,
+        0xaae103b5fcd2a881,0xd652bdc29f26a119,
+        0xd59944a37c0752a2,0x4be76d3346f0495f,
+        0x857fcae62d8493a5,0x6f70a4400c562ddb,
+        0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
+        0xd097ad07a71f26b2,0x7e2000a41346a7a7,
+        0x825ecc24c873782f,0x8ed400668c0c28c8,
+        0xa2f67f2dfa90563b,0x728900802f0f32fa,
+        0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
+        0xfea126b7d78186bc,0xe2f610c84987bfa8,
+        0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
+        0xc6ede63fa05d3143,0x91503d1c79720dbb,
+        0xf8a95fcf88747d94,0x75a44c6397ce912a,
+        0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
+        0xc24452da229b021b,0xfbe85badce996168,
+        0xf2d56790ab41c2a2,0xfae27299423fb9c3,
+        0x97c560ba6b0919a5,0xdccd879fc967d41a,
+        0xbdb6b8e905cb600f,0x5400e987bbc1c920,
+        0xed246723473e3813,0x290123e9aab23b68,
+        0x9436c0760c86e30b,0xf9a0b6720aaf6521,
+        0xb94470938fa89bce,0xf808e40e8d5b3e69,
+        0xe7958cb87392c2c2,0xb60b1d1230b20e04,
+        0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
+        0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
+        0xe2280b6c20dd5232,0x25c6da63c38de1b0,
+        0x8d590723948a535f,0x579c487e5a38ad0e,
+        0xb0af48ec79ace837,0x2d835a9df0c6d851,
+        0xdcdb1b2798182244,0xf8e431456cf88e65,
+        0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
+        0xac8b2d36eed2dac5,0xe272467e3d222f3f,
+        0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
+        0x86ccbb52ea94baea,0x98e947129fc2b4e9,
+        0xa87fea27a539e9a5,0x3f2398d747b36224,
+        0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
+        0x83a3eeeef9153e89,0x1953cf68300424ac,
+        0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
+        0xcdb02555653131b6,0x3792f412cb06794d,
+        0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
+        0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
+        0xc8de047564d20a8b,0xf245825a5a445275,
+        0xfb158592be068d2e,0xeed6e2f0f0d56712,
+        0x9ced737bb6c4183d,0x55464dd69685606b,
+        0xc428d05aa4751e4c,0xaa97e14c3c26b886,
+        0xf53304714d9265df,0xd53dd99f4b3066a8,
+        0x993fe2c6d07b7fab,0xe546a8038efe4029,
+        0xbf8fdb78849a5f96,0xde98520472bdd033,
+        0xef73d256a5c0f77c,0x963e66858f6d4440,
+        0x95a8637627989aad,0xdde7001379a44aa8,
+        0xbb127c53b17ec159,0x5560c018580d5d52,
+        0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
+        0x9226712162ab070d,0xcab3961304ca70e8,
+        0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
+        0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
+        0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
+        0xb267ed1940f1c61c,0x55f038b237591ed3,
+        0xdf01e85f912e37a3,0x6b6c46dec52f6688,
+        0x8b61313bbabce2c6,0x2323ac4b3b3da015,
+        0xae397d8aa96c1b77,0xabec975e0a0d081a,
+        0xd9c7dced53c72255,0x96e7bd358c904a21,
+        0x881cea14545c7575,0x7e50d64177da2e54,
+        0xaa242499697392d2,0xdde50bd1d5d0b9e9,
+        0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
+        0x84ec3c97da624ab4,0xbd5af13bef0b113e,
+        0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
+        0xcfb11ead453994ba,0x67de18eda5814af2,
+        0x81ceb32c4b43fcf4,0x80eacf948770ced7,
+        0xa2425ff75e14fc31,0xa1258379a94d028d,
+        0xcad2f7f5359a3b3e,0x96ee45813a04330,
+        0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
+        0x9e74d1b791e07e48,0x775ea264cf55347e,
+        0xc612062576589dda,0x95364afe032a819e,
+        0xf79687aed3eec551,0x3a83ddbd83f52205,
+        0x9abe14cd44753b52,0xc4926a9672793543,
+        0xc16d9a0095928a27,0x75b7053c0f178294,
+        0xf1c90080baf72cb1,0x5324c68b12dd6339,
+        0x971da05074da7bee,0xd3f6fc16ebca5e04,
+        0xbce5086492111aea,0x88f4bb1ca6bcf585,
+        0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
+        0x9392ee8e921d5d07,0x3aff322e62439fd0,
+        0xb877aa3236a4b449,0x9befeb9fad487c3,
+        0xe69594bec44de15b,0x4c2ebe687989a9b4,
+        0x901d7cf73ab0acd9,0xf9d37014bf60a11,
+        0xb424dc35095cd80f,0x538484c19ef38c95,
+        0xe12e13424bb40e13,0x2865a5f206b06fba,
+        0x8cbccc096f5088cb,0xf93f87b7442e45d4,
+        0xafebff0bcb24aafe,0xf78f69a51539d749,
+        0xdbe6fecebdedd5be,0xb573440e5a884d1c,
+        0x89705f4136b4a597,0x31680a88f8953031,
+        0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
+        0xd6bf94d5e57a42bc,0x3d32907604691b4d,
+        0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
+        0xa7c5ac471b478423,0xfcf80dc33721d54,
+        0xd1b71758e219652b,0xd3c36113404ea4a9,
+        0x83126e978d4fdf3b,0x645a1cac083126ea,
+        0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
+        0xcccccccccccccccc,0xcccccccccccccccd,
+        0x8000000000000000,0x0,
+        0xa000000000000000,0x0,
+        0xc800000000000000,0x0,
+        0xfa00000000000000,0x0,
+        0x9c40000000000000,0x0,
+        0xc350000000000000,0x0,
+        0xf424000000000000,0x0,
+        0x9896800000000000,0x0,
+        0xbebc200000000000,0x0,
+        0xee6b280000000000,0x0,
+        0x9502f90000000000,0x0,
+        0xba43b74000000000,0x0,
+        0xe8d4a51000000000,0x0,
+        0x9184e72a00000000,0x0,
+        0xb5e620f480000000,0x0,
+        0xe35fa931a0000000,0x0,
+        0x8e1bc9bf04000000,0x0,
+        0xb1a2bc2ec5000000,0x0,
+        0xde0b6b3a76400000,0x0,
+        0x8ac7230489e80000,0x0,
+        0xad78ebc5ac620000,0x0,
+        0xd8d726b7177a8000,0x0,
+        0x878678326eac9000,0x0,
+        0xa968163f0a57b400,0x0,
+        0xd3c21bcecceda100,0x0,
+        0x84595161401484a0,0x0,
+        0xa56fa5b99019a5c8,0x0,
+        0xcecb8f27f4200f3a,0x0,
+        0x813f3978f8940984,0x4000000000000000,
+        0xa18f07d736b90be5,0x5000000000000000,
+        0xc9f2c9cd04674ede,0xa400000000000000,
+        0xfc6f7c4045812296,0x4d00000000000000,
+        0x9dc5ada82b70b59d,0xf020000000000000,
+        0xc5371912364ce305,0x6c28000000000000,
+        0xf684df56c3e01bc6,0xc732000000000000,
+        0x9a130b963a6c115c,0x3c7f400000000000,
+        0xc097ce7bc90715b3,0x4b9f100000000000,
+        0xf0bdc21abb48db20,0x1e86d40000000000,
+        0x96769950b50d88f4,0x1314448000000000,
+        0xbc143fa4e250eb31,0x17d955a000000000,
+        0xeb194f8e1ae525fd,0x5dcfab0800000000,
+        0x92efd1b8d0cf37be,0x5aa1cae500000000,
+        0xb7abc627050305ad,0xf14a3d9e40000000,
+        0xe596b7b0c643c719,0x6d9ccd05d0000000,
+        0x8f7e32ce7bea5c6f,0xe4820023a2000000,
+        0xb35dbf821ae4f38b,0xdda2802c8a800000,
+        0xe0352f62a19e306e,0xd50b2037ad200000,
+        0x8c213d9da502de45,0x4526f422cc340000,
+        0xaf298d050e4395d6,0x9670b12b7f410000,
+        0xdaf3f04651d47b4c,0x3c0cdd765f114000,
+        0x88d8762bf324cd0f,0xa5880a69fb6ac800,
+        0xab0e93b6efee0053,0x8eea0d047a457a00,
+        0xd5d238a4abe98068,0x72a4904598d6d880,
+        0x85a36366eb71f041,0x47a6da2b7f864750,
+        0xa70c3c40a64e6c51,0x999090b65f67d924,
+        0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
+        0x82818f1281ed449f,0xbff8f10e7a8921a4,
+        0xa321f2d7226895c7,0xaff72d52192b6a0d,
+        0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
+        0xfee50b7025c36a08,0x2f236d04753d5b4,
+        0x9f4f2726179a2245,0x1d762422c946590,
+        0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
+        0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
+        0x9b934c3b330c8577,0x63cc55f49f88eb2f,
+        0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
+        0xf316271c7fc3908a,0x8bef464e3945ef7a,
+        0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
+        0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
+        0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
+        0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
+        0xb975d6b6ee39e436,0xb3e2fd538e122b44,
+        0xe7d34c64a9c85d44,0x60dbbca87196b616,
+        0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
+        0xb51d13aea4a488dd,0x6babab6398bdbe41,
+        0xe264589a4dcdab14,0xc696963c7eed2dd1,
+        0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
+        0xb0de65388cc8ada8,0x3b25a55f43294bcb,
+        0xdd15fe86affad912,0x49ef0eb713f39ebe,
+        0x8a2dbf142dfcc7ab,0x6e3569326c784337,
+        0xacb92ed9397bf996,0x49c2c37f07965404,
+        0xd7e77a8f87daf7fb,0xdc33745ec97be906,
+        0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
+        0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
+        0xd2d80db02aabd62b,0xf50a3fa490c30190,
+        0x83c7088e1aab65db,0x792667c6da79e0fa,
+        0xa4b8cab1a1563f52,0x577001b891185938,
+        0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
+        0x80b05e5ac60b6178,0x544f8158315b05b4,
+        0xa0dc75f1778e39d6,0x696361ae3db1c721,
+        0xc913936dd571c84c,0x3bc3a19cd1e38e9,
+        0xfb5878494ace3a5f,0x4ab48a04065c723,
+        0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
+        0xc45d1df942711d9a,0x3ba5d0bd324f8394,
+        0xf5746577930d6500,0xca8f44ec7ee36479,
+        0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
+        0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
+        0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
+        0x95d04aee3b80ece5,0xbba1f1d158724a12,
+        0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
+        0xea1575143cf97226,0xf52d09d71a3293bd,
+        0x924d692ca61be758,0x593c2626705f9c56,
+        0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
+        0xe498f455c38b997a,0xb6dfb9c0f956447,
+        0x8edf98b59a373fec,0x4724bd4189bd5eac,
+        0xb2977ee300c50fe7,0x58edec91ec2cb657,
+        0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
+        0x8b865b215899f46c,0xbd79e0d20082ee74,
+        0xae67f1e9aec07187,0xecd8590680a3aa11,
+        0xda01ee641a708de9,0xe80e6f4820cc9495,
+        0x884134fe908658b2,0x3109058d147fdcdd,
+        0xaa51823e34a7eede,0xbd4b46f0599fd415,
+        0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
+        0x850fadc09923329e,0x3e2cf6bc604ddb0,
+        0xa6539930bf6bff45,0x84db8346b786151c,
+        0xcfe87f7cef46ff16,0xe612641865679a63,
+        0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
+        0xa26da3999aef7749,0xe3be5e330f38f09d,
+        0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
+        0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
+        0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
+        0xc646d63501a1511d,0xb281e1fd541501b8,
+        0xf7d88bc24209a565,0x1f225a7ca91a4226,
+        0x9ae757596946075f,0x3375788de9b06958,
+        0xc1a12d2fc3978937,0x52d6b1641c83ae,
+        0xf209787bb47d6b84,0xc0678c5dbd23a49a,
+        0x9745eb4d50ce6332,0xf840b7ba963646e0,
+        0xbd176620a501fbff,0xb650e5a93bc3d898,
+        0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
+        0x93ba47c980e98cdf,0xc66f336c36b10137,
+        0xb8a8d9bbe123f017,0xb80b0047445d4184,
+        0xe6d3102ad96cec1d,0xa60dc059157491e5,
+        0x9043ea1ac7e41392,0x87c89837ad68db2f,
+        0xb454e4a179dd1877,0x29babe4598c311fb,
+        0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
+        0x8ce2529e2734bb1d,0x1899e4a65f58660c,
+        0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
+        0xdc21a1171d42645d,0x76707543f4fa1f73,
+        0x899504ae72497eba,0x6a06494a791c53a8,
+        0xabfa45da0edbde69,0x487db9d17636892,
+        0xd6f8d7509292d603,0x45a9d2845d3c42b6,
+        0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
+        0xa7f26836f282b732,0x8e6cac7768d7141e,
+        0xd1ef0244af2364ff,0x3207d795430cd926,
+        0x8335616aed761f1f,0x7f44e6bd49e807b8,
+        0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
+        0xcd036837130890a1,0x36dba887c37a8c0f,
+        0x802221226be55a64,0xc2494954da2c9789,
+        0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
+        0xc83553c5c8965d3d,0x6f92829494e5acc7,
+        0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
+        0x9c69a97284b578d7,0xff2a760414536efb,
+        0xc38413cf25e2d70d,0xfef5138519684aba,
+        0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
+        0x98bf2f79d5993802,0xef2f773ffbd97a61,
+        0xbeeefb584aff8603,0xaafb550ffacfd8fa,
+        0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
+        0x952ab45cfa97a0b2,0xdd945a747bf26183,
+        0xba756174393d88df,0x94f971119aeef9e4,
+        0xe912b9d1478ceb17,0x7a37cd5601aab85d,
+        0x91abb422ccb812ee,0xac62e055c10ab33a,
+        0xb616a12b7fe617aa,0x577b986b314d6009,
+        0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
+        0x8e41ade9fbebc27d,0x14588f13be847307,
+        0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
+        0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
+        0x8aec23d680043bee,0x25de7bb9480d5854,
+        0xada72ccc20054ae9,0xaf561aa79a10ae6a,
+        0xd910f7ff28069da4,0x1b2ba1518094da04,
+        0x87aa9aff79042286,0x90fb44d2f05d0842,
+        0xa99541bf57452b28,0x353a1607ac744a53,
+        0xd3fa922f2d1675f2,0x42889b8997915ce8,
+        0x847c9b5d7c2e09b7,0x69956135febada11,
+        0xa59bc234db398c25,0x43fab9837e699095,
+        0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
+        0x8161afb94b44f57d,0x1d1be0eebac278f5,
+        0xa1ba1ba79e1632dc,0x6462d92a69731732,
+        0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
+        0xfcb2cb35e702af78,0x5cda735244c3d43e,
+        0x9defbf01b061adab,0x3a0888136afa64a7,
+        0xc56baec21c7a1916,0x88aaa1845b8fdd0,
+        0xf6c69a72a3989f5b,0x8aad549e57273d45,
+        0x9a3c2087a63f6399,0x36ac54e2f678864b,
+        0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
+        0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
+        0x969eb7c47859e743,0x9f644ae5a4b1b325,
+        0xbc4665b596706114,0x873d5d9f0dde1fee,
+        0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
+        0x9316ff75dd87cbd8,0x9a7f12442d588f2,
+        0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
+        0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
+        0x8fa475791a569d10,0xf96e017d694487bc,
+        0xb38d92d760ec4455,0x37c981dcc395a9ac,
+        0xe070f78d3927556a,0x85bbe253f47b1417,
+        0x8c469ab843b89562,0x93956d7478ccec8e,
+        0xaf58416654a6babb,0x387ac8d1970027b2,
+        0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
+        0x88fcf317f22241e2,0x441fece3bdf81f03,
+        0xab3c2fddeeaad25a,0xd527e81cad7626c3,
+        0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
+        0x85c7056562757456,0xf6872d5667844e49,
+        0xa738c6bebb12d16c,0xb428f8ac016561db,
+        0xd106f86e69d785c7,0xe13336d701beba52,
+        0x82a45b450226b39c,0xecc0024661173473,
+        0xa34d721642b06084,0x27f002d7f95d0190,
+        0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
+        0xff290242c83396ce,0x7e67047175a15271,
+        0x9f79a169bd203e41,0xf0062c6e984d386,
+        0xc75809c42c684dd1,0x52c07b78a3e60868,
+        0xf92e0c3537826145,0xa7709a56ccdf8a82,
+        0x9bbcc7a142b17ccb,0x88a66076400bb691,
+        0xc2abf989935ddbfe,0x6acff893d00ea435,
+        0xf356f7ebf83552fe,0x583f6b8c4124d43,
+        0x98165af37b2153de,0xc3727a337a8b704a,
+        0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
+        0xeda2ee1c7064130c,0x1162def06f79df73,
+        0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
+        0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
+        0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
+        0x910ab1d4db9914a0,0x1d9c9892400a22a2,
+        0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
+        0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
+        0x8da471a9de737e24,0x5ceaecfed289e5d2,
+        0xb10d8e1456105dad,0x7425a83e872c5f47,
+        0xdd50f1996b947518,0xd12f124e28f77719,
+        0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
+        0xace73cbfdc0bfb7b,0x636cc64d1001550b,
+        0xd8210befd30efa5a,0x3c47f7e05401aa4e,
+        0x8714a775e3e95c78,0x65acfaec34810a71,
+        0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
+        0xd31045a8341ca07c,0x1ede48111209a050,
+        0x83ea2b892091e44d,0x934aed0aab460432,
+        0xa4e4b66b68b65d60,0xf81da84d5617853f,
+        0xce1de40642e3f4b9,0x36251260ab9d668e,
+        0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
+        0xa1075a24e4421730,0xb24cf65b8612f81f,
+        0xc94930ae1d529cfc,0xdee033f26797b627,
+        0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
+        0x9d412e0806e88aa5,0x8e1f289560ee864e,
+        0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
+        0xf5b5d7ec8acb58a2,0xae10af696774b1db,
+        0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
+        0xbff610b0cc6edd3f,0x17fd090a58d32af3,
+        0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
+        0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
+        0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
+        0xea53df5fd18d5513,0x84c86189216dc5ed,
+        0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
+        0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
+        0xe4d5e82392a40515,0xfabaf3feaa5334a,
+        0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
+        0xb2c71d5bca9023f8,0x743e20e9ef511012,
+        0xdf78e4b2bd342cf6,0x914da9246b255416,
+        0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
+        0xae9672aba3d0c320,0xa184ac2473b529b1,
+        0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
+        0x8865899617fb1871,0x7e2fa67c7a658892,
+        0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
+        0xd51ea6fa85785631,0x552a74227f3ea565,
+        0x8533285c936b35de,0xd53a88958f87275f,
+        0xa67ff273b8460356,0x8a892abaf368f137,
+        0xd01fef10a657842c,0x2d2b7569b0432d85,
+        0x8213f56a67f6b29b,0x9c3b29620e29fc73,
+        0xa298f2c501f45f42,0x8349f3ba91b47b8f,
+        0xcb3f2f7642717713,0x241c70a936219a73,
+        0xfe0efb53d30dd4d7,0xed238cd383aa0110,
+        0x9ec95d1463e8a506,0xf4363804324a40aa,
+        0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
+        0xf81aa16fdc1b81da,0xdd94b7868e94050a,
+        0x9b10a4e5e9913128,0xca7cf2b4191c8326,
+        0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
+        0xf24a01a73cf2dccf,0xbc633b39673c8cec,
+        0x976e41088617ca01,0xd5be0503e085d813,
+        0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
+        0xec9c459d51852ba2,0xddf8e7d60ed1219e,
+        0x93e1ab8252f33b45,0xcabb90e5c942b503,
+        0xb8da1662e7b00a17,0x3d6a751f3b936243,
+        0xe7109bfba19c0c9d,0xcc512670a783ad4,
+        0x906a617d450187e2,0x27fb2b80668b24c5,
+        0xb484f9dc9641e9da,0xb1f9f660802dedf6,
+        0xe1a63853bbd26451,0x5e7873f8a0396973,
+        0x8d07e33455637eb2,0xdb0b487b6423e1e8,
+        0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
+        0xdc5c5301c56b75f7,0x7641a140cc7810fb,
+        0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
+        0xac2820d9623bf429,0x546345fa9fbdcd44,
+        0xd732290fbacaf133,0xa97c177947ad4095,
+        0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
+        0xa81f301449ee8c70,0x5c68f256bfff5a74,
+        0xd226fc195c6a2f8c,0x73832eec6fff3111,
+        0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
+        0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
+        0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
+        0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
+        0xa0555e361951c366,0xd7e105bcc332621f,
+        0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
+        0xfa856334878fc150,0xb14f98f6f0feb951,
+        0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
+        0xc3b8358109e84f07,0xa862f80ec4700c8,
+        0xf4a642e14c6262c8,0xcd27bb612758c0fa,
+        0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
+        0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
+        0xeeea5d5004981478,0x1858ccfce06cac74,
+        0x95527a5202df0ccb,0xf37801e0c43ebc8,
+        0xbaa718e68396cffd,0xd30560258f54e6ba,
+        0xe950df20247c83fd,0x47c6b82ef32a2069,
+        0x91d28b7416cdd27e,0x4cdc331d57fa5441,
+        0xb6472e511c81471d,0xe0133fe4adf8e952,
+        0xe3d8f9e563a198e5,0x58180fddd97723a6,
+        0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
+using powers = powers_template<>;
+
+}
+
+#endif
+
+#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
+#define FASTFLOAT_DECIMAL_TO_BINARY_H
+
+//included above:
+//#include <cfloat>
+#include <cinttypes>
+#include <cmath>
+//included above:
+//#include <cstdint>
+#include <cstdlib>
+//included above:
+//#include <cstring>
+
+namespace fast_float {
+
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
+// the result, with the "high" part corresponding to the most significant bits and the
+// low part corresponding to the least significant bits.
+//
+template <int bit_precision>
+fastfloat_really_inline
+value128 compute_product_approximation(int64_t q, uint64_t w) {
+  const int index = 2 * int(q - powers::smallest_power_of_five);
+  // For small values of q, e.g., q in [0,27], the answer is always exact because
+  // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
+  // gives the exact answer.
+  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
+  static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
+  constexpr uint64_t precision_mask = (bit_precision < 64) ?
+               (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
+               : uint64_t(0xFFFFFFFFFFFFFFFF);
+  if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
+    // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
+    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
+    firstproduct.low += secondproduct.high;
+    if(secondproduct.high > firstproduct.low) {
+      firstproduct.high++;
+    }
+  }
+  return firstproduct;
+}
+
+namespace detail {
+/**
+ * For q in (0,350), we have that
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ *   floor(p) + q
+ * where
+ *   p = log(5**q)/log(2) = q * log(5)/log(2)
+ *
+ * For negative values of q in (-400,0), we have that 
+ *  f = (((152170 + 65536) * q ) >> 16);
+ * is equal to 
+ *   -ceil(p) + q
+ * where
+ *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
+ */
+  constexpr fastfloat_really_inline int32_t power(int32_t q)  noexcept  {
+    return (((152170 + 65536) * q) >> 16) + 63;
+  }
+} // namespace detail
+
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept  {
+  int hilz = int(w >> 63) ^ 1;
+  adjusted_mantissa answer;
+  answer.mantissa = w << hilz;
+  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + invalid_am_bias);
+  return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error(int64_t q, uint64_t w)  noexcept  {
+  int lz = leading_zeroes(w);
+  w <<= lz;
+  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  return compute_error_scaled<binary>(q, product.high, lz);
+}
+
+// w * 10 ** q
+// The returned value should be a valid ieee64 number that simply need to be packed.
+// However, in some very rare cases, the computation will fail. In such cases, we
+// return an adjusted_mantissa with a negative power of 2: the caller should recompute
+// in such cases.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
+  adjusted_mantissa answer;
+  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
+    answer.power2 = 0;
+    answer.mantissa = 0;
+    // result should be zero
+    return answer;
+  }
+  if (q > binary::largest_power_of_ten()) {
+    // we want to get infinity:
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+    return answer;
+  }
+  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
+
+  // We want the most significant bit of i to be 1. Shift if needed.
+  int lz = leading_zeroes(w);
+  w <<= lz;
+
+  // The required precision is binary::mantissa_explicit_bits() + 3 because
+  // 1. We need the implicit bit
+  // 2. We need an extra bit for rounding purposes
+  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
+
+  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
+    // In some very rare cases, this could happen, in which case we might need a more accurate
+    // computation that what we can provide cheaply. This is very, very unlikely.
+    //
+    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
+    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
+    if(!inside_safe_exponent) {
+      return compute_error_scaled<binary>(q, product.high, lz);
+    }
+  }
+  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
+  // value128 product = compute_product(q, w);
+  // but in practice, we can win big with the compute_product_approximation if its additional branch
+  // is easily predicted. Which is best is data specific.
+  int upperbit = int(product.high >> 63);
+
+  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+
+  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
+  if (answer.power2 <= 0) { // we have a subnormal?
+    // Here have that answer.power2 <= 0 so -answer.power2 >= 0
+    if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
+      answer.power2 = 0;
+      answer.mantissa = 0;
+      // result should be zero
+      return answer;
+    }
+    // next line is safe because -answer.power2 + 1 < 64
+    answer.mantissa >>= -answer.power2 + 1;
+    // Thankfully, we can't have both "round-to-even" and subnormals because
+    // "round-to-even" only occurs for powers close to 0.
+    answer.mantissa += (answer.mantissa & 1); // round up
+    answer.mantissa >>= 1;
+    // There is a weird scenario where we don't have a subnormal but just.
+    // Suppose we start with 2.2250738585072013e-308, we end up
+    // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
+    // whereas 0x40000000000000 x 2^-1023-53  is normal. Now, we need to round
+    // up 0x3fffffffffffff x 2^-1023-53  and once we do, we are no longer
+    // subnormal, but we can only know this after rounding.
+    // So we only declare a subnormal if we are smaller than the threshold.
+    answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
+    return answer;
+  }
+
+  // usually, we round *up*, but if we fall right in between and and we have an
+  // even basis, we need to round down
+  // We are only concerned with the cases where 5**q fits in single 64-bit word.
+  if ((product.low <= 1) &&  (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
+      ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
+    // To be in-between two floats we need that in doing
+    //   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+    // ... we dropped out only zeroes. But if this happened, then we can go back!!!
+    if((answer.mantissa  << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) ==  product.high) {
+      answer.mantissa &= ~uint64_t(1);          // flip it so that we do not round up
+    }
+  }
+
+  answer.mantissa += (answer.mantissa & 1); // round up
+  answer.mantissa >>= 1;
+  if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
+    answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
+    answer.power2++; // undo previous addition
+  }
+
+  answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
+  if (answer.power2 >= binary::infinite_power()) { // infinity
+    answer.power2 = binary::infinite_power();
+    answer.mantissa = 0;
+  }
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_BIGINT_H
+#define FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+//included above:
+//#include <cstdint>
+//included above:
+//#include <climits>
+//included above:
+//#include <cstring>
+
+
+namespace fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(FASTFLOAT_64BIT) && !defined(__sparc)
+#define FASTFLOAT_64BIT_LIMB
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size>
+struct stackvec {
+  limb data[size];
+  // we never need more than 150 limbs
+  uint16_t length{0};
+
+  stackvec() = default;
+  stackvec(const stackvec &) = delete;
+  stackvec &operator=(const stackvec &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  stackvec(limb_span s) {
+    FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  limb& operator[](size_t index) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  const limb& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  // index from the end of the container
+  const limb& rindex(size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    size_t rindex = length - index - 1;
+    return data[rindex];
+  }
+
+  // set the length, without bounds checking.
+  void set_len(size_t len) noexcept {
+    length = uint16_t(len);
+  }
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+  constexpr bool is_empty() const noexcept {
+    return length == 0;
+  }
+  constexpr size_t capacity() const noexcept {
+    return size;
+  }
+  // append item to vector, without bounds checking
+  void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+  // append item to vector, returning if item was added
+  bool try_push(limb value) noexcept {
+    if (len() < capacity()) {
+      push_unchecked(value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // add items to the vector, from a span, without bounds checking
+  void extend_unchecked(limb_span s) noexcept {
+    limb* ptr = data + length;
+    ::memcpy((void*)ptr, (const void*)s.ptr, sizeof(limb) * s.len());
+    set_len(len() + s.len());
+  }
+  // try to add items to the vector, returning if items were added
+  bool try_extend(limb_span s) noexcept {
+    if (len() + s.len() <= capacity()) {
+      extend_unchecked(s);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // resize the vector, without bounds checking
+  // if the new size is longer than the vector, assign value to each
+  // appended item.
+  void resize_unchecked(size_t new_len, limb value) noexcept {
+    if (new_len > len()) {
+      size_t count = new_len - len();
+      limb* first = data + len();
+      limb* last = first + count;
+      ::std::fill(first, last, value);
+      set_len(new_len);
+    } else {
+      set_len(new_len);
+    }
+  }
+  // try to resize the vector, returning if the vector was resized.
+  bool try_resize(size_t new_len, limb value) noexcept {
+    if (new_len > capacity()) {
+      return false;
+    } else {
+      resize_unchecked(new_len, value);
+      return true;
+    }
+  }
+  // check if any limbs are non-zero after the given index.
+  // this needs to be done in reverse order, since the index
+  // is relative to the most significant limbs.
+  bool nonzero(size_t index) const noexcept {
+    while (index < len()) {
+      if (rindex(index) != 0) {
+        return true;
+      }
+      index++;
+    }
+    return false;
+  }
+  // normalize the big integer, so most-significant zero limbs are removed.
+  void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline
+uint64_t empty_hi64(bool& truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
+  int shl = leading_zeroes(r0);
+  if (shl == 0) {
+    truncated = r1 != 0;
+    return r0;
+  } else {
+    int shr = 64 - shl;
+    truncated = (r1 << shl) != 0;
+    return (r0 << shl) | (r1 >> shr);
+  }
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  uint64_t x2 = r2;
+  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline
+limb scalar_add(limb x, limb y, bool& overflow) noexcept {
+  limb z;
+
+// gcc and clang
+#if defined(__has_builtin)
+  #if __has_builtin(__builtin_add_overflow)
+    overflow = __builtin_add_overflow(x, y, &z);
+    return z;
+  #endif
+#endif
+
+  // generic, this still optimizes correctly on MSVC.
+  z = x + y;
+  overflow = z < x;
+  return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline
+limb scalar_mul(limb x, limb y, limb& carry) noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+  #if defined(__SIZEOF_INT128__)
+  // GCC and clang both define it as an extension.
+  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+  #else
+  // fallback, no native 128-bit integer multiplication with carry.
+  // on msvc, this optimizes identically, somehow.
+  value128 z = full_multiplication(x, y);
+  bool overflow;
+  z.low = scalar_add(z.low, carry, overflow);
+  z.high += uint64_t(overflow);  // cannot overflow
+  carry = z.high;
+  return z.low;
+  #endif
+#else
+  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
+  size_t index = start;
+  limb carry = y;
+  bool overflow;
+  while (carry != 0 && index < vec.len()) {
+    vec[index] = scalar_add(vec[index], carry, overflow);
+    carry = limb(overflow);
+    index += 1;
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool small_add(stackvec<size>& vec, limb y) noexcept {
+  return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
+  limb carry = 0;
+  for (size_t index = 0; index < vec.len(); index++) {
+    vec[index] = scalar_mul(vec[index], y, carry);
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
+  // the effective x buffer is from `xstart..x.len()`, so exit early
+  // if we can't get that current range.
+  if (x.len() < start || y.len() > x.len() - start) {
+      FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+  }
+
+  bool carry = false;
+  for (size_t index = 0; index < y.len(); index++) {
+    limb xi = x[index + start];
+    limb yi = y[index];
+    bool c1 = false;
+    bool c2 = false;
+    xi = scalar_add(xi, yi, c1);
+    if (carry) {
+      xi = scalar_add(xi, 1, c2);
+    }
+    x[index + start] = xi;
+    carry = c1 | c2;
+  }
+
+  // handle overflow
+  if (carry) {
+    FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+  }
+  return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
+  return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool long_mul(stackvec<size>& x, limb_span y) noexcept {
+  limb_span xs = limb_span(x.data, x.len());
+  stackvec<size> z(xs);
+  limb_span zs = limb_span(z.data, z.len());
+
+  if (y.len() != 0) {
+    limb y0 = y[0];
+    FASTFLOAT_TRY(small_mul(x, y0));
+    for (size_t index = 1; index < y.len(); index++) {
+      limb yi = y[index];
+      stackvec<size> zi;
+      if (yi != 0) {
+        // re-use the same buffer throughout
+        zi.set_len(0);
+        FASTFLOAT_TRY(zi.try_extend(zs));
+        FASTFLOAT_TRY(small_mul(zi, yi));
+        limb_span zis = limb_span(zi.data, zi.len());
+        FASTFLOAT_TRY(large_add_from(x, zis, index));
+      }
+    }
+  }
+
+  x.normalize();
+  return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool large_mul(stackvec<size>& x, limb_span y) noexcept {
+  if (y.len() == 1) {
+    FASTFLOAT_TRY(small_mul(x, y[0]));
+  } else {
+    FASTFLOAT_TRY(long_mul(x, y));
+  }
+  return true;
+}
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  bigint(): vec() {}
+  bigint(const bigint &) = delete;
+  bigint &operator=(const bigint &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  bigint(uint64_t value): vec() {
+#ifdef FASTFLOAT_64BIT_LIMB
+    vec.push_unchecked(value);
+#else
+    vec.push_unchecked(uint32_t(value));
+    vec.push_unchecked(uint32_t(value >> 32));
+#endif
+    vec.normalize();
+  }
+
+  // get the high 64 bits from the vector, and if bits were truncated.
+  // this is to get the significant digits for the float.
+  uint64_t hi64(bool& truncated) const noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint64_hi64(vec.rindex(0), truncated);
+    } else {
+      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+      truncated |= vec.nonzero(2);
+      return result;
+    }
+#else
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint32_hi64(vec.rindex(0), truncated);
+    } else if (vec.len() == 2) {
+      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+    } else {
+      uint64_t result = uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+      truncated |= vec.nonzero(3);
+      return result;
+    }
+#endif
+  }
+
+  // compare two big integers, returning the large value.
+  // assumes both are normalized. if the return value is
+  // negative, other is larger, if the return value is
+  // positive, this is larger, otherwise they are equal.
+  // the limbs are stored in little-endian order, so we
+  // must compare the limbs in ever order.
+  int compare(const bigint& other) const noexcept {
+    if (vec.len() > other.vec.len()) {
+      return 1;
+    } else if (vec.len() < other.vec.len()) {
+      return -1;
+    } else {
+      for (size_t index = vec.len(); index > 0; index--) {
+        limb xi = vec[index - 1];
+        limb yi = other.vec[index - 1];
+        if (xi > yi) {
+          return 1;
+        } else if (xi < yi) {
+          return -1;
+        }
+      }
+      return 0;
+    }
+  }
+
+  // shift left each limb n bits, carrying over to the new limb
+  // returns true if we were able to shift all the digits.
+  bool shl_bits(size_t n) noexcept {
+    // Internally, for each item, we shift left by n, and add the previous
+    // right shifted limb-bits.
+    // For example, we transform (for u8) shifted left 2, to:
+    //      b10100100 b01000010
+    //      b10 b10010001 b00001000
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+    size_t shl = n;
+    size_t shr = limb_bits - shl;
+    limb prev = 0;
+    for (size_t index = 0; index < vec.len(); index++) {
+      limb xi = vec[index];
+      vec[index] = (xi << shl) | (prev >> shr);
+      prev = xi;
+    }
+
+    limb carry = prev >> shr;
+    if (carry != 0) {
+      return vec.try_push(carry);
+    }
+    return true;
+  }
+
+  // move the limbs left by `n` limbs.
+  bool shl_limbs(size_t n) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    if (n + vec.len() > vec.capacity()) {
+      return false;
+    } else if (!vec.is_empty()) {
+      // move limbs
+      limb* dst = vec.data + n;
+      const limb* src = vec.data;
+      ::memmove(dst, src, sizeof(limb) * vec.len());
+      // fill in empty limbs
+      limb* first = vec.data;
+      limb* last = first + n;
+      ::std::fill(first, last, 0);
+      vec.set_len(n + vec.len());
+      return true;
+    } else {
+      return true;
+    }
+  }
+
+  // move the limbs left by `n` bits.
+  bool shl(size_t n) noexcept {
+    size_t rem = n % limb_bits;
+    size_t div = n / limb_bits;
+    if (rem != 0) {
+      FASTFLOAT_TRY(shl_bits(rem));
+    }
+    if (div != 0) {
+      FASTFLOAT_TRY(shl_limbs(div));
+    }
+    return true;
+  }
+
+  // get the number of leading zeros in the bigint.
+  int ctlz() const noexcept {
+    if (vec.is_empty()) {
+      return 0;
+    } else {
+#ifdef FASTFLOAT_64BIT_LIMB
+      return leading_zeroes(vec.rindex(0));
+#else
+      // no use defining a specialized leading_zeroes for a 32-bit type.
+      uint64_t r0 = vec.rindex(0);
+      return leading_zeroes(r0 << 32);
+#endif
+    }
+  }
+
+  // get the number of bits in the bigint.
+  int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  bool mul(limb y) noexcept {
+    return small_mul(vec, y);
+  }
+
+  bool add(limb y) noexcept {
+    return small_add(vec, y);
+  }
+
+  // multiply as if by 2 raised to a power.
+  bool pow2(uint32_t exp) noexcept {
+    return shl(exp);
+  }
+
+  // multiply as if by 5 raised to a power.
+  bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    static constexpr uint32_t large_step = 135;
+    static constexpr uint64_t small_power_of_5[] = {
+      1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
+      1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
+      6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
+      3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
+      2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
+      298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
+    };
+#ifdef FASTFLOAT_64BIT_LIMB
+    constexpr static limb large_power_of_5[] = {
+      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+      10482974169319127550UL, 198276706040285095UL};
+#else
+    constexpr static limb large_power_of_5[] = {
+      4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
+      1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
+#endif
+    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+    limb_span large = limb_span(large_power_of_5, large_length);
+    while (exp >= large_step) {
+      FASTFLOAT_TRY(large_mul(vec, large));
+      exp -= large_step;
+    }
+#ifdef FASTFLOAT_64BIT_LIMB
+    uint32_t small_step = 27;
+    limb max_native = 7450580596923828125UL;
+#else
+    uint32_t small_step = 13;
+    limb max_native = 1220703125U;
+#endif
+    while (exp >= small_step) {
+      FASTFLOAT_TRY(small_mul(vec, max_native));
+      exp -= small_step;
+    }
+    if (exp != 0) {
+      FASTFLOAT_TRY(small_mul(vec, limb(small_power_of_5[exp])));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  bool pow10(uint32_t exp) noexcept {
+    FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+//included above:
+//#include <cctype>
+//included above:
+//#include <cstdint>
+//included above:
+//#include <cstring>
+//included above:
+//#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56
+    | (val & 0x00FF000000000000) >> 40
+    | (val & 0x0000FF0000000000) >> 24
+    | (val & 0x000000FF00000000) >> 8
+    | (val & 0x00000000FF000000) << 8
+    | (val & 0x0000000000FF0000) << 24
+    | (val & 0x000000000000FF00) << 40
+    | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit  @aqrit
+fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
+  const uint64_t mask = 0x000000FF000000FF;
+  const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+  val -= 0x3030303030303030;
+  val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+  val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+  return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
+  return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+     0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
+  return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  const char *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  byte_span integer{};  // non-nullable
+  byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
+  parsed_number_string answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  answer.negative = (*p == '-');
+  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+    ++p;
+    if (p == pend) {
+      return answer;
+    }
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+      return answer;
+    }
+  }
+  const char *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  const char *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = byte_span(start_digits, size_t(digit_count));
+  int64_t exponent = 0;
+  if ((p != pend) && (*p == decimal_point)) {
+    ++p;
+    const char* before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+      i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+      p += 8;
+    }
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - '0');
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = byte_span(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  // we must have encountered at least one integer!
+  if (digit_count == 0) {
+    return answer;
+  }
+  int64_t exp_number = 0;            // explicit exponential part
+  if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+    const char * location_of_e = p;
+    ++p;
+    bool neg_exp = false;
+    if ((p != pend) && ('-' == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if(!(fmt & chars_format::fixed)) {
+        // We are in error.
+        return answer;
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - '0');
+        if (exp_number < 0x10000000) {
+          exp_number = 10 * exp_number + digit;
+        }
+        ++p;
+      }
+      if(neg_exp) { exp_number = - exp_number; }
+      exponent += exp_number;
+    }
+  } else {
+    // If it scientific and not fixed, we have to bail out.
+    if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+  }
+  answer.lastmatch = p;
+  answer.valid = true;
+
+  // If we frequently had to deal with long strings of digits,
+  // we could extend our code by using a 128-bit integer instead
+  // of a 64-bit integer. However, this is uncommon.
+  //
+  // We can deal with up to 19 digits.
+  if (digit_count > 19) { // this is uncommon
+    // It is possible that the integer had an overflow.
+    // We have to handle the case where we have 0.0000somenumber.
+    // We need to be mindful of the case where we only have zeroes...
+    // E.g., 0.000000000...000.
+    const char *start = start_digits;
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+      if(*start == '0') { digit_count --; }
+      start++;
+    }
+    if (digit_count > 19) {
+      answer.too_many_digits = true;
+      // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
+      i = 0;
+      p = answer.integer.ptr;
+      const char* int_end = p + answer.integer.len();
+      const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - '0');
+        ++p;
+      }
+      if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+        exponent = end_of_integer_part - p + exp_number;
+      } else { // We have a value with a fractional component.
+          p = answer.fraction.ptr;
+          const char* frac_end = p + answer.fraction.len();
+          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+            i = i * 10 + uint64_t(*p - '0');
+            ++p;
+          }
+          exponent = answer.fraction.ptr - p + exp_number;
+      }
+      // We have now corrected both exponent and i, to a truncated value
+    }
+  }
+  answer.exponent = exponent;
+  answer.mantissa = i;
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DIGIT_COMPARISON_H
+#define FASTFLOAT_DIGIT_COMPARISON_H
+
+//included above:
+//#include <algorithm>
+//included above:
+//#include <cstdint>
+//included above:
+//#include <cstring>
+//included above:
+//#include <iterator>
+
+
+namespace fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {
+    1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
+    1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
+    100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
+    1000000000000000000UL, 10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+fastfloat_really_inline int32_t scientific_exponent(parsed_number_string& num) noexcept {
+  uint64_t mantissa = num.mantissa;
+  int32_t exponent = int32_t(num.exponent);
+  while (mantissa >= 10000) {
+    mantissa /= 10000;
+    exponent += 4;
+  }
+  while (mantissa >= 100) {
+    mantissa /= 100;
+    exponent += 2;
+  }
+  while (mantissa >= 10) {
+    mantissa /= 10;
+    exponent += 1;
+  }
+  return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended(T value) noexcept {
+  using equiv_uint = typename binary_format<T>::equiv_uint;
+  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
+  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
+  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
+
+  adjusted_mantissa am;
+  int32_t bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  equiv_uint bits;
+  ::memcpy(&bits, &value, sizeof(T));
+  if ((bits & exponent_mask) == 0) {
+    // denormal
+    am.power2 = 1 - bias;
+    am.mantissa = bits & mantissa_mask;
+  } else {
+    // normal
+    am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
+    am.power2 -= bias;
+    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+  }
+
+  return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended_halfway(T value) noexcept {
+  adjusted_mantissa am = to_extended(value);
+  am.mantissa <<= 1;
+  am.mantissa += 1;
+  am.power2 -= 1;
+  return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept {
+  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+  if (-am.power2 >= mantissa_shift) {
+    // have a denormal float
+    int32_t shift = -am.power2 + 1;
+    cb(am, std::min<int32_t>(shift, 64));
+    // check for round-up: if rounding-nearest carried us to the hidden bit.
+    am.power2 = (am.mantissa < (uint64_t(1) << binary_format<T>::mantissa_explicit_bits())) ? 0 : 1;
+    return;
+  }
+
+  // have a normal float, use the default shift.
+  cb(am, mantissa_shift);
+
+  // check for carry
+  if (am.mantissa >= (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+    am.power2++;
+  }
+
+  // check for infinite: we could have carried to an infinite power
+  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+  if (am.power2 >= binary_format<T>::infinite_power()) {
+    am.power2 = binary_format<T>::infinite_power();
+    am.mantissa = 0;
+  }
+}
+
+template <typename callback>
+fastfloat_really_inline
+void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept {
+  uint64_t mask;
+  uint64_t halfway;
+  if (shift == 64) {
+    mask = UINT64_MAX;
+  } else {
+    mask = (uint64_t(1) << shift) - 1;
+  }
+  if (shift == 0) {
+    halfway = 0;
+  } else {
+    halfway = uint64_t(1) << (shift - 1);
+  }
+  uint64_t truncated_bits = am.mantissa & mask;
+  uint64_t is_above = truncated_bits > halfway;
+  uint64_t is_halfway = truncated_bits == halfway;
+
+  // shift digits into position
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+
+  bool is_odd = (am.mantissa & 1) == 1;
+  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+
+fastfloat_really_inline void skip_zeros(const char*& first, const char* last) noexcept {
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      break;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+fastfloat_really_inline bool is_truncated(const char* first, const char* last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      return true;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      return true;
+    }
+    first++;
+  }
+  return false;
+}
+
+fastfloat_really_inline bool is_truncated(byte_span s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+fastfloat_really_inline
+void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+fastfloat_really_inline
+void parse_one_digit(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 10 + limb(*p - '0');
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline
+void add_native(bigint& big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline void round_up_bigint(bigint& big, size_t& count) noexcept {
+  // need to round-up the digits, but need to avoid rounding
+  // ....9999 to ...10000, which could cause a false halfway point.
+  add_native(big, 10, 1);
+  count++;
+}
+
+// parse the significant digits into a big integer
+inline void parse_mantissa(bigint& result, parsed_number_string& num, size_t max_digits, size_t& digits) noexcept {
+  // try to minimize the number of big integer and scalar multiplication.
+  // therefore, try to parse 8 digits at a time, and multiply by the largest
+  // scalar value (9 or 19 digits) for each step.
+  size_t counter = 0;
+  digits = 0;
+  limb value = 0;
+#ifdef FASTFLOAT_64BIT_LIMB
+  size_t step = 19;
+#else
+  size_t step = 9;
+#endif
+
+  // process all integer digits.
+  const char* p = num.integer.ptr;
+  const char* pend = p + num.integer.len();
+  skip_zeros(p, pend);
+  // process all digits, in increments of step per loop
+  while (p != pend) {
+    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+      parse_eight_digits(p, value, counter, digits);
+    }
+    while (counter < step && p != pend && digits < max_digits) {
+      parse_one_digit(p, value, counter, digits);
+    }
+    if (digits == max_digits) {
+      // add the temporary value, then check if we've truncated any digits
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      bool truncated = is_truncated(p, pend);
+      if (num.fraction.ptr != nullptr) {
+        truncated |= is_truncated(num.fraction);
+      }
+      if (truncated) {
+        round_up_bigint(result, digits);
+      }
+      return;
+    } else {
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      counter = 0;
+      value = 0;
+    }
+  }
+
+  // add our fraction digits, if they're available.
+  if (num.fraction.ptr != nullptr) {
+    p = num.fraction.ptr;
+    pend = p + num.fraction.len();
+    if (digits == 0) {
+      skip_zeros(p, pend);
+    }
+    // process all digits, in increments of step per loop
+    while (p != pend) {
+      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+        parse_eight_digits(p, value, counter, digits);
+      }
+      while (counter < step && p != pend && digits < max_digits) {
+        parse_one_digit(p, value, counter, digits);
+      }
+      if (digits == max_digits) {
+        // add the temporary value, then check if we've truncated any digits
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        bool truncated = is_truncated(p, pend);
+        if (truncated) {
+          round_up_bigint(result, digits);
+        }
+        return;
+      } else {
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        counter = 0;
+        value = 0;
+      }
+    }
+  }
+
+  if (counter != 0) {
+    add_native(result, limb(powers_of_ten_uint64[counter]), value);
+  }
+}
+
+template <typename T>
+inline adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcept {
+  FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+  adjusted_mantissa answer;
+  bool truncated;
+  answer.mantissa = bigmant.hi64(truncated);
+  int bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  answer.power2 = bigmant.bit_length() - 64 + bias;
+
+  round<T>(answer, [truncated](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+      return is_above || (is_halfway && truncated) || (is_odd && is_halfway);
+    });
+  });
+
+  return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+  bigint& real_digits = bigmant;
+  int32_t real_exp = exponent;
+
+  // get the value of `b`, rounded down, and get a bigint representation of b+h
+  adjusted_mantissa am_b = am;
+  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with -Wnoexcept-type.
+  round<T>(am_b, [](adjusted_mantissa&a, int32_t shift) { round_down(a, shift); });
+  T b;
+  to_float(false, am_b, b);
+  adjusted_mantissa theor = to_extended_halfway(b);
+  bigint theor_digits(theor.mantissa);
+  int32_t theor_exp = theor.power2;
+
+  // scale real digits and theor digits to be same power.
+  int32_t pow2_exp = theor_exp - real_exp;
+  uint32_t pow5_exp = uint32_t(-real_exp);
+  if (pow5_exp != 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+  }
+  if (pow2_exp > 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+  } else if (pow2_exp < 0) {
+    FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+  }
+
+  // compare digits, and use it to director rounding
+  int ord = real_digits.compare(theor_digits);
+  adjusted_mantissa answer = am;
+  round<T>(answer, [ord](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+      (void)_;  // not needed, since we've done our comparison
+      (void)__; // not needed, since we've done our comparison
+      if (ord > 0) {
+        return true;
+      } else if (ord < 0) {
+        return false;
+      } else {
+        return is_odd;
+      }
+    });
+  });
+
+  return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T>
+inline adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa am) noexcept {
+  // remove the invalid exponent bias
+  am.power2 -= invalid_am_bias;
+
+  int32_t sci_exp = scientific_exponent(num);
+  size_t max_digits = binary_format<T>::max_digits();
+  size_t digits = 0;
+  bigint bigmant;
+  parse_mantissa(bigmant, num, max_digits, digits);
+  // can't underflow, since digits is at most max_digits.
+  int32_t exponent = sci_exp + 1 - int32_t(digits);
+  if (exponent >= 0) {
+    return positive_digit_comp<T>(bigmant, exponent);
+  } else {
+    return negative_digit_comp<T>(bigmant, am, exponent);
+  }
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_PARSE_NUMBER_H
+#define FASTFLOAT_PARSE_NUMBER_H
+
+
+//included above:
+//#include <cmath>
+//included above:
+//#include <cstring>
+//included above:
+//#include <limits>
+//included above:
+//#include <system_error>
+
+namespace fast_float {
+
+
+namespace detail {
+/**
+ * Special case +inf, -inf, nan, infinity, -infinity.
+ * The case comparisons could be made much faster given that we know that the
+ * strings a null-free and fixed.
+ **/
+template <typename T>
+from_chars_result parse_infnan(const char *first, const char *last, T &value)  noexcept  {
+  from_chars_result answer;
+  answer.ptr = first;
+  answer.ec = std::errc(); // be optimistic
+  bool minusSign = false;
+  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
+      minusSign = true;
+      ++first;
+  }
+  if (last - first >= 3) {
+    if (fastfloat_strncasecmp(first, "nan", 3)) {
+      answer.ptr = (first += 3);
+      value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
+      // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
+      if(first != last && *first == '(') {
+        for(const char* ptr = first + 1; ptr != last; ++ptr) {
+          if (*ptr == ')') {
+            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+            break;
+          }
+          else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
+            break; // forbidden char, not nan(n-char-seq-opt)
+        }
+      }
+      return answer;
+    }
+    if (fastfloat_strncasecmp(first, "inf", 3)) {
+      if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
+        answer.ptr = first + 8;
+      } else {
+        answer.ptr = first + 3;
+      }
+      value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
+      return answer;
+    }
+  }
+  answer.ec = std::errc::invalid_argument;
+  return answer;
+}
+
+} // namespace detail
+
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+                             T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
+  return from_chars_advanced(first, last, value, parse_options{fmt});
+}
+
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept  {
+
+  static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
+
+
+  from_chars_result answer;
+  if (first == last) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  parsed_number_string pns = parse_number_string(first, last, options);
+  if (!pns.valid) {
+    return detail::parse_infnan(first, last, value);
+  }
+  answer.ec = std::errc(); // be optimistic
+  answer.ptr = pns.lastmatch;
+  // Next is Clinger's fast path.
+  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && pns.mantissa <=binary_format<T>::max_mantissa_fast_path() && !pns.too_many_digits) {
+    value = T(pns.mantissa);
+    if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
+    else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
+    if (pns.negative) { value = -value; }
+    return answer;
+  }
+  adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
+  if(pns.too_many_digits && am.power2 >= 0) {
+    if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
+      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
+    }
+  }
+  // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
+  // then we need to go the long way around again. This is very uncommon.
+  if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
+  to_float(pns.negative, am, value);
+  return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__) || defined(__APPLE_CC__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif // _C4_EXT_FAST_FLOAT_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/ext/fast_float.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/vector_fwd.hpp
+// https://github.com/biojppm/c4core/src/c4/std/vector_fwd.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_VECTOR_FWD_HPP_
+#define _C4_STD_VECTOR_FWD_HPP_
+
+/** @file vector_fwd.hpp */
+
+//included above:
+//#include <cstddef>
+
+// forward declarations for std::vector
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__) || defined(_MSC_VER)
+namespace std {
+template<typename> class allocator;
+template<typename T, typename Alloc> class vector;
+} // namespace std
+#elif defined(_LIBCPP_ABI_NAMESPACE)
+namespace std {
+inline namespace _LIBCPP_ABI_NAMESPACE {
+template<typename> class allocator;
+template<typename T, typename Alloc> class vector;
+} // namespace _LIBCPP_ABI_NAMESPACE
+} // namespace std
+#else
+#error "unknown standard library"
+#endif
+
+#ifndef C4CORE_SINGLE_HEADER
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp
+//#include "c4/substr_fwd.hpp"
+#if !defined(C4_SUBSTR_FWD_HPP_) && !defined(_C4_SUBSTR_FWD_HPP_)
+#error "amalgamate: file c4/substr_fwd.hpp must have been included at this point"
+#endif /* C4_SUBSTR_FWD_HPP_ */
+
+#endif
+
+namespace c4 {
+
+template<class Alloc> c4::substr to_substr(std::vector<char, Alloc> &vec);
+template<class Alloc> c4::csubstr to_csubstr(std::vector<char, Alloc> const& vec);
+
+template<class Alloc> bool operator!= (c4::csubstr ss, std::vector<char, Alloc> const& s);
+template<class Alloc> bool operator== (c4::csubstr ss, std::vector<char, Alloc> const& s);
+template<class Alloc> bool operator>= (c4::csubstr ss, std::vector<char, Alloc> const& s);
+template<class Alloc> bool operator>  (c4::csubstr ss, std::vector<char, Alloc> const& s);
+template<class Alloc> bool operator<= (c4::csubstr ss, std::vector<char, Alloc> const& s);
+template<class Alloc> bool operator<  (c4::csubstr ss, std::vector<char, Alloc> const& s);
+
+template<class Alloc> bool operator!= (std::vector<char, Alloc> const& s, c4::csubstr ss);
+template<class Alloc> bool operator== (std::vector<char, Alloc> const& s, c4::csubstr ss);
+template<class Alloc> bool operator>= (std::vector<char, Alloc> const& s, c4::csubstr ss);
+template<class Alloc> bool operator>  (std::vector<char, Alloc> const& s, c4::csubstr ss);
+template<class Alloc> bool operator<= (std::vector<char, Alloc> const& s, c4::csubstr ss);
+template<class Alloc> bool operator<  (std::vector<char, Alloc> const& s, c4::csubstr ss);
+
+template<class Alloc> size_t to_chars(c4::substr buf, std::vector<char, Alloc> const& s);
+template<class Alloc> bool from_chars(c4::csubstr buf, std::vector<char, Alloc> * s);
+
+} // namespace c4
+
+#endif // _C4_STD_VECTOR_FWD_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/vector_fwd.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/string_fwd.hpp
+// https://github.com/biojppm/c4core/src/c4/std/string_fwd.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_STRING_FWD_HPP_
+#define _C4_STD_STRING_FWD_HPP_
+
+/** @file string_fwd.hpp */
+
+#ifndef DOXYGEN
+
+#ifndef C4CORE_SINGLE_HEADER
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp
+//#include "c4/substr_fwd.hpp"
+#if !defined(C4_SUBSTR_FWD_HPP_) && !defined(_C4_SUBSTR_FWD_HPP_)
+#error "amalgamate: file c4/substr_fwd.hpp must have been included at this point"
+#endif /* C4_SUBSTR_FWD_HPP_ */
+
+#endif
+
+//included above:
+//#include <cstddef>
+
+// forward declarations for std::string
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__)
+#include <bits/stringfwd.h>  // use the fwd header in glibcxx
+#elif defined(_LIBCPP_VERSION) || defined(__APPLE_CC__)
+#include <iosfwd>  // use the fwd header in stdlibc++
+#elif defined(_MSC_VER)
+//! @todo is there a fwd header in msvc?
+namespace std {
+template<typename> struct char_traits;
+template<typename> class allocator;
+template<typename _CharT, typename _Traits, typename _Alloc> class basic_string;
+using string = basic_string<char, char_traits<char>, allocator<char>>;
+} /* namespace std */
+#else
+#error "unknown standard library"
+#endif
+
+namespace c4 {
+
+c4::substr to_substr(std::string &s);
+c4::csubstr to_csubstr(std::string const& s);
+
+bool operator== (c4::csubstr ss, std::string const& s);
+bool operator!= (c4::csubstr ss, std::string const& s);
+bool operator>= (c4::csubstr ss, std::string const& s);
+bool operator>  (c4::csubstr ss, std::string const& s);
+bool operator<= (c4::csubstr ss, std::string const& s);
+bool operator<  (c4::csubstr ss, std::string const& s);
+
+bool operator== (std::string const& s, c4::csubstr ss);
+bool operator!= (std::string const& s, c4::csubstr ss);
+bool operator>= (std::string const& s, c4::csubstr ss);
+bool operator>  (std::string const& s, c4::csubstr ss);
+bool operator<= (std::string const& s, c4::csubstr ss);
+bool operator<  (std::string const& s, c4::csubstr ss);
+
+size_t to_chars(c4::substr buf, std::string const& s);
+bool from_chars(c4::csubstr buf, std::string * s);
+
+} // namespace c4
+
+#endif // DOXYGEN
+#endif // _C4_STD_STRING_FWD_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/string_fwd.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/std_fwd.hpp
+// https://github.com/biojppm/c4core/src/c4/std/std_fwd.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_STD_FWD_HPP_
+#define _C4_STD_STD_FWD_HPP_
+
+/** @file std_fwd.hpp includes all c4-std interop fwd files */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/std/vector_fwd.hpp
+//#include "c4/std/vector_fwd.hpp"
+#if !defined(C4_STD_VECTOR_FWD_HPP_) && !defined(_C4_STD_VECTOR_FWD_HPP_)
+#error "amalgamate: file c4/std/vector_fwd.hpp must have been included at this point"
+#endif /* C4_STD_VECTOR_FWD_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/std/string_fwd.hpp
+//#include "c4/std/string_fwd.hpp"
+#if !defined(C4_STD_STRING_FWD_HPP_) && !defined(_C4_STD_STRING_FWD_HPP_)
+#error "amalgamate: file c4/std/string_fwd.hpp must have been included at this point"
+#endif /* C4_STD_STRING_FWD_HPP_ */
+
+//#include "c4/std/tuple_fwd.hpp"
+
+#endif // _C4_STD_STD_FWD_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/std_fwd.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/charconv.hpp
+// https://github.com/biojppm/c4core/src/c4/charconv.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_CHARCONV_HPP_
+#define _C4_CHARCONV_HPP_
+
+/** @file charconv.hpp Lightweight generic type-safe wrappers for
+ * converting individual values to/from strings.
+ *
+ * These are the main functions:
+ *
+ * @code{.cpp}
+ * // Convert the given value, writing into the string.
+ * // The resulting string will NOT be null-terminated.
+ * // Return the number of characters needed.
+ * // This function is safe to call when the string is too small -
+ * // no writes will occur beyond the string's last character.
+ * template<class T> size_t c4::to_chars(substr buf, T const& C4_RESTRICT val);
+ *
+ *
+ * // Convert the given value to a string using to_chars(), and
+ * // return the resulting string, up to and including the last
+ * // written character.
+ * template<class T> substr c4::to_chars_sub(substr buf, T const& C4_RESTRICT val);
+ *
+ *
+ * // Read a value from the string, which must be
+ * // trimmed to the value (ie, no leading/trailing whitespace).
+ * // return true if the conversion succeeded.
+ * template<class T> bool c4::from_chars(csubstr buf, T * C4_RESTRICT val);
+ *
+ *
+ * // Read the first valid sequence of characters from the string,
+ * // skipping leading whitespace, and convert it using from_chars().
+ * // Return the number of characters read for converting.
+ * template<class T> size_t c4::from_chars_first(csubstr buf, T * C4_RESTRICT val);
+ * @endcode
+ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+//included above:
+//#include <inttypes.h>
+//included above:
+//#include <type_traits>
+//included above:
+//#include <climits>
+//included above:
+//#include <limits>
+//included above:
+//#include <utility>
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr.hpp
+//#include "c4/substr.hpp"
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/std/std_fwd.hpp
+//#include "c4/std/std_fwd.hpp"
+#if !defined(C4_STD_STD_FWD_HPP_) && !defined(_C4_STD_STD_FWD_HPP_)
+#error "amalgamate: file c4/std/std_fwd.hpp must have been included at this point"
+#endif /* C4_STD_STD_FWD_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_util.hpp
+//#include "c4/memory_util.hpp"
+#if !defined(C4_MEMORY_UTIL_HPP_) && !defined(_C4_MEMORY_UTIL_HPP_)
+#error "amalgamate: file c4/memory_util.hpp must have been included at this point"
+#endif /* C4_MEMORY_UTIL_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/szconv.hpp
+//#include "c4/szconv.hpp"
+#if !defined(C4_SZCONV_HPP_) && !defined(_C4_SZCONV_HPP_)
+#error "amalgamate: file c4/szconv.hpp must have been included at this point"
+#endif /* C4_SZCONV_HPP_ */
+
+
+#ifndef C4CORE_NO_FAST_FLOAT
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wsign-conversion")
+    C4_SUPPRESS_WARNING_GCC("-Warray-bounds")
+#if __GNUC__ >= 5
+    C4_SUPPRESS_WARNING_GCC("-Wshift-count-overflow")
+#endif
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/ext/fast_float.hpp
+//#   include "c4/ext/fast_float.hpp"
+#if !defined(C4_EXT_FAST_FLOAT_HPP_) && !defined(_C4_EXT_FAST_FLOAT_HPP_)
+#error "amalgamate: file c4/ext/fast_float.hpp must have been included at this point"
+#endif /* C4_EXT_FAST_FLOAT_HPP_ */
+
+    C4_SUPPRESS_WARNING_GCC_POP
+#   define C4CORE_HAVE_FAST_FLOAT 1
+#   define C4CORE_HAVE_STD_FROMCHARS 0
+#   if (C4_CPP >= 17)
+#       if defined(_MSC_VER)
+#           if (C4_MSVC_VERSION >= C4_MSVC_VERSION_2019)
+#               include <charconv>
+#               define C4CORE_HAVE_STD_TOCHARS 1
+#           else
+#               define C4CORE_HAVE_STD_TOCHARS 0
+#           endif
+#       else  // VS2017 and lower do not have these macros
+#           if __has_include(<charconv>) && __cpp_lib_to_chars
+#               define C4CORE_HAVE_STD_TOCHARS 1
+//included above:
+//#               include <charconv>
+#           else
+#               define C4CORE_HAVE_STD_TOCHARS 0
+#           endif
+#       endif
+#   else
+#       define C4CORE_HAVE_STD_TOCHARS 0
+#   endif
+#elif (C4_CPP >= 17)
+#   if defined(_MSC_VER)
+#       if (C4_MSVC_VERSION >= C4_MSVC_VERSION_2019)
+//included above:
+//#           include <charconv>
+#           define C4CORE_HAVE_STD_TOCHARS 1
+#           define C4CORE_HAVE_STD_FROMCHARS 1
+#       else
+#           define C4CORE_HAVE_STD_TOCHARS 0
+#           define C4CORE_HAVE_STD_FROMCHARS 0
+#       endif
+#   else  // VS2017 and lower do not have these macros
+#       if __has_include(<charconv>) && __cpp_lib_to_chars
+#           define C4CORE_HAVE_STD_TOCHARS 1
+#           define C4CORE_HAVE_STD_FROMCHARS 1
+//included above:
+//#           include <charconv>
+#       else
+#           define C4CORE_HAVE_STD_TOCHARS 0
+#           define C4CORE_HAVE_STD_FROMCHARS 0
+#       endif
+#   endif
+#else
+#   define C4CORE_HAVE_STD_TOCHARS 0
+#   define C4CORE_HAVE_STD_FROMCHARS 0
+#endif
+
+
+#if !C4CORE_HAVE_STD_FROMCHARS && !defined(C4CORE_HAVE_FAST_FLOAT)
+#include <cstdio>
+#endif
+
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   if C4_MSVC_VERSION != C4_MSVC_VERSION_2017
+#       pragma warning(disable: 4800) //'int': forcing value to bool 'true' or 'false' (performance warning)
+#   endif
+#   pragma warning(disable: 4996) // snprintf/scanf: this function or variable may be unsafe
+#elif defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
+#   pragma clang diagnostic ignored "-Wformat-nonliteral"
+#   pragma clang diagnostic ignored "-Wdouble-promotion" // implicit conversion increases floating-point precision
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#   pragma GCC diagnostic ignored "-Wdouble-promotion" // implicit conversion increases floating-point precision
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+
+
+namespace c4 {
+
+typedef enum : uint8_t {
+    /** print the real number in floating point format (like %f) */
+    FTOA_FLOAT = 0,
+    /** print the real number in scientific format (like %e) */
+    FTOA_SCIENT = 1,
+    /** print the real number in flexible format (like %g) */
+    FTOA_FLEX = 2,
+    /** print the real number in hexadecimal format (like %a) */
+    FTOA_HEXA = 3,
+    _FTOA_COUNT
+} RealFormat_e;
+
+
+inline C4_CONSTEXPR14 char to_c_fmt(RealFormat_e f)
+{
+    constexpr const char fmt[] = {
+        'f',  // FTOA_FLOAT
+        'e',  // FTOA_SCIENT
+        'g',  // FTOA_FLEX
+        'a',  // FTOA_HEXA
+    };
+    C4_STATIC_ASSERT(C4_COUNTOF(fmt) == _FTOA_COUNT);
+    #if C4_CPP > 14
+    C4_ASSERT(f < _FTOA_COUNT);
+    #endif
+    return fmt[f];
+}
+
+
+#if C4CORE_HAVE_STD_TOCHARS
+inline C4_CONSTEXPR14 std::chars_format to_std_fmt(RealFormat_e f)
+{
+    constexpr const std::chars_format fmt[] = {
+        std::chars_format::fixed,       // FTOA_FLOAT
+        std::chars_format::scientific,  // FTOA_SCIENT
+        std::chars_format::general,     // FTOA_FLEX
+        std::chars_format::hex,         // FTOA_HEXA
+    };
+    C4_STATIC_ASSERT(C4_COUNTOF(fmt) == _FTOA_COUNT);
+    #if C4_CPP >= 14
+    C4_ASSERT(f < _FTOA_COUNT);
+    #endif
+    return fmt[f];
+}
+#endif // C4CORE_HAVE_STD_TOCHARS
+
+/** in some platforms, int,unsigned int
+ *  are not any of int8_t...int64_t and
+ *  long,unsigned long are not any of uint8_t...uint64_t */
+template<class T>
+struct is_fixed_length
+{
+    enum : bool {
+        /** true if T is one of the fixed length signed types */
+        value_i = (std::is_integral<T>::value
+                   && (std::is_same<T, int8_t>::value
+                       || std::is_same<T, int16_t>::value
+                       || std::is_same<T, int32_t>::value
+                       || std::is_same<T, int64_t>::value)),
+        /** true if T is one of the fixed length unsigned types */
+        value_u = (std::is_integral<T>::value
+                   && (std::is_same<T, uint8_t>::value
+                       || std::is_same<T, uint16_t>::value
+                       || std::is_same<T, uint32_t>::value
+                       || std::is_same<T, uint64_t>::value)),
+        /** true if T is one of the fixed length signed or unsigned types */
+        value = value_i || value_u
+    };
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#elif defined(__clang__)
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wconversion"
+#   if __GNUC__ >= 6
+#       pragma GCC diagnostic ignored "-Wnull-dereference"
+#   endif
+#endif
+
+// Helper macros, undefined below
+
+#define _c4append(c) { if(C4_LIKELY(pos < buf.len)) { buf.str[pos++] = static_cast<char>(c); } else { ++pos; } }
+#define _c4appendhex(i) { if(C4_LIKELY(pos < buf.len)) { buf.str[pos++] = hexchars[i]; } else { ++pos; } }
+
+}
+#include <iostream>
+namespace c4 {
+C4_INLINE_CONSTEXPR const char hexchars[] = "0123456789abcdef";
+
+/** write an integer to a string in decimal format. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @return the number of characters required for the string,
+ * even if the string is not long enough for the result.
+ * No writes are done past the end of the string. */
+template<class T>
+size_t write_dec(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    size_t pos = 0;
+    do {
+        _c4append('0' + (v % T(10)));
+        v /= T(10);
+    } while(v);
+    buf.reverse_range(0, pos <= buf.len ? pos : buf.len);
+    return pos;
+}
+
+
+/** write an integer to a string in hexadecimal format. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @return the number of characters required for the string,
+ * even if the string is not long enough for the result.
+ * No writes are done past the end of the string. */
+template<class T>
+size_t write_hex(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    size_t pos = 0;
+    do {
+        _c4appendhex(v & T(15));
+        v >>= 4;
+    } while(v);
+    buf.reverse_range(0, pos <= buf.len ? pos : buf.len);
+    return pos;
+}
+
+/** write an integer to a string in octal format. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note does not prefix with 0o
+ * @return the number of characters required for the string,
+ * even if the string is not long enough for the result.
+ * No writes are done past the end of the string. */
+template<class T>
+size_t write_oct(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    size_t pos = 0;
+    do {
+        _c4append('0' + (v & T(7)));
+        v >>= 3;
+    } while(v);
+    buf.reverse_range(0, pos <= buf.len ? pos : buf.len);
+    return pos;
+}
+
+/** write an integer to a string in binary format. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note does not prefix with 0b
+ * @return the number of characters required for the string,
+ * even if the string is not long enough for the result.
+ * No writes are done past the end of the string. */
+template<class T>
+size_t write_bin(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    size_t pos = 0;
+    do {
+        _c4append('0' + (v & T(1)));
+        v >>= 1;
+    } while(v);
+    buf.reverse_range(0, pos <= buf.len ? pos : buf.len);
+    return pos;
+}
+
+
+namespace detail {
+template<class U> using NumberWriter = size_t (*)(substr, U);
+/** @todo pass the writer as a template parameter */
+template<class T, NumberWriter<T> writer>
+size_t write_num_digits(substr buf, T v, size_t num_digits)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    size_t ret = writer(buf, v);
+    if(ret >= num_digits)
+        return ret;
+    else if(ret >= buf.len || num_digits > buf.len)
+        return num_digits;
+    C4_ASSERT(num_digits >= ret);
+    size_t delta = static_cast<size_t>(num_digits - ret);
+    memmove(buf.str + delta, buf.str, ret);
+    memset(buf.str, '0', delta);
+    return num_digits;
+}
+} // namespace detail
+
+
+/** same as c4::write_dec(), but pad with zeroes on the left
+ * such that the resulting string is @p num_digits wide.
+ * If the given number is wider than num_digits, then the number prevails. */
+template<class T>
+size_t write_dec(substr buf, T val, size_t num_digits)
+{
+    return detail::write_num_digits<T, &write_dec<T>>(buf, val, num_digits);
+}
+
+/** same as c4::write_hex(), but pad with zeroes on the left
+ * such that the resulting string is @p num_digits wide.
+ * If the given number is wider than num_digits, then the number prevails. */
+template<class T>
+size_t write_hex(substr buf, T val, size_t num_digits)
+{
+    return detail::write_num_digits<T, &write_hex<T>>(buf, val, num_digits);
+}
+
+/** same as c4::write_bin(), but pad with zeroes on the left
+ * such that the resulting string is @p num_digits wide.
+ * If the given number is wider than num_digits, then the number prevails. */
+template<class T>
+size_t write_bin(substr buf, T val, size_t num_digits)
+{
+    return detail::write_num_digits<T, &write_bin<T>>(buf, val, num_digits);
+}
+
+/** same as c4::write_oct(), but pad with zeroes on the left
+ * such that the resulting string is @p num_digits wide.
+ * If the given number is wider than num_digits, then the number prevails. */
+template<class T>
+size_t write_oct(substr buf, T val, size_t num_digits)
+{
+    return detail::write_num_digits<T, &write_oct<T>>(buf, val, num_digits);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** read a decimal integer from a string. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note The string must be trimmed. Whitespace is not accepted.
+ * @return true if the conversion was successful */
+template<class I>
+C4_ALWAYS_INLINE bool read_dec(csubstr s, I *C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    *v = 0;
+    for(char c : s)
+    {
+        if(C4_UNLIKELY(c < '0' || c > '9'))
+            return false;
+        *v = (*v) * I(10) + (I(c) - I('0'));
+    }
+    return true;
+}
+
+/** read an hexadecimal integer from a string. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note does not accept leading 0x or 0X
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @return true if the conversion was successful */
+template<class I>
+C4_ALWAYS_INLINE bool read_hex(csubstr s, I *C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    *v = 0;
+    for(char c : s)
+    {
+        I cv;
+        if(c >= '0' && c <= '9')
+            cv = I(c) - I('0');
+        else if(c >= 'a' && c <= 'f')
+            cv = I(10) + (I(c) - I('a'));
+        else if(c >= 'A' && c <= 'F')
+            cv = I(10) + (I(c) - I('A'));
+        else
+            return false;
+        *v = (*v) * I(16) + cv;
+    }
+    return true;
+}
+
+/** read a binary integer from a string. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note does not accept leading 0b or 0B
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @return true if the conversion was successful */
+template<class I>
+C4_ALWAYS_INLINE bool read_bin(csubstr s, I *C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    *v = 0;
+    for(char c : s)
+    {
+        *v <<= 1;
+        if(c == '1')
+            *v |= 1;
+        else if(c != '0')
+            return false;
+    }
+    return true;
+}
+
+/** read an octal integer from a string. This is the
+ * lowest level (and the fastest) function to do this task.
+ * @note does not accept negative numbers
+ * @note does not accept leading 0o or 0O
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @return true if the conversion was successful */
+template<class I>
+C4_ALWAYS_INLINE bool read_oct(csubstr s, I *C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    *v = 0;
+    for(char c : s)
+    {
+        if(C4_UNLIKELY(c < '0' || c > '7'))
+            return false;
+        *v = (*v) * I(8) + (I(c) - I('0'));
+    }
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+// do not use the type as the template argument because in some
+// platforms long!=int32 and long!=int64. Just use the numbytes
+// which is more generic and spares lengthy SFINAE code.
+template<size_t numbytes> struct itoa_min;
+template<> struct itoa_min<1>
+{
+    static csubstr value_dec() { return csubstr("128"); }
+    static csubstr value_hex() { return csubstr("80"); }
+    static csubstr value_oct() { return csubstr("200"); }
+    static csubstr value_bin() { return csubstr("10000000"); }
+};
+template<> struct itoa_min<2>
+{
+    static csubstr value_dec() { return csubstr("32768"); }
+    static csubstr value_hex() { return csubstr("8000"); }
+    static csubstr value_oct() { return csubstr("100000"); }
+    static csubstr value_bin() { return csubstr("1000000000000000"); }
+};
+template<> struct itoa_min<4>
+{
+    static csubstr value_dec() { return csubstr("2147483648"); }
+    static csubstr value_hex() { return csubstr("80000000"); }
+    static csubstr value_oct() { return csubstr("20000000000"); }
+    static csubstr value_bin() { return csubstr("10000000000000000000000000000000"); }
+};
+template<> struct itoa_min<8>
+{
+    static csubstr value_dec() { return csubstr("9223372036854775808"); }
+    static csubstr value_hex() { return csubstr("8000000000000000"); }
+    static csubstr value_oct() { return csubstr("1000000000000000000000"); }
+    static csubstr value_bin() { return csubstr("1000000000000000000000000000000000000000000000000000000000000000"); }
+};
+inline size_t _itoa2buf(substr buf, size_t pos, csubstr val)
+{
+    if(C4_LIKELY(pos + val.len <= buf.len))
+        memcpy(buf.str + pos, val.str, val.len);
+    return pos + val.len;
+}
+inline size_t _itoa2bufwithdigits(substr buf, size_t pos, size_t num_digits, csubstr val)
+{
+    num_digits = num_digits > val.len ? num_digits - val.len : 0;
+    for(size_t i = 0; i < num_digits; ++i)
+        _c4append('0');
+    return _itoa2buf(buf, pos, val);
+}
+template<class T>
+size_t _itoadec2buf(substr buf)
+{
+    if(C4_LIKELY(buf.len > 0))
+    {
+        buf.str[0] = '-';
+        return detail::_itoa2buf(buf, 1, detail::itoa_min<sizeof(T)>::value_dec());
+    }
+    else
+    {
+        return detail::_itoa2buf({}, 1, detail::itoa_min<sizeof(T)>::value_dec());
+    }
+    C4_UNREACHABLE();
+}
+template<class I>
+size_t _itoa2buf(substr buf, I radix)
+{
+    size_t pos = 0;
+    _c4append('-');
+    switch(radix)
+    {
+    case I(10):
+        /*...........................*/ return _itoa2buf(buf, pos, itoa_min<sizeof(I)>::value_dec());
+    case I(16):
+        _c4append('0'); _c4append('x'); return _itoa2buf(buf, pos, itoa_min<sizeof(I)>::value_hex());
+    case I( 2):
+        _c4append('0'); _c4append('b'); return _itoa2buf(buf, pos, itoa_min<sizeof(I)>::value_bin());
+    case I( 8):
+        _c4append('0'); _c4append('o'); return _itoa2buf(buf, pos, itoa_min<sizeof(I)>::value_oct());
+    }
+    C4_ERROR("unknown radix");
+    return 0;
+}
+template<class I>
+size_t _itoa2buf(substr buf, I radix, size_t num_digits)
+{
+    size_t pos = 0;
+    _c4append('-');
+    switch(radix)
+    {
+    case I(10):
+        /*...........................*/ return _itoa2bufwithdigits(buf, pos, num_digits, itoa_min<sizeof(I)>::value_dec());
+    case I(16):
+        _c4append('0'); _c4append('x'); return _itoa2bufwithdigits(buf, pos, num_digits, itoa_min<sizeof(I)>::value_hex());
+    case I( 2):
+        _c4append('0'); _c4append('b'); return _itoa2bufwithdigits(buf, pos, num_digits, itoa_min<sizeof(I)>::value_bin());
+    case I( 8):
+        _c4append('0'); _c4append('o'); return _itoa2bufwithdigits(buf, pos, num_digits, itoa_min<sizeof(I)>::value_oct());
+    }
+    C4_ERROR("unknown radix");
+    return 0;
+}
+} // namespace detail
+
+
+/** convert an integral signed decimal to a string.
+ * The resulting string is NOT zero-terminated.
+ * Writing stops at the buffer's end.
+ * @return the number of characters needed for the result, even if the buffer size is insufficient */
+template<class T>
+size_t itoa(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    if(v >= 0)
+    {
+        return write_dec(buf, v);
+    }
+    else
+    {
+        if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+        {
+            if(C4_LIKELY(buf.len > 0))
+            {
+                buf.str[0] = '-';
+                return size_t(1) + write_dec(buf.sub(1), -v);
+            }
+            else
+            {
+                return size_t(1) + write_dec({}, -v);
+            }
+            C4_UNREACHABLE();
+        }
+        else
+        {
+            // when T is the min value (eg i8: -128), negating it
+            // will overflow. so we just use the explicit value
+            return detail::_itoadec2buf<T>(buf);
+        }
+        C4_UNREACHABLE();
+    }
+    C4_UNREACHABLE();
+}
+
+/** convert an integral signed integer to a string, using a specific
+ * radix. The radix must be 2, 8, 10 or 16.
+ *
+ * The resulting string is NOT zero-terminated.
+ * Writing stops at the buffer's end.
+ * @return the number of characters needed for the result, even if the buffer size is insufficient */
+template<class T>
+size_t itoa(substr buf, T v, T radix)
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow
+    if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+    {
+        size_t pos = 0;
+        if(v < 0)
+        {
+            v = -v;
+            _c4append('-');
+        }
+        switch(radix)
+        {
+        case 10:
+            /*............................*/return pos + write_dec(pos < buf.len ? buf.sub(pos) : substr(), v);
+        case 16:
+            _c4append('0'); _c4append('x'); return pos + write_hex(pos < buf.len ? buf.sub(pos) : substr(), v);
+        case 2:
+            _c4append('0'); _c4append('b'); return pos + write_bin(pos < buf.len ? buf.sub(pos) : substr(), v);
+        case 8:
+            _c4append('0'); _c4append('o'); return pos + write_oct(pos < buf.len ? buf.sub(pos) : substr(), v);
+        }
+    }
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow
+    return detail::_itoa2buf<T>(buf, radix);
+}
+
+
+/** same as c4::itoa(), but pad with zeroes on the left such that the
+ * resulting string is @p num_digits wide. The @p radix must be 2,
+ * 8, 10 or 16.  The resulting string is NOT zero-terminated.  Writing
+ * stops at the buffer's end.
+ *
+ * @return the number of characters needed for the result, even if
+ * the buffer size is insufficient */
+template<class T>
+size_t itoa(substr buf, T v, T radix, size_t num_digits)
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
+    if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+    {
+        size_t pos = 0;
+        if(v < 0)
+        {
+            v = -v;
+            _c4append('-');
+        }
+        switch(radix)
+        {
+        case 10:
+            /*............................*/return pos + write_dec(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+        case 16:
+            _c4append('0'); _c4append('x'); return pos + write_hex(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+        case 2:
+            _c4append('0'); _c4append('b'); return pos + write_bin(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+        case 8:
+            _c4append('0'); _c4append('o'); return pos + write_oct(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+        }
+    }
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow
+    return detail::_itoa2buf<T>(buf, radix, num_digits);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** convert an integral unsigned decimal to a string.
+ * The resulting string is NOT zero-terminated.
+ * Writing stops at the buffer's end.
+ * @return the number of characters needed for the result, even if the buffer size is insufficient */
+template<class T>
+size_t utoa(substr buf, T v)
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    return write_dec(buf, v);
+}
+
+/** convert an integral unsigned integer to a string, using a specific radix. The radix must be 2, 8, 10 or 16.
+ * The resulting string is NOT zero-terminated.
+ * Writing stops at the buffer's end.
+ * @return the number of characters needed for the result, even if the buffer size is insufficient */
+template<class T>
+size_t utoa(substr buf, T v, T radix)
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
+    size_t pos = 0;
+    switch(radix)
+    {
+    case 10:
+        /*............................*/return pos + write_dec(pos < buf.len ? buf.sub(pos) : substr(), v);
+    case 16:
+        _c4append('0'); _c4append('x'); return pos + write_hex(pos < buf.len ? buf.sub(pos) : substr(), v);
+    case 2:
+        _c4append('0'); _c4append('b'); return pos + write_bin(pos < buf.len ? buf.sub(pos) : substr(), v);
+    case 8:
+        _c4append('0'); _c4append('o'); return pos + write_oct(pos < buf.len ? buf.sub(pos) : substr(), v);
+    }
+    C4_UNREACHABLE();
+    return substr::npos;
+}
+
+/** same as c4::utoa(), but pad with zeroes on the left such that the
+ * resulting string is @p num_digits wide. The @p radix must be 2,
+ * 8, 10 or 16.  The resulting string is NOT zero-terminated.  Writing
+ * stops at the buffer's end.
+ *
+ * @return the number of characters needed for the result, even if
+ * the buffer size is insufficient */
+template<class T>
+size_t utoa(substr buf, T v, T radix, size_t num_digits)
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
+    size_t pos = 0;
+    switch(radix)
+    {
+    case 10:
+        /*............................*/return pos + write_dec(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+    case 16:
+        _c4append('0'); _c4append('x'); return pos + write_hex(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+    case 2:
+        _c4append('0'); _c4append('b'); return pos + write_bin(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+    case 8:
+        _c4append('0'); _c4append('o'); return pos + write_oct(pos < buf.len ? buf.sub(pos) : substr(), v, num_digits);
+    }
+    C4_UNREACHABLE();
+    return substr::npos;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** Convert a trimmed string to a signed integral value. The string
+ * can be formatted as decimal, binary (prefix 0b or 0B), octal
+ * (prefix 0o or 0O) or hexadecimal (prefix 0x or 0X). Strings with
+ * leading zeroes are considered as decimal. Every character in the
+ * input string is read for the conversion; it must not contain any
+ * leading or trailing whitespace.
+ *
+ * @return true if the conversion was successful.
+ *
+ * @note overflow is not detected: the return status is true even if
+ * the conversion would return a value outside of the type's range, in
+ * which case the result will wrap around the type's range.
+ * This is similar to native behavior.
+ *
+ * @see atoi_first() if the string is not trimmed to the value to read. */
+template<class T>
+bool atoi(csubstr str, T * C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+
+    if(C4_UNLIKELY(str.len == 0))
+        return false;
+
+    T sign = 1;
+    size_t start = 0;
+    if(str.str[0] == '-')
+    {
+        if(C4_UNLIKELY(str.len == 1))
+            return false;
+        ++start;
+        sign = -1;
+    }
+
+    if(str.str[start] != '0')
+    {
+        if(C4_UNLIKELY( ! read_dec(str.sub(start), v)))
+            return false;
+    }
+    else
+    {
+        if(str.len == start+1)
+        {
+            *v = 0; // because the first character is 0
+            return true;
+        }
+        else
+        {
+            char pfx = str.str[start+1];
+            if(pfx == 'x' || pfx == 'X') // hexadecimal
+            {
+                if(C4_UNLIKELY(str.len <= start + 2))
+                    return false;
+                if(C4_UNLIKELY( ! read_hex(str.sub(start + 2), v)))
+                    return false;
+            }
+            else if(pfx == 'b' || pfx == 'B') // binary
+            {
+                if(C4_UNLIKELY(str.len <= start + 2))
+                    return false;
+                if(C4_UNLIKELY( ! read_bin(str.sub(start + 2), v)))
+                    return false;
+            }
+            else if(pfx == 'o' || pfx == 'O') // octal
+            {
+                if(C4_UNLIKELY(str.len <= start + 2))
+                    return false;
+                if(C4_UNLIKELY( ! read_oct(str.sub(start + 2), v)))
+                    return false;
+            }
+            else
+            {
+                // we know the first character is 0
+                auto fno = str.first_not_of('0', start + 1);
+                if(fno == csubstr::npos)
+                {
+                    *v = 0;
+                    return true;
+                }
+                if(C4_UNLIKELY( ! read_dec(str.sub(fno), v)))
+                {
+                    return false;
+                }
+            }
+        }
+    }
+    *v *= sign;
+    return true;
+}
+
+
+/** Select the next range of characters in the string that can be parsed
+ * as a signed integral value, and convert it using atoi(). Leading
+ * whitespace (space, newline, tabs) is skipped.
+ * @return the number of characters read for conversion, or csubstr::npos if the conversion failed
+ * @see atoi() if the string is already trimmed to the value to read.
+ * @see csubstr::first_int_span() */
+template<class T>
+inline size_t atoi_first(csubstr str, T * C4_RESTRICT v)
+{
+    csubstr trimmed = str.first_int_span();
+    if(trimmed.len == 0)
+        return csubstr::npos;
+    if(atoi(trimmed, v))
+        return static_cast<size_t>(trimmed.end() - str.begin());
+    return csubstr::npos;
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** Convert a trimmed string to an unsigned integral value. The string can be
+ * formatted as decimal, binary (prefix 0b or 0B), octal (prefix 0o or 0O)
+ * or hexadecimal (prefix 0x or 0X). Every character in the input string is read
+ * for the conversion; it must not contain any leading or trailing whitespace.
+ *
+ * @return true if the conversion was successful.
+ *
+ * @note overflow is not detected: the return status is true even if
+ * the conversion would return a value outside of the type's range, in
+ * which case the result will wrap around the type's range.
+ *
+ * @note If the string has a minus character, the return status
+ * will be false.
+ *
+ * @see atou_first() if the string is not trimmed to the value to read. */
+template<class T>
+bool atou(csubstr str, T * C4_RESTRICT v)
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+
+    if(C4_UNLIKELY(str.len == 0 || str.front() == '-'))
+        return false;
+
+    if(str.str[0] != '0')
+    {
+        if(C4_UNLIKELY( ! read_dec(str, v)))
+            return false;
+    }
+    else
+    {
+        if(str.len == 1)
+        {
+            *v = 0; // we know the first character is 0
+            return true;
+        }
+        else
+        {
+            char pfx = str.str[1];
+            if(pfx == 'x' || pfx == 'X') // hexadecimal
+            {
+                if(C4_UNLIKELY(str.len <= 2))
+                    return false;
+                return read_hex(str.sub(2), v);
+            }
+            else if(pfx == 'b' || pfx == 'B') // binary
+            {
+                if(C4_UNLIKELY(str.len <= 2))
+                    return false;
+                return read_bin(str.sub(2), v);
+            }
+            else if(pfx == 'o' || pfx == 'O') // octal
+            {
+                if(C4_UNLIKELY(str.len <= 2))
+                    return false;
+                return read_oct(str.sub(2), v);
+            }
+            else
+            {
+                // we know the first character is 0
+                auto fno = str.first_not_of('0');
+                if(fno == csubstr::npos)
+                {
+                    *v = 0;
+                    return true;
+                }
+                return read_dec(str.sub(fno), v);
+            }
+        }
+    }
+    return true;
+}
+
+
+/** Select the next range of characters in the string that can be parsed
+ * as an unsigned integral value, and convert it using atou(). Leading
+ * whitespace (space, newline, tabs) is skipped.
+ * @return the number of characters read for conversion, or csubstr::npos if the conversion faileds
+ * @see atou() if the string is already trimmed to the value to read.
+ * @see csubstr::first_uint_span() */
+template<class T>
+inline size_t atou_first(csubstr str, T *v)
+{
+    csubstr trimmed = str.first_uint_span();
+    if(trimmed.len == 0)
+        return csubstr::npos;
+    if(atou(trimmed, v))
+        return static_cast<size_t>(trimmed.end() - str.begin());
+    return csubstr::npos;
+}
+
+
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+
+
+/** @see http://www.exploringbinary.com/ for many good examples on float-str conversion */
+template<size_t N>
+void get_real_format_str(char (& C4_RESTRICT fmt)[N], int precision, RealFormat_e formatting, const char* length_modifier="")
+{
+    int iret;
+    if(precision == -1)
+        iret = snprintf(fmt, sizeof(fmt), "%%%s%c", length_modifier, to_c_fmt(formatting));
+    else if(precision == 0)
+        iret = snprintf(fmt, sizeof(fmt), "%%.%s%c", length_modifier, to_c_fmt(formatting));
+    else
+        iret = snprintf(fmt, sizeof(fmt), "%%.%d%s%c", precision, length_modifier, to_c_fmt(formatting));
+    C4_ASSERT(iret >= 2 && size_t(iret) < sizeof(fmt));
+    C4_UNUSED(iret);
+}
+
+
+/** @todo we're depending on snprintf()/sscanf() for converting to/from
+ * floating point numbers. Apparently, this increases the binary size
+ * by a considerable amount. There are some lightweight printf
+ * implementations:
+ *
+ * @see http://www.sparetimelabs.com/tinyprintf/tinyprintf.php (BSD)
+ * @see https://github.com/weiss/c99-snprintf
+ * @see https://github.com/nothings/stb/blob/master/stb_sprintf.h
+ * @see http://www.exploringbinary.com/
+ * @see https://blog.benoitblanchon.fr/lightweight-float-to-string/
+ * @see http://www.ryanjuckett.com/programming/printing-floating-point-numbers/
+ */
+template<class T>
+size_t print_one(substr str, const char* full_fmt, T v)
+{
+#ifdef _MSC_VER
+    /** use _snprintf() to prevent early termination of the output
+     * for writing the null character at the last position
+     * @see https://msdn.microsoft.com/en-us/library/2ts7cx93.aspx */
+    int iret = _snprintf(str.str, str.len, full_fmt, v);
+    if(iret < 0)
+    {
+        /* when buf.len is not enough, VS returns a negative value.
+         * so call it again with a negative value for getting an
+         * actual length of the string */
+        iret = snprintf(nullptr, 0, full_fmt, v);
+        C4_ASSERT(iret > 0);
+    }
+    size_t ret = (size_t) iret;
+    return ret;
+#else
+    int iret = snprintf(str.str, str.len, full_fmt, v);
+    C4_ASSERT(iret >= 0);
+    size_t ret = (size_t) iret;
+    if(ret >= str.len)
+        ++ret; /* snprintf() reserves the last character to write \0 */
+    return ret;
+#endif
+}
+
+#if !C4CORE_HAVE_STD_FROMCHARS && !defined(C4CORE_HAVE_FAST_FLOAT)
+/** scans a string using the given type format, while at the same time
+ * allowing non-null-terminated strings AND guaranteeing that the given
+ * string length is strictly respected, so that no buffer overflows
+ * might occur. */
+template<typename T>
+inline size_t scan_one(csubstr str, const char *type_fmt, T *v)
+{
+    /* snscanf() is absolutely needed here as we must be sure that
+     * str.len is strictly respected, because substr is
+     * generally not null-terminated.
+     *
+     * Alas, there is no snscanf().
+     *
+     * So we fake it by using a dynamic format with an explicit
+     * field size set to the length of the given span.
+     * This trick is taken from:
+     * https://stackoverflow.com/a/18368910/5875572 */
+
+    /* this is the actual format we'll use for scanning */
+    char fmt[16];
+
+    /* write the length into it. Eg "%12f".
+     * Also, get the number of characters read from the string.
+     * So the final format ends up as "%12f%n"*/
+    int iret = std::snprintf(fmt, sizeof(fmt), "%%" "%zu" "%s" "%%n", str.len, type_fmt);
+    /* no nasty surprises, please! */
+    C4_ASSERT(iret >= 0 && size_t(iret) < C4_COUNTOF(fmt));
+
+    /* now we scan with confidence that the span length is respected */
+    int num_chars;
+    iret = std::sscanf(str.str, fmt, v, &num_chars);
+    /* scanf returns the number of successful conversions */
+    if(iret != 1) return csubstr::npos;
+    C4_ASSERT(num_chars >= 0);
+    return (size_t)(num_chars);
+}
+#endif
+
+
+#if C4CORE_HAVE_STD_TOCHARS
+template<class T>
+size_t rtoa(substr buf, T v, int precision=-1, RealFormat_e formatting=FTOA_FLEX)
+{
+    std::to_chars_result result;
+    size_t pos = 0;
+    if(formatting == FTOA_HEXA)
+    {
+        _c4append('0');
+        _c4append('x');
+    }
+    if(precision == -1)
+        result = std::to_chars(buf.str + pos, buf.str + buf.len, v, to_std_fmt(formatting));
+    else
+        result = std::to_chars(buf.str + pos, buf.str + buf.len, v, to_std_fmt(formatting), precision);
+    if(result.ec == std::errc())
+    {
+        // all good, no errors.
+        C4_ASSERT(result.ptr >= buf.str);
+        ptrdiff_t delta = result.ptr - buf.str;
+        return static_cast<size_t>(delta);
+    }
+    C4_ASSERT(result.ec == std::errc::value_too_large);
+    // This is unfortunate.
+    //
+    // When the result can't fit in the given buffer,
+    // std::to_chars() returns the end pointer it was originally
+    // given, which is useless because here we would like to know
+    // _exactly_ how many characters the buffer must have to fit
+    // the result.
+    //
+    // So we take the pessimistic view, and assume as many digits
+    // as could ever be required:
+    size_t ret = static_cast<size_t>(std::numeric_limits<T>::max_digits10);
+    return ret > buf.len ? ret : buf.len + 1;
+}
+#endif // C4CORE_HAVE_STD_TOCHARS
+
+} // namespace detail
+
+
+#undef _c4appendhex
+#undef _c4append
+
+
+/** Convert a single-precision real number to string.
+ * The string will in general be NOT null-terminated.
+ * For FTOA_FLEX, \p precision is the number of significand digits. Otherwise
+ * \p precision is the number of decimals. */
+inline size_t ftoa(substr str, float v, int precision=-1, RealFormat_e formatting=FTOA_FLEX)
+{
+#if C4CORE_HAVE_STD_TOCHARS
+    return detail::rtoa(str, v, precision, formatting);
+#else
+    char fmt[16];
+    detail::get_real_format_str(fmt, precision, formatting, /*length_modifier*/"");
+    return detail::print_one(str, fmt, v);
+#endif
+}
+
+
+/** Convert a double-precision real number to string.
+ * The string will in general be NOT null-terminated.
+ * For FTOA_FLEX, \p precision is the number of significand digits. Otherwise
+ * \p precision is the number of decimals.
+ *
+ * @return the number of characters written.
+ */
+inline size_t dtoa(substr str, double v, int precision=-1, RealFormat_e formatting=FTOA_FLEX)
+{
+#if C4CORE_HAVE_STD_TOCHARS
+    return detail::rtoa(str, v, precision, formatting);
+#else
+    char fmt[16];
+    detail::get_real_format_str(fmt, precision, formatting, /*length_modifier*/"l");
+    return detail::print_one(str, fmt, v);
+#endif
+}
+
+
+/** Convert a string to a single precision real number.
+ * The input string must be trimmed to the value, ie
+ * no leading or trailing whitespace can be present.
+ * @return true iff the conversion succeeded
+ * @see atof_first() if the string is not trimmed
+ */
+inline bool atof(csubstr str, float * C4_RESTRICT v)
+{
+    C4_ASSERT(str.triml(" \r\t\n").len == str.len);
+#if C4CORE_HAVE_FAST_FLOAT
+    fast_float::from_chars_result result;
+    result = fast_float::from_chars(str.str, str.str + str.len, *v);
+    return result.ec == std::errc();
+#elif C4CORE_HAVE_STD_FROMCHARS
+    std::from_chars_result result;
+    result = std::from_chars(str.str, str.str + str.len, *v);
+    return result.ec == std::errc();
+#else
+    size_t ret = detail::scan_one(str, "f", v);
+    return ret != csubstr::npos;
+#endif
+}
+
+
+/** Convert a string to a double precision real number.
+ * The input string must be trimmed to the value, ie
+ * no leading or trailing whitespace can be present.
+ * @return true iff the conversion succeeded
+ * @see atod_first() if the string is not trimmed
+ */
+inline bool atod(csubstr str, double * C4_RESTRICT v)
+{
+    C4_ASSERT(str.triml(" \r\t\n").len == str.len);
+#if C4CORE_HAVE_FAST_FLOAT
+    fast_float::from_chars_result result;
+    result = fast_float::from_chars(str.str, str.str + str.len, *v);
+    return result.ec == std::errc();
+#elif C4CORE_HAVE_STD_FROMCHARS
+    std::from_chars_result result;
+    result = std::from_chars(str.str, str.str + str.len, *v);
+    return result.ec == std::errc();
+#else
+    size_t ret = detail::scan_one(str, "lf", v);
+    return ret != csubstr::npos;
+#endif
+}
+
+
+/** Convert a string to a single precision real number.
+ * Leading whitespace is skipped until valid characters are found.
+ * @return the number of characters read from the string, or npos if
+ * conversion was not successful or if the string was empty */
+inline size_t atof_first(csubstr str, float * C4_RESTRICT v)
+{
+    csubstr trimmed = str.first_real_span();
+    if(trimmed.len == 0)
+        return csubstr::npos;
+    if(atof(trimmed, v))
+        return static_cast<size_t>(trimmed.end() - str.begin());
+    return csubstr::npos;
+}
+
+
+/** Convert a string to a double precision real number.
+ * Leading whitespace is skipped until valid characters are found.
+ * @return the number of characters read from the string, or npos if
+ * conversion was not successful or if the string was empty */
+inline size_t atod_first(csubstr str, double * C4_RESTRICT v)
+{
+    csubstr trimmed = str.first_real_span();
+    if(trimmed.len == 0)
+        return csubstr::npos;
+    if(atod(trimmed, v))
+        return static_cast<size_t>(trimmed.end() - str.begin());
+    return csubstr::npos;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// generic versions
+
+C4_ALWAYS_INLINE size_t xtoa(substr s,  uint8_t v) { return utoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint16_t v) { return utoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint32_t v) { return utoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint64_t v) { return utoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   int8_t v) { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int16_t v) { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int32_t v) { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int64_t v) { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,    float v) { return ftoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   double v) { return dtoa(s, v); }
+
+C4_ALWAYS_INLINE bool atox(csubstr s,  uint8_t *C4_RESTRICT v) { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint16_t *C4_RESTRICT v) { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint32_t *C4_RESTRICT v) { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint64_t *C4_RESTRICT v) { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,   int8_t *C4_RESTRICT v) { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int16_t *C4_RESTRICT v) { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int32_t *C4_RESTRICT v) { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int64_t *C4_RESTRICT v) { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,    float *C4_RESTRICT v) { return atof(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,   double *C4_RESTRICT v) { return atod(s, v); }
+
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  uint8_t v) { return utoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint16_t v) { return utoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint32_t v) { return utoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint64_t v) { return utoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,   int8_t v) { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int16_t v) { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int32_t v) { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int64_t v) { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,    float v) { return ftoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,   double v) { return dtoa(buf, v); }
+
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  uint8_t *C4_RESTRICT v) { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint16_t *C4_RESTRICT v) { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint32_t *C4_RESTRICT v) { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint64_t *C4_RESTRICT v) { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,   int8_t *C4_RESTRICT v) { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int16_t *C4_RESTRICT v) { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int32_t *C4_RESTRICT v) { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int64_t *C4_RESTRICT v) { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,    float *C4_RESTRICT v) { return atof(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,   double *C4_RESTRICT v) { return atod(buf, v); }
+
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  uint8_t *C4_RESTRICT v) { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint16_t *C4_RESTRICT v) { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint32_t *C4_RESTRICT v) { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint64_t *C4_RESTRICT v) { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,   int8_t *C4_RESTRICT v) { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int16_t *C4_RESTRICT v) { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int32_t *C4_RESTRICT v) { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int64_t *C4_RESTRICT v) { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,    float *C4_RESTRICT v) { return atof_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,   double *C4_RESTRICT v) { return atod_first(buf, v); }
+
+
+//-----------------------------------------------------------------------------
+// on some platforms, (unsigned) int and (unsigned) long
+// are not any of the fixed length types above
+
+#define _C4_IF_NOT_FIXED_LENGTH_I(T, ty) C4_ALWAYS_INLINE typename std::enable_if<std::  is_signed<T>::value && !is_fixed_length<T>::value_i, ty>
+#define _C4_IF_NOT_FIXED_LENGTH_U(T, ty) C4_ALWAYS_INLINE typename std::enable_if<std::is_unsigned<T>::value && !is_fixed_length<T>::value_u, ty>
+
+template <class T> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type xtoa(substr buf, T v) { return itoa(buf, v); }
+template <class T> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type xtoa(substr buf, T v) { return utoa(buf, v); }
+
+template <class T> _C4_IF_NOT_FIXED_LENGTH_I(T, bool  )::type atox(csubstr buf, T *C4_RESTRICT v) { return atoi(buf, v); }
+template <class T> _C4_IF_NOT_FIXED_LENGTH_U(T, bool  )::type atox(csubstr buf, T *C4_RESTRICT v) { return atou(buf, v); }
+
+template <class T> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type to_chars(substr buf, T v) { return itoa(buf, v); }
+template <class T> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type to_chars(substr buf, T v) { return utoa(buf, v); }
+
+template <class T> _C4_IF_NOT_FIXED_LENGTH_I(T, bool  )::type from_chars(csubstr buf, T *C4_RESTRICT v) { return atoi(buf, v); }
+template <class T> _C4_IF_NOT_FIXED_LENGTH_U(T, bool  )::type from_chars(csubstr buf, T *C4_RESTRICT v) { return atou(buf, v); }
+
+template <class T> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type from_chars_first(csubstr buf, T *C4_RESTRICT v) { return atoi_first(buf, v); }
+template <class T> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type from_chars_first(csubstr buf, T *C4_RESTRICT v) { return atou_first(buf, v); }
+
+#undef _C4_IF_NOT_FIXED_LENGTH_I
+#undef _C4_IF_NOT_FIXED_LENGTH_U
+
+
+//-----------------------------------------------------------------------------
+// for pointers
+
+template <class T> C4_ALWAYS_INLINE size_t xtoa(substr s, T *v) { return itoa(s, (intptr_t)v, (intptr_t)16); }
+template <class T> C4_ALWAYS_INLINE bool   atox(csubstr s, T **v) { intptr_t tmp; bool ret = atox(s, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+template <class T> C4_ALWAYS_INLINE size_t to_chars(substr s, T *v) { return itoa(s, (intptr_t)v, (intptr_t)16); }
+template <class T> C4_ALWAYS_INLINE bool   from_chars(csubstr buf, T **v) { intptr_t tmp; bool ret = from_chars(buf, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+template <class T> C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, T **v) { intptr_t tmp; bool ret = from_chars_first(buf, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** call to_chars() and return a substr consisting of the
+ * written portion of the input buffer. Ie, same as to_chars(),
+ * but return a substr instead of a size_t.
+ *
+ * @see to_chars() */
+template<class T>
+inline substr to_chars_sub(substr buf, T const& C4_RESTRICT v)
+{
+    size_t sz = to_chars(buf, v);
+    return buf.left_of(sz <= buf.len ? sz : buf.len);
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// bool implementation
+
+inline size_t to_chars(substr buf, bool v)
+{
+    int val = v;
+    return to_chars(buf, val);
+}
+
+inline bool from_chars(csubstr buf, bool * C4_RESTRICT v)
+{
+    if(buf == '0')
+    {
+        *v = false; return true;
+    }
+    else if(buf == '1')
+    {
+        *v = true; return true;
+    }
+    else if(buf == "false")
+    {
+        *v = false; return true;
+    }
+    else if(buf == "true")
+    {
+        *v = true; return true;
+    }
+    else if(buf == "False")
+    {
+        *v = false; return true;
+    }
+    else if(buf == "True")
+    {
+        *v = true; return true;
+    }
+    else if(buf == "FALSE")
+    {
+        *v = false; return true;
+    }
+    else if(buf == "TRUE")
+    {
+        *v = true; return true;
+    }
+    // fallback to c-style int bools
+    int val = 0;
+    bool ret = from_chars(buf, &val);
+    if(C4_LIKELY(ret))
+    {
+        *v = (val != 0);
+    }
+    return ret;
+}
+
+inline size_t from_chars_first(csubstr buf, bool * C4_RESTRICT v)
+{
+    csubstr trimmed = buf.first_non_empty_span();
+    if(trimmed.len == 0 || !from_chars(buf, v))
+        return csubstr::npos;
+    return trimmed.len;
+}
+
+
+//-----------------------------------------------------------------------------
+// single-char implementation
+
+inline size_t to_chars(substr buf, char v)
+{
+    if(buf.len > 0)
+        buf[0] = v;
+    return 1;
+}
+
+/** extract a single character from a substring
+ * @note to extract a string instead and not just a single character, use the csubstr overload */
+inline bool from_chars(csubstr buf, char * C4_RESTRICT v)
+{
+    if(buf.len != 1)
+        return false;
+    *v = buf[0];
+    return true;
+}
+
+inline size_t from_chars_first(csubstr buf, char * C4_RESTRICT v)
+{
+    if(buf.len < 1)
+        return csubstr::npos;
+    *v = buf[0];
+    return 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// csubstr implementation
+
+inline size_t to_chars(substr buf, csubstr v)
+{
+    C4_ASSERT(!buf.overlaps(v));
+    size_t len = buf.len < v.len ? buf.len : v.len;
+    memcpy(buf.str, v.str, len);
+    return v.len;
+}
+
+inline bool from_chars(csubstr buf, csubstr *C4_RESTRICT v)
+{
+    *v = buf;
+    return true;
+}
+
+inline size_t from_chars_first(substr buf, csubstr * C4_RESTRICT v)
+{
+    csubstr trimmed = buf.first_non_empty_span();
+    if(trimmed.len == 0)
+        return csubstr::npos;
+    *v = trimmed;
+    return static_cast<size_t>(trimmed.end() - buf.begin());
+}
+
+
+//-----------------------------------------------------------------------------
+// substr
+
+inline size_t to_chars(substr buf, substr v)
+{
+    C4_ASSERT(!buf.overlaps(v));
+    size_t len = buf.len < v.len ? buf.len : v.len;
+    memcpy(buf.str, v.str, len);
+    return v.len;
+}
+
+inline bool from_chars(csubstr buf, substr * C4_RESTRICT v)
+{
+    C4_ASSERT(!buf.overlaps(*v));
+    if(buf.len <= v->len)
+    {
+        memcpy(v->str, buf.str, buf.len);
+        v->len = buf.len;
+        return true;
+    }
+    memcpy(v->str, buf.str, v->len);
+    return false;
+}
+
+inline size_t from_chars_first(csubstr buf, substr * C4_RESTRICT v)
+{
+    csubstr trimmed = buf.first_non_empty_span();
+    C4_ASSERT(!trimmed.overlaps(*v));
+    if(C4_UNLIKELY(trimmed.len == 0))
+        return csubstr::npos;
+    size_t len = trimmed.len > v->len ? v->len : trimmed.len;
+    memcpy(v->str, trimmed.str, len);
+    if(C4_UNLIKELY(trimmed.len > v->len))
+        return csubstr::npos;
+    return static_cast<size_t>(trimmed.end() - buf.begin());
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<size_t N>
+inline size_t to_chars(substr buf, const char (& C4_RESTRICT v)[N])
+{
+    csubstr sp(v);
+    return to_chars(buf, sp);
+}
+
+inline size_t to_chars(substr buf, const char * C4_RESTRICT v)
+{
+    return to_chars(buf, to_csubstr(v));
+}
+
+} // namespace c4
+
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* _C4_CHARCONV_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/charconv.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/utf.hpp
+// https://github.com/biojppm/c4core/src/c4/utf.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_UTF_HPP_
+#define C4_UTF_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr_fwd.hpp
+//#include "c4/substr_fwd.hpp"
+#if !defined(C4_SUBSTR_FWD_HPP_) && !defined(_C4_SUBSTR_FWD_HPP_)
+#error "amalgamate: file c4/substr_fwd.hpp must have been included at this point"
+#endif /* C4_SUBSTR_FWD_HPP_ */
+
+//included above:
+//#include <stddef.h>
+//included above:
+//#include <stdint.h>
+
+namespace c4 {
+
+substr decode_code_point(substr out, csubstr code_point);
+size_t decode_code_point(uint8_t *C4_RESTRICT buf, size_t buflen, const uint32_t code);
+
+} // namespace c4
+
+#endif // C4_UTF_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/utf.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/format.hpp
+// https://github.com/biojppm/c4core/src/c4/format.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_FORMAT_HPP_
+#define _C4_FORMAT_HPP_
+
+/** @file format.hpp provides type-safe facilities for formatting arguments
+ * to string buffers */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/charconv.hpp
+//#include "c4/charconv.hpp"
+#if !defined(C4_CHARCONV_HPP_) && !defined(_C4_CHARCONV_HPP_)
+#error "amalgamate: file c4/charconv.hpp must have been included at this point"
+#endif /* C4_CHARCONV_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/blob.hpp
+//#include "c4/blob.hpp"
+#if !defined(C4_BLOB_HPP_) && !defined(_C4_BLOB_HPP_)
+#error "amalgamate: file c4/blob.hpp must have been included at this point"
+#endif /* C4_BLOB_HPP_ */
+
+
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   if C4_MSVC_VERSION != C4_MSVC_VERSION_2017
+#       pragma warning(disable: 4800) // forcing value to bool 'true' or 'false' (performance warning)
+#   endif
+#   pragma warning(disable: 4996) // snprintf/scanf: this function or variable may be unsafe
+#elif defined(__clang__)
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+
+namespace c4 {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting truthy types as booleans
+
+namespace fmt {
+
+/** write a variable as an alphabetic boolean, ie as either true or false
+ * @param strict_read */
+template<class T>
+struct boolalpha_
+{
+    boolalpha_(T val_, bool strict_read_=false) : val(val_ ? true : false), strict_read(strict_read_) {}
+    bool val;
+    bool strict_read;
+};
+
+template<class T>
+boolalpha_<T> boolalpha(T const& val, bool strict_read=false)
+{
+    return boolalpha_<T>(val, strict_read);
+}
+
+} // namespace fmt
+
+/** write a variable as an alphabetic boolean, ie as either true or false */
+template<class T>
+inline size_t to_chars(substr buf, fmt::boolalpha_<T> fmt)
+{
+    return to_chars(buf, fmt.val ? "true" : "false");
+}
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting integral types
+
+namespace fmt {
+
+/** format an integral type with a custom radix */
+template<typename T>
+struct integral_
+{
+    T val;
+    T radix;
+    C4_ALWAYS_INLINE integral_(T val_, T radix_) : val(val_), radix(radix_) {}
+};
+
+/** format an integral type with a custom radix, and pad with zeroes on the left */
+template<typename T>
+struct integral_padded_
+{
+    T val;
+    T radix;
+    size_t num_digits;
+    C4_ALWAYS_INLINE integral_padded_(T val_, T radix_, size_t nd) : val(val_), radix(radix_), num_digits(nd) {}
+};
+
+/** format an integral type with a custom radix */
+template<class T>
+C4_ALWAYS_INLINE integral_<T> integral(T val, T radix=10)
+{
+    return integral_<T>(val, radix);
+}
+/** format an integral type with a custom radix */
+template<class T>
+C4_ALWAYS_INLINE integral_<intptr_t> integral(T const* val, T radix=10)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(val), static_cast<intptr_t>(radix));
+}
+/** format an integral type with a custom radix */
+template<class T>
+C4_ALWAYS_INLINE integral_<intptr_t> integral(std::nullptr_t, T radix=10)
+{
+    return integral_<intptr_t>(intptr_t(0), static_cast<intptr_t>(radix));
+}
+/** pad the argument with zeroes on the left, with decimal radix */
+template<class T>
+C4_ALWAYS_INLINE integral_padded_<T> zpad(T val, size_t num_digits)
+{
+    return integral_padded_<T>(val, T(10), num_digits);
+}
+/** pad the argument with zeroes on the left */
+template<class T>
+C4_ALWAYS_INLINE integral_padded_<T> zpad(integral_<T> val, size_t num_digits)
+{
+    return integral_padded_<T>(val.val, val.radix, num_digits);
+}
+/** pad the argument with zeroes on the left */
+C4_ALWAYS_INLINE integral_padded_<intptr_t> zpad(std::nullptr_t, size_t num_digits)
+{
+    return integral_padded_<intptr_t>(0, 16, num_digits);
+}
+/** pad the argument with zeroes on the left */
+template<class T>
+C4_ALWAYS_INLINE integral_padded_<intptr_t> zpad(T const* val, size_t num_digits)
+{
+    return integral_padded_<intptr_t>(reinterpret_cast<intptr_t>(val), 16, num_digits);
+}
+template<class T>
+C4_ALWAYS_INLINE integral_padded_<intptr_t> zpad(T * val, size_t num_digits)
+{
+    return integral_padded_<intptr_t>(reinterpret_cast<intptr_t>(val), 16, num_digits);
+}
+
+
+/** format the pointer as an hexadecimal value */
+template<class T>
+inline integral_<intptr_t> hex(T * v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(16));
+}
+/** format the pointer as an hexadecimal value */
+template<class T>
+inline integral_<intptr_t> hex(T const* v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(16));
+}
+/** format null as an hexadecimal value
+ * @overload hex */
+inline integral_<intptr_t> hex(std::nullptr_t)
+{
+    return integral_<intptr_t>(0, intptr_t(16));
+}
+/** format the integral_ argument as an hexadecimal value
+ * @overload hex */
+template<class T>
+inline integral_<T> hex(T v)
+{
+    return integral_<T>(v, T(16));
+}
+
+/** format the pointer as an octal value */
+template<class T>
+inline integral_<intptr_t> oct(T const* v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(8));
+}
+/** format the pointer as an octal value */
+template<class T>
+inline integral_<intptr_t> oct(T * v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(8));
+}
+/** format null as an octal value */
+inline integral_<intptr_t> oct(std::nullptr_t)
+{
+    return integral_<intptr_t>(intptr_t(0), intptr_t(8));
+}
+/** format the integral_ argument as an octal value */
+template<class T>
+inline integral_<T> oct(T v)
+{
+    return integral_<T>(v, T(8));
+}
+
+/** format the pointer as a binary 0-1 value
+ * @see c4::raw() if you want to use a binary memcpy instead of 0-1 formatting */
+template<class T>
+inline integral_<intptr_t> bin(T const* v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(2));
+}
+/** format the pointer as a binary 0-1 value
+ * @see c4::raw() if you want to use a binary memcpy instead of 0-1 formatting */
+template<class T>
+inline integral_<intptr_t> bin(T * v)
+{
+    return integral_<intptr_t>(reinterpret_cast<intptr_t>(v), intptr_t(2));
+}
+/** format null as a binary 0-1 value
+ * @see c4::raw() if you want to use a binary memcpy instead of 0-1 formatting */
+inline integral_<intptr_t> bin(std::nullptr_t)
+{
+    return integral_<intptr_t>(intptr_t(0), intptr_t(2));
+}
+/** format the integral_ argument as a binary 0-1 value
+ * @see c4::raw() if you want to use a binary memcpy instead of 0-1 formatting */
+template<class T>
+inline integral_<T> bin(T v)
+{
+    return integral_<T>(v, T(2));
+}
+
+} // namespace fmt
+
+
+/** format an integral_ signed type */
+template<typename T>
+C4_ALWAYS_INLINE
+typename std::enable_if<std::is_signed<T>::value, size_t>::type
+to_chars(substr buf, fmt::integral_<T> fmt)
+{
+    return itoa(buf, fmt.val, fmt.radix);
+}
+/** format an integral_ signed type, pad with zeroes */
+template<typename T>
+C4_ALWAYS_INLINE
+typename std::enable_if<std::is_signed<T>::value, size_t>::type
+to_chars(substr buf, fmt::integral_padded_<T> fmt)
+{
+    return itoa(buf, fmt.val, fmt.radix, fmt.num_digits);
+}
+
+/** format an integral_ unsigned type */
+template<typename T>
+C4_ALWAYS_INLINE
+typename std::enable_if<std::is_unsigned<T>::value, size_t>::type
+to_chars(substr buf, fmt::integral_<T> fmt)
+{
+    return utoa(buf, fmt.val, fmt.radix);
+}
+/** format an integral_ unsigned type, pad with zeroes */
+template<typename T>
+C4_ALWAYS_INLINE
+typename std::enable_if<std::is_unsigned<T>::value, size_t>::type
+to_chars(substr buf, fmt::integral_padded_<T> fmt)
+{
+    return utoa(buf, fmt.val, fmt.radix, fmt.num_digits);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting real types
+
+namespace fmt {
+
+template<class T>
+struct real_
+{
+    T val;
+    int precision;
+    RealFormat_e fmt;
+    real_(T v, int prec=-1, RealFormat_e f=FTOA_FLOAT) : val(v), precision(prec), fmt(f)  {}
+};
+
+template<class T>
+real_<T> real(T val, int precision, RealFormat_e fmt=FTOA_FLOAT)
+{
+    return real_<T>(val, precision, fmt);
+}
+
+} // namespace fmt
+
+inline size_t to_chars(substr buf, fmt::real_< float> fmt) { return ftoa(buf, fmt.val, fmt.precision, fmt.fmt); }
+inline size_t to_chars(substr buf, fmt::real_<double> fmt) { return dtoa(buf, fmt.val, fmt.precision, fmt.fmt); }
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// writing raw binary data
+
+namespace fmt {
+
+/** @see blob_ */
+template<class T>
+struct raw_wrapper_ : public blob_<T>
+{
+    size_t alignment;
+
+    C4_ALWAYS_INLINE raw_wrapper_(blob_<T> data, size_t alignment_) noexcept
+        :
+        blob_<T>(data),
+        alignment(alignment_)
+    {
+        C4_ASSERT_MSG(alignment > 0 && (alignment & (alignment - 1)) == 0, "alignment must be a power of two");
+    }
+};
+
+using const_raw_wrapper = raw_wrapper_<cbyte>;
+using raw_wrapper = raw_wrapper_<byte>;
+
+/** mark a variable to be written in raw binary format, using memcpy
+ * @see blob_ */
+inline const_raw_wrapper craw(cblob data, size_t alignment=alignof(max_align_t))
+{
+    return const_raw_wrapper(data, alignment);
+}
+/** mark a variable to be written in raw binary format, using memcpy
+ * @see blob_ */
+inline const_raw_wrapper raw(cblob data, size_t alignment=alignof(max_align_t))
+{
+    return const_raw_wrapper(data, alignment);
+}
+/** mark a variable to be written in raw binary format, using memcpy
+ * @see blob_ */
+template<class T>
+inline const_raw_wrapper craw(T const& C4_RESTRICT data, size_t alignment=alignof(T))
+{
+    return const_raw_wrapper(cblob(data), alignment);
+}
+/** mark a variable to be written in raw binary format, using memcpy
+ * @see blob_ */
+template<class T>
+inline const_raw_wrapper raw(T const& C4_RESTRICT data, size_t alignment=alignof(T))
+{
+    return const_raw_wrapper(cblob(data), alignment);
+}
+
+/** mark a variable to be read in raw binary format, using memcpy */
+inline raw_wrapper raw(blob data, size_t alignment=alignof(max_align_t))
+{
+    return raw_wrapper(data, alignment);
+}
+/** mark a variable to be read in raw binary format, using memcpy */
+template<class T>
+inline raw_wrapper raw(T & C4_RESTRICT data, size_t alignment=alignof(T))
+{
+    return raw_wrapper(blob(data), alignment);
+}
+
+} // namespace fmt
+
+
+/** write a variable in raw binary format, using memcpy */
+C4CORE_EXPORT size_t to_chars(substr buf, fmt::const_raw_wrapper r);
+
+/** read a variable in raw binary format, using memcpy */
+C4CORE_EXPORT bool from_chars(csubstr buf, fmt::raw_wrapper *r);
+/** read a variable in raw binary format, using memcpy */
+inline bool from_chars(csubstr buf, fmt::raw_wrapper r)
+{
+    return from_chars(buf, &r);
+}
+
+/** read a variable in raw binary format, using memcpy */
+inline size_t from_chars_first(csubstr buf, fmt::raw_wrapper *r)
+{
+    return from_chars(buf, r);
+}
+/** read a variable in raw binary format, using memcpy */
+inline size_t from_chars_first(csubstr buf, fmt::raw_wrapper r)
+{
+    return from_chars(buf, &r);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting aligned to left/right
+
+namespace fmt {
+
+template<class T>
+struct left_
+{
+    T val;
+    size_t width;
+    char pad;
+    left_(T v, size_t w, char p) : val(v), width(w), pad(p) {}
+};
+
+template<class T>
+struct right_
+{
+    T val;
+    size_t width;
+    char pad;
+    right_(T v, size_t w, char p) : val(v), width(w), pad(p) {}
+};
+
+/** mark an argument to be aligned left */
+template<class T>
+left_<T> left(T val, size_t width, char padchar=' ')
+{
+    return left_<T>(val, width, padchar);
+}
+
+/** mark an argument to be aligned right */
+template<class T>
+right_<T> right(T val, size_t width, char padchar=' ')
+{
+    return right_<T>(val, width, padchar);
+}
+
+} // namespace fmt
+
+
+template<class T>
+size_t to_chars(substr buf, fmt::left_<T> const& C4_RESTRICT align)
+{
+    size_t ret = to_chars(buf, align.val);
+    if(ret >= buf.len || ret >= align.width)
+        return ret > align.width ? ret : align.width;
+    buf.first(align.width).sub(ret).fill(align.pad);
+    to_chars(buf, align.val);
+    return align.width;
+}
+
+template<class T>
+size_t to_chars(substr buf, fmt::right_<T> const& C4_RESTRICT align)
+{
+    size_t ret = to_chars(buf, align.val);
+    if(ret >= buf.len || ret >= align.width)
+        return ret > align.width ? ret : align.width;
+    size_t rem = static_cast<size_t>(align.width - ret);
+    buf.first(rem).fill(align.pad);
+    to_chars(buf.sub(rem), align.val);
+    return align.width;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the variadic recursion
+inline size_t cat(substr /*buf*/)
+{
+    return 0;
+}
+/// @endcond
+
+
+/** serialize the arguments, concatenating them to the given fixed-size buffer.
+ * The buffer size is strictly respected: no writes will occur beyond its end.
+ * @return the number of characters needed to write all the arguments into the buffer.
+ * @see c4::catrs() if instead of a fixed-size buffer, a resizeable container is desired
+ * @see c4::uncat() for the inverse function
+ * @see c4::catsep() if a separator between each argument is to be used
+ * @see c4::format() if a format string is desired */
+template<class Arg, class... Args>
+size_t cat(substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t num = to_chars(buf, a);
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num += cat(buf, more...);
+    return num;
+}
+
+/** like c4::cat() but return a substr instead of a size */
+template<class... Args>
+substr cat_sub(substr buf, Args && ...args)
+{
+    size_t sz = cat(buf, std::forward<Args>(args)...);
+    C4_CHECK(sz <= buf.len);
+    return {buf.str, sz <= buf.len ? sz : buf.len};
+}
+
+
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the variadic recursion
+inline size_t uncat(csubstr /*buf*/)
+{
+    return 0;
+}
+/// @endcond
+
+
+/** deserialize the arguments from the given buffer.
+ *
+ * @return the number of characters read from the buffer, or csubstr::npos
+ *   if a conversion was not successful.
+ * @see c4::cat(). c4::uncat() is the inverse of c4::cat(). */
+template<class Arg, class... Args>
+size_t uncat(csubstr buf, Arg & C4_RESTRICT a, Args & C4_RESTRICT ...more)
+{
+    size_t out = from_chars_first(buf, &a);
+    if(C4_UNLIKELY(out == csubstr::npos))
+        return csubstr::npos;
+    buf  = buf.len >= out ? buf.sub(out) : substr{};
+    size_t num = uncat(buf, more...);
+    if(C4_UNLIKELY(num == csubstr::npos))
+        return csubstr::npos;
+    return out + num;
+}
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace detail {
+
+template<class Sep>
+inline size_t catsep_more(substr /*buf*/, Sep const& C4_RESTRICT /*sep*/)
+{
+    return 0;
+}
+
+template<class Sep, class Arg, class... Args>
+size_t catsep_more(substr buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t ret = to_chars(buf, sep), num = ret;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = to_chars(buf, a);
+    num += ret;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = catsep_more(buf, sep, more...);
+    num += ret;
+    return num;
+}
+
+template<class Sep>
+inline size_t uncatsep_more(csubstr /*buf*/, Sep & /*sep*/)
+{
+    return 0;
+}
+
+template<class Sep, class Arg, class... Args>
+size_t uncatsep_more(csubstr buf, Sep & C4_RESTRICT sep, Arg & C4_RESTRICT a, Args & C4_RESTRICT ...more)
+{
+    size_t ret = from_chars_first(buf, &sep), num = ret;
+    if(C4_UNLIKELY(ret == csubstr::npos))
+        return csubstr::npos;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = from_chars_first(buf, &a);
+    if(C4_UNLIKELY(ret == csubstr::npos))
+        return csubstr::npos;
+    num += ret;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = uncatsep_more(buf, sep, more...);
+    if(C4_UNLIKELY(ret == csubstr::npos))
+        return csubstr::npos;
+    num += ret;
+    return num;
+}
+
+} // namespace detail
+
+
+/** serialize the arguments, concatenating them to the given fixed-size
+ * buffer, using a separator between each argument.
+ * The buffer size is strictly respected: no writes will occur beyond its end.
+ * @return the number of characters needed to write all the arguments into the buffer.
+ * @see c4::catseprs() if instead of a fixed-size buffer, a resizeable container is desired
+ * @see c4::uncatsep() for the inverse function (ie, reading instead of writing)
+ * @see c4::cat() if no separator is needed
+ * @see c4::format() if a format string is desired */
+template<class Sep, class Arg, class... Args>
+size_t catsep(substr buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t num = to_chars(buf, a);
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num += detail::catsep_more(buf, sep, more...);
+    return num;
+}
+
+/** like c4::catsep() but return a substr instead of a size
+ * @see c4::catsep(). c4::uncatsep() is the inverse of c4::catsep(). */
+template<class... Args>
+substr catsep_sub(substr buf, Args && ...args)
+{
+    size_t sz = catsep(buf, std::forward<Args>(args)...);
+    C4_CHECK(sz <= buf.len);
+    return {buf.str, sz <= buf.len ? sz : buf.len};
+}
+
+/** deserialize the arguments from the given buffer, using a separator.
+ *
+ * @return the number of characters read from the buffer, or csubstr::npos
+ *   if a conversion was not successful
+ * @see c4::catsep(). c4::uncatsep() is the inverse of c4::catsep(). */
+template<class Sep, class Arg, class... Args>
+size_t uncatsep(csubstr buf, Sep & C4_RESTRICT sep, Arg & C4_RESTRICT a, Args & C4_RESTRICT ...more)
+{
+    size_t ret = from_chars_first(buf, &a), num = ret;
+    if(C4_UNLIKELY(ret == csubstr::npos))
+        return csubstr::npos;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = detail::uncatsep_more(buf, sep, more...);
+    if(C4_UNLIKELY(ret == csubstr::npos))
+        return csubstr::npos;
+    num += ret;
+    return num;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the variadic recursion
+inline size_t format(substr buf, csubstr fmt)
+{
+    return to_chars(buf, fmt);
+}
+/// @endcond
+
+
+/** using a format string, serialize the arguments into the given
+ * fixed-size buffer.
+ * The buffer size is strictly respected: no writes will occur beyond its end.
+ * In the format string, each argument is marked with a compact
+ * curly-bracket pair: {}. Arguments beyond the last curly bracket pair
+ * are silently ignored. For example:
+ * @code{.cpp}
+ * c4::format(buf, "the {} drank {} {}", "partier", 5, "beers"); // the partier drank 5 beers
+ * c4::format(buf, "the {} drank {} {}", "programmer", 6, "coffees"); // the programmer drank 6 coffees
+ * @endcode
+ * @return the number of characters needed to write into the buffer.
+ * @see c4::formatrs() if instead of a fixed-size buffer, a resizeable container is desired
+ * @see c4::unformat() for the inverse function
+ * @see c4::cat() if no format or separator is needed
+ * @see c4::catsep() if no format is needed, but a separator must be used */
+template<class Arg, class... Args>
+size_t format(substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    if(C4_UNLIKELY(pos == csubstr::npos))
+        return to_chars(buf, fmt);
+    size_t num = to_chars(buf, fmt.sub(0, pos));
+    size_t out = num;
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num  = to_chars(buf, a);
+    out += num;
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num  = format(buf, fmt.sub(pos + 2), more...);
+    out += num;
+    return out;
+}
+
+/** like c4::format() but return a substr instead of a size
+ * @see c4::format()
+ * @see c4::catsep(). uncatsep() is the inverse of catsep(). */
+template<class... Args>
+substr format_sub(substr buf, csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+    size_t sz = c4::format(buf, fmt, args...);
+    C4_CHECK(sz <= buf.len);
+    return {buf.str, sz <= buf.len ? sz : buf.len};
+}
+
+
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the variadic recursion
+inline size_t unformat(csubstr /*buf*/, csubstr fmt)
+{
+    return fmt.len;
+}
+/// @endcond
+
+
+/** using a format string, deserialize the arguments from the given
+ * buffer.
+ * @return the number of characters read from the buffer, or npos if a conversion failed.
+ * @see c4::format(). c4::unformat() is the inverse function to format(). */
+template<class Arg, class... Args>
+size_t unformat(csubstr buf, csubstr fmt, Arg & C4_RESTRICT a, Args & C4_RESTRICT ...more)
+{
+    const size_t pos = fmt.find("{}");
+    if(C4_UNLIKELY(pos == csubstr::npos))
+        return unformat(buf, fmt);
+    size_t num = pos;
+    size_t out = num;
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num  = from_chars_first(buf, &a);
+    if(C4_UNLIKELY(num == csubstr::npos))
+        return csubstr::npos;
+    out += num;
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num  = unformat(buf, fmt.sub(pos + 2), more...);
+    if(C4_UNLIKELY(num == csubstr::npos))
+        return csubstr::npos;
+    out += num;
+    return out;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** a tag type for marking append to container
+ * @see c4::catrs() */
+struct append_t {};
+
+/** a tag variable
+ * @see c4::catrs() */
+constexpr const append_t append = {};
+
+
+//-----------------------------------------------------------------------------
+
+/** like c4::cat(), but receives a container, and resizes it as needed to contain
+ * the result. The container is overwritten. To append to it, use the append
+ * overload.
+ * @see c4::cat() */
+template<class CharOwningContainer, class... Args>
+inline void catrs(CharOwningContainer * C4_RESTRICT cont, Args const& C4_RESTRICT ...args)
+{
+retry:
+    substr buf = to_substr(*cont);
+    size_t ret = cat(buf, args...);
+    cont->resize(ret);
+    if(ret > buf.len)
+        goto retry;
+}
+
+/** like c4::cat(), but creates and returns a new container sized as needed to contain
+ * the result.
+ * @see c4::cat() */
+template<class CharOwningContainer, class... Args>
+inline CharOwningContainer catrs(Args const& C4_RESTRICT ...args)
+{
+    CharOwningContainer cont;
+    catrs(&cont, args...);
+    return cont;
+}
+
+/** like c4::cat(), but receives a container, and appends to it instead of
+ * overwriting it. The container is resized as needed to contain the result.
+ * @return the region newly appended to the original container
+ * @see c4::cat()
+ * @see c4::catrs() */
+template<class CharOwningContainer, class... Args>
+inline csubstr catrs(append_t, CharOwningContainer * C4_RESTRICT cont, Args const& C4_RESTRICT ...args)
+{
+    const size_t pos = cont->size();
+retry:
+    substr buf = to_substr(*cont).sub(pos);
+    size_t ret = cat(buf, args...);
+    cont->resize(pos + ret);
+    if(ret > buf.len)
+        goto retry;
+    return to_csubstr(*cont).range(pos, cont->size());
+}
+
+
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the recursion
+template<class CharOwningContainer, class Sep, class... Args>
+inline void catseprs(CharOwningContainer * C4_RESTRICT, Sep const& C4_RESTRICT)
+{
+    return;
+}
+/// @end cond
+
+
+/** like c4::catsep(), but receives a container, and resizes it as needed to contain the result.
+ * The container is overwritten. To append to the container use the append overload.
+ * @see c4::catsep() */
+template<class CharOwningContainer, class Sep, class... Args>
+inline void catseprs(CharOwningContainer * C4_RESTRICT cont, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...args)
+{
+retry:
+    substr buf = to_substr(*cont);
+    size_t ret = catsep(buf, sep, args...);
+    cont->resize(ret);
+    if(ret > buf.len)
+        goto retry;
+}
+
+/** like c4::catsep(), but create a new container with the result.
+ * @return the requested container */
+template<class CharOwningContainer, class Sep, class... Args>
+inline CharOwningContainer catseprs(Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...args)
+{
+    CharOwningContainer cont;
+    catseprs(&cont, sep, args...);
+    return cont;
+}
+
+
+/// @cond dev
+// terminates the recursion
+template<class CharOwningContainer, class Sep, class... Args>
+inline csubstr catseprs(append_t, CharOwningContainer * C4_RESTRICT, Sep const& C4_RESTRICT)
+{
+    csubstr s;
+    return s;
+}
+/// @endcond
+
+/** like catsep(), but receives a container, and appends the arguments, resizing the
+ * container as needed to contain the result. The buffer is appended to.
+ * @return a csubstr of the appended part
+ * @ingroup formatting_functions */
+template<class CharOwningContainer, class Sep, class... Args>
+inline csubstr catseprs(append_t, CharOwningContainer * C4_RESTRICT cont, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...args)
+{
+    const size_t pos = cont->size();
+retry:
+    substr buf = to_substr(*cont).sub(pos);
+    size_t ret = catsep(buf, sep, args...);
+    cont->resize(pos + ret);
+    if(ret > buf.len)
+        goto retry;
+    return to_csubstr(*cont).range(pos, cont->size());
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** like c4::format(), but receives a container, and resizes it as needed
+ * to contain the result.  The container is overwritten. To append to
+ * the container use the append overload.
+ * @see c4::format() */
+template<class CharOwningContainer, class... Args>
+inline void formatrs(CharOwningContainer * C4_RESTRICT cont, csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+retry:
+    substr buf = to_substr(*cont);
+    size_t ret = format(buf, fmt, args...);
+    cont->resize(ret);
+    if(ret > buf.len)
+        goto retry;
+}
+
+/** like c4::format(), but create a new container with the result.
+ * @return the requested container */
+template<class CharOwningContainer, class... Args>
+inline CharOwningContainer formatrs(csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+    CharOwningContainer cont;
+    formatrs(&cont, fmt, args...);
+    return cont;
+}
+
+/** like format(), but receives a container, and appends the
+ * arguments, resizing the container as needed to contain the
+ * result. The buffer is appended to.
+ * @return the region newly appended to the original container
+ * @ingroup formatting_functions */
+template<class CharOwningContainer, class... Args>
+inline csubstr formatrs(append_t, CharOwningContainer * C4_RESTRICT cont, csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+    const size_t pos = cont->size();
+retry:
+    substr buf = to_substr(*cont).sub(pos);
+    size_t ret = format(buf, fmt, args...);
+    cont->resize(pos + ret);
+    if(ret > buf.len)
+        goto retry;
+    return to_csubstr(*cont).range(pos, cont->size());
+}
+
+} // namespace c4
+
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* _C4_FORMAT_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/format.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/dump.hpp
+// https://github.com/biojppm/c4core/src/c4/dump.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_DUMP_HPP_
+#define C4_DUMP_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr.hpp
+//#include <c4/substr.hpp>
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+
+namespace c4 {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** type of the function to dump characters */
+using DumperPfn = void (*)(csubstr buf);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<DumperPfn dumpfn, class Arg>
+inline size_t dump(substr buf, Arg const& a)
+{
+    size_t sz = to_chars(buf, a); // need to serialize to the buffer
+    if(C4_LIKELY(sz <= buf.len))
+        dumpfn(buf.first(sz));
+    return sz;
+}
+
+template<class DumperFn, class Arg>
+inline size_t dump(DumperFn &&dumpfn, substr buf, Arg const& a)
+{
+    size_t sz = to_chars(buf, a); // need to serialize to the buffer
+    if(C4_LIKELY(sz <= buf.len))
+        dumpfn(buf.first(sz));
+    return sz;
+}
+
+template<DumperPfn dumpfn>
+inline size_t dump(substr buf, csubstr a)
+{
+    if(buf.len)
+        dumpfn(a); // dump directly, no need to serialize to the buffer
+    return 0; // no space was used in the buffer
+}
+
+template<class DumperFn>
+inline size_t dump(DumperFn &&dumpfn, substr buf, csubstr a)
+{
+    if(buf.len)
+        dumpfn(a); // dump directly, no need to serialize to the buffer
+    return 0; // no space was used in the buffer
+}
+
+template<DumperPfn dumpfn, size_t N>
+inline size_t dump(substr buf, const char (&a)[N])
+{
+    if(buf.len)
+        dumpfn(csubstr(a)); // dump directly, no need to serialize to the buffer
+    return 0; // no space was used in the buffer
+}
+
+template<class DumperFn, size_t N>
+inline size_t dump(DumperFn &&dumpfn, substr buf, const char (&a)[N])
+{
+    if(buf.len)
+        dumpfn(csubstr(a)); // dump directly, no need to serialize to the buffer
+    return 0; // no space was used in the buffer
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** */
+struct DumpResults
+{
+    enum : size_t { noarg = (size_t)-1 };
+    size_t bufsize = 0;
+    size_t lastok = noarg;
+    bool success_until(size_t expected) const { return lastok == noarg ? false : lastok >= expected; }
+    bool write_arg(size_t arg) const { return lastok == noarg || arg > lastok; }
+    size_t argfail() const { return lastok + 1; }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminates the variadic recursion
+template<class DumperFn>
+size_t cat_dump(DumperFn &&, substr)
+{
+    return 0;
+}
+
+// terminates the variadic recursion
+template<DumperPfn dumpfn>
+size_t cat_dump(substr)
+{
+    return 0;
+}
+/// @endcond
+
+/** take the function pointer as a function argument */
+template<class DumperFn, class Arg, class... Args>
+size_t cat_dump(DumperFn &&dumpfn, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t size_for_a = dump(dumpfn, buf, a);
+    if(C4_UNLIKELY(size_for_a > buf.len))
+        buf = buf.first(0); // ensure no more calls
+    size_t size_for_more = cat_dump(dumpfn, buf, more...);
+    return size_for_more > size_for_a ? size_for_more : size_for_a;
+}
+
+/** take the function pointer as a template argument */
+template<DumperPfn dumpfn,class Arg, class... Args>
+size_t cat_dump(substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t size_for_a = dump<dumpfn>(buf, a);
+    if(C4_LIKELY(size_for_a > buf.len))
+        buf = buf.first(0); // ensure no more calls
+    size_t size_for_more = cat_dump<dumpfn>(buf, more...);
+    return size_for_more > size_for_a ? size_for_more : size_for_a;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+
+// terminates the variadic recursion
+template<DumperPfn dumpfn, class Arg>
+DumpResults cat_dump_resume(size_t currarg, DumpResults results, substr buf, Arg const& C4_RESTRICT a)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        size_t sz = dump<dumpfn>(buf, a);  // yield to the specialized function
+        if(currarg == results.lastok + 1 && sz <= buf.len)
+            results.lastok = currarg;
+        results.bufsize = sz > results.bufsize ? sz : results.bufsize;
+    }
+    return results;
+}
+
+// terminates the variadic recursion
+template<class DumperFn, class Arg>
+DumpResults cat_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults results, substr buf, Arg const& C4_RESTRICT a)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        size_t sz = dump(dumpfn, buf, a);  // yield to the specialized function
+        if(currarg == results.lastok + 1 && sz <= buf.len)
+            results.lastok = currarg;
+        results.bufsize = sz > results.bufsize ? sz : results.bufsize;
+    }
+    return results;
+}
+
+template<DumperPfn dumpfn, class Arg, class... Args>
+DumpResults cat_dump_resume(size_t currarg, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    results = detail::cat_dump_resume<dumpfn>(currarg, results, buf, a);
+    return detail::cat_dump_resume<dumpfn>(currarg + 1u, results, buf, more...);
+}
+
+template<class DumperFn, class Arg, class... Args>
+DumpResults cat_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    results = detail::cat_dump_resume(currarg, dumpfn, results, buf, a);
+    return detail::cat_dump_resume(currarg + 1u, dumpfn, results, buf, more...);
+}
+} // namespace detail
+/// @endcond
+
+
+template<DumperPfn dumpfn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    if(results.bufsize > buf.len)
+        return results;
+    return detail::cat_dump_resume<dumpfn>(0u, results, buf, a, more...);
+}
+
+template<class DumperFn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(DumperFn &&dumpfn, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    if(results.bufsize > buf.len)
+        return results;
+    return detail::cat_dump_resume(0u, dumpfn, results, buf, a, more...);
+}
+
+template<DumperPfn dumpfn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    return detail::cat_dump_resume<dumpfn>(0u, DumpResults{}, buf, a, more...);
+}
+
+template<class DumperFn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(DumperFn &&dumpfn, substr buf, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    return detail::cat_dump_resume(0u, dumpfn, DumpResults{}, buf, a, more...);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminate the recursion
+template<class DumperFn, class Sep>
+size_t catsep_dump(DumperFn &&, substr, Sep const& C4_RESTRICT)
+{
+    return 0;
+}
+
+// terminate the recursion
+template<DumperPfn dumpfn, class Sep>
+size_t catsep_dump(substr, Sep const& C4_RESTRICT)
+{
+    return 0;
+}
+/// @endcond
+
+/** take the function pointer as a function argument */
+template<class DumperFn, class Sep, class Arg, class... Args>
+size_t catsep_dump(DumperFn &&dumpfn, substr buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t sz = dump(dumpfn, buf, a);
+    if(C4_UNLIKELY(sz > buf.len))
+        buf = buf.first(0); // ensure no more calls
+    if C4_IF_CONSTEXPR (sizeof...(more) > 0)
+    {
+        size_t szsep = dump(dumpfn, buf, sep);
+        if(C4_UNLIKELY(szsep > buf.len))
+            buf = buf.first(0); // ensure no more calls
+        sz = sz > szsep ? sz : szsep;
+    }
+    size_t size_for_more = catsep_dump(dumpfn, buf, sep, more...);
+    return size_for_more > sz ? size_for_more : sz;
+}
+
+/** take the function pointer as a template argument */
+template<DumperPfn dumpfn, class Sep, class Arg, class... Args>
+size_t catsep_dump(substr buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    size_t sz = dump<dumpfn>(buf, a);
+    if(C4_UNLIKELY(sz > buf.len))
+        buf = buf.first(0); // ensure no more calls
+    if C4_IF_CONSTEXPR (sizeof...(more) > 0)
+    {
+        size_t szsep = dump<dumpfn>(buf, sep);
+        if(C4_UNLIKELY(szsep > buf.len))
+            buf = buf.first(0); // ensure no more calls
+        sz = sz > szsep ? sz : szsep;
+    }
+    size_t size_for_more = catsep_dump<dumpfn>(buf, sep, more...);
+    return size_for_more > sz ? size_for_more : sz;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+template<DumperPfn dumpfn, class Arg>
+void catsep_dump_resume_(size_t currarg, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Arg const& C4_RESTRICT a)
+{
+    if(C4_LIKELY(results->write_arg(currarg)))
+    {
+        size_t sz = dump<dumpfn>(*buf, a);
+        results->bufsize = sz > results->bufsize ? sz : results->bufsize;
+        if(C4_LIKELY(sz <= buf->len))
+            results->lastok = currarg;
+        else
+            buf->len = 0;
+    }
+}
+
+template<class DumperFn, class Arg>
+void catsep_dump_resume_(size_t currarg, DumperFn &&dumpfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Arg const& C4_RESTRICT a)
+{
+    if(C4_LIKELY(results->write_arg(currarg)))
+    {
+        size_t sz = dump(dumpfn, *buf, a);
+        results->bufsize = sz > results->bufsize ? sz : results->bufsize;
+        if(C4_LIKELY(sz <= buf->len))
+            results->lastok = currarg;
+        else
+            buf->len = 0;
+    }
+}
+
+template<DumperPfn dumpfn, class Sep, class Arg>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const& C4_RESTRICT, Arg const& C4_RESTRICT a)
+{
+    detail::catsep_dump_resume_<dumpfn>(currarg, results, buf, a);
+}
+
+template<class DumperFn, class Sep, class Arg>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const& C4_RESTRICT, Arg const& C4_RESTRICT a)
+{
+    detail::catsep_dump_resume_(currarg, dumpfn, results, buf, a);
+}
+
+template<DumperPfn dumpfn, class Sep, class Arg, class... Args>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    detail::catsep_dump_resume_<dumpfn>(currarg     , results, buf, a);
+    detail::catsep_dump_resume_<dumpfn>(currarg + 1u, results, buf, sep);
+    detail::catsep_dump_resume <dumpfn>(currarg + 2u, results, buf, sep, more...);
+}
+
+template<class DumperFn, class Sep, class Arg, class... Args>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const& C4_RESTRICT sep, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    detail::catsep_dump_resume_(currarg     , dumpfn, results, buf, a);
+    detail::catsep_dump_resume_(currarg + 1u, dumpfn, results, buf, sep);
+    detail::catsep_dump_resume (currarg + 2u, dumpfn, results, buf, sep, more...);
+}
+} // namespace detail
+/// @endcond
+
+
+template<DumperPfn dumpfn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(DumpResults results, substr buf, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...more)
+{
+    detail::catsep_dump_resume<dumpfn>(0u, &results, &buf, sep, more...);
+    return results;
+}
+
+template<class DumperFn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(DumperFn &&dumpfn, DumpResults results, substr buf, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...more)
+{
+    detail::catsep_dump_resume(0u, dumpfn, &results, &buf, sep, more...);
+    return results;
+}
+
+template<DumperPfn dumpfn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(substr buf, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...more)
+{
+    DumpResults results;
+    detail::catsep_dump_resume<dumpfn>(0u, &results, &buf, sep, more...);
+    return results;
+}
+
+template<class DumperFn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(DumperFn &&dumpfn, substr buf, Sep const& C4_RESTRICT sep, Args const& C4_RESTRICT ...more)
+{
+    DumpResults results;
+    detail::catsep_dump_resume(0u, dumpfn, &results, &buf, sep, more...);
+    return results;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** take the function pointer as a function argument */
+template<class DumperFn>
+C4_ALWAYS_INLINE size_t format_dump(DumperFn &&dumpfn, substr buf, csubstr fmt)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(buf.len > 0 && fmt.len))
+        dumpfn(fmt);
+    return 0u;
+}
+
+/** take the function pointer as a function argument */
+template<DumperPfn dumpfn>
+C4_ALWAYS_INLINE size_t format_dump(substr buf, csubstr fmt)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(buf.len > 0 && fmt.len > 0))
+        dumpfn(fmt);
+    return 0u;
+}
+
+/** take the function pointer as a function argument */
+template<class DumperFn, class Arg, class... Args>
+size_t format_dump(DumperFn &&dumpfn, substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    if(C4_UNLIKELY(pos == csubstr::npos))
+    {
+        if(C4_LIKELY(buf.len > 0 && fmt.len > 0))
+            dumpfn(fmt);
+        return 0u;
+    }
+    if(C4_LIKELY(buf.len > 0 && pos > 0))
+        dumpfn(fmt.first(pos)); // we can dump without using buf
+    fmt = fmt.sub(pos + 2); // skip {} do this before assigning to pos again
+    pos = dump(dumpfn, buf, a);
+    if(C4_UNLIKELY(pos > buf.len))
+        buf.len = 0; // ensure no more calls to dump
+    size_t size_for_more = format_dump(dumpfn, buf, fmt, more...);
+    return size_for_more > pos ? size_for_more : pos;
+}
+
+/** take the function pointer as a template argument */
+template<DumperPfn dumpfn, class Arg, class... Args>
+size_t format_dump(substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    if(C4_UNLIKELY(pos == csubstr::npos))
+    {
+        if(C4_LIKELY(buf.len > 0 && fmt.len > 0))
+            dumpfn(fmt);
+        return 0u;
+    }
+    if(C4_LIKELY(buf.len > 0 && pos > 0))
+        dumpfn(fmt.first(pos)); // we can dump without using buf
+    fmt = fmt.sub(pos + 2); // skip {} do this before assigning to pos again
+    pos = dump<dumpfn>(buf, a);
+    if(C4_UNLIKELY(pos > buf.len))
+        buf.len = 0; // ensure no more calls to dump
+    size_t size_for_more = format_dump<dumpfn>(buf, fmt, more...);
+    return size_for_more > pos ? size_for_more : pos;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+
+template<DumperPfn dumpfn>
+DumpResults format_dump_resume(size_t currarg, DumpResults results, substr buf, csubstr fmt)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(buf.len > 0))
+    {
+        dumpfn(fmt);
+        results.lastok = currarg;
+    }
+    return results;
+}
+
+template<class DumperFn>
+DumpResults format_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults results, substr buf, csubstr fmt)
+{
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(buf.len > 0))
+    {
+        dumpfn(fmt);
+        results.lastok = currarg;
+    }
+    return results;
+}
+
+template<DumperPfn dumpfn, class Arg, class... Args>
+DumpResults format_dump_resume(size_t currarg, DumpResults results, substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    // we need to process the format even if we're not
+    // going to print the first arguments because we're resuming
+    size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        if(C4_UNLIKELY(pos == csubstr::npos))
+        {
+            if(C4_LIKELY(buf.len > 0))
+            {
+                results.lastok = currarg;
+                dumpfn(fmt);
+            }
+            return results;
+        }
+        if(C4_LIKELY(buf.len > 0))
+        {
+            results.lastok = currarg;
+            dumpfn(fmt.first(pos));
+        }
+    }
+    fmt = fmt.sub(pos + 2);
+    if(C4_LIKELY(results.write_arg(currarg + 1)))
+    {
+        pos = dump<dumpfn>(buf, a);
+        results.bufsize = pos > results.bufsize ? pos : results.bufsize;
+        if(C4_LIKELY(pos <= buf.len))
+            results.lastok = currarg + 1;
+        else
+            buf.len = 0;
+    }
+    return detail::format_dump_resume<dumpfn>(currarg + 2u, results, buf, fmt, more...);
+}
+/// @endcond
+
+
+template<class DumperFn, class Arg, class... Args>
+DumpResults format_dump_resume(size_t currarg, DumperFn &&dumpfn, DumpResults results, substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& C4_RESTRICT ...more)
+{
+    // we need to process the format even if we're not
+    // going to print the first arguments because we're resuming
+    size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    // we can dump without using buf
+    // but we'll only dump if the buffer is ok
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        if(C4_UNLIKELY(pos == csubstr::npos))
+        {
+            if(C4_LIKELY(buf.len > 0))
+            {
+                results.lastok = currarg;
+                dumpfn(fmt);
+            }
+            return results;
+        }
+        if(C4_LIKELY(buf.len > 0))
+        {
+            results.lastok = currarg;
+            dumpfn(fmt.first(pos));
+        }
+    }
+    fmt = fmt.sub(pos + 2);
+    if(C4_LIKELY(results.write_arg(currarg + 1)))
+    {
+        pos = dump(dumpfn, buf, a);
+        results.bufsize = pos > results.bufsize ? pos : results.bufsize;
+        if(C4_LIKELY(pos <= buf.len))
+            results.lastok = currarg + 1;
+        else
+            buf.len = 0;
+    }
+    return detail::format_dump_resume(currarg + 2u, dumpfn, results, buf, fmt, more...);
+}
+} // namespace detail
+
+
+template<DumperPfn dumpfn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(DumpResults results, substr buf, csubstr fmt, Args const& C4_RESTRICT ...more)
+{
+    return detail::format_dump_resume<dumpfn>(0u, results, buf, fmt, more...);
+}
+
+template<class DumperFn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(DumperFn &&dumpfn, DumpResults results, substr buf, csubstr fmt, Args const& C4_RESTRICT ...more)
+{
+    return detail::format_dump_resume(0u, dumpfn, results, buf, fmt, more...);
+}
+
+
+template<DumperPfn dumpfn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(substr buf, csubstr fmt, Args const& C4_RESTRICT ...more)
+{
+    return detail::format_dump_resume<dumpfn>(0u, DumpResults{}, buf, fmt, more...);
+}
+
+template<class DumperFn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(DumperFn &&dumpfn, substr buf, csubstr fmt, Args const& C4_RESTRICT ...more)
+{
+    return detail::format_dump_resume(0u, dumpfn, DumpResults{}, buf, fmt, more...);
+}
+
+
+} // namespace c4
+
+
+#endif /* C4_DUMP_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/dump.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/enum.hpp
+// https://github.com/biojppm/c4core/src/c4/enum.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_ENUM_HPP_
+#define _C4_ENUM_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+//included above:
+//#include <string.h>
+
+/** @file enum.hpp utilities for enums: convert to/from string
+ */
+
+
+namespace c4 {
+
+//! taken from http://stackoverflow.com/questions/15586163/c11-type-trait-to-differentiate-between-enum-class-and-regular-enum
+template<typename Enum>
+using is_scoped_enum = std::integral_constant<bool, std::is_enum<Enum>::value && !std::is_convertible<Enum, int>::value>;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+typedef enum {
+    EOFFS_NONE = 0,  ///< no offset
+    EOFFS_CLS = 1,   ///< get the enum offset for the class name. @see eoffs_cls()
+    EOFFS_PFX = 2,   ///< get the enum offset for the enum prefix. @see eoffs_pfx()
+    _EOFFS_LAST      ///< reserved
+} EnumOffsetType;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A simple (proxy) container for the value-name pairs of an enum type.
+ * Uses linear search for finds; this could be improved for time-critical
+ * code. */
+template<class Enum>
+class EnumSymbols
+{
+public:
+
+    struct Sym
+    {
+        Enum value;
+        const char *name;
+
+        bool cmp(const char *s) const;
+        bool cmp(const char *s, size_t len) const;
+
+        const char *name_offs(EnumOffsetType t) const;
+    };
+
+    using const_iterator = Sym const*;
+
+public:
+
+    template<size_t N>
+    EnumSymbols(Sym const (&p)[N]) : m_symbols(p), m_num(N) {}
+
+    size_t size() const { return m_num; }
+    bool empty() const { return m_num == 0; }
+
+    Sym const* get(Enum v) const { auto p = find(v); C4_CHECK_MSG(p != nullptr, "could not find symbol=%zd", (std::ptrdiff_t)v); return p; }
+    Sym const* get(const char *s) const { auto p = find(s); C4_CHECK_MSG(p != nullptr, "could not find symbol \"%s\"", s); return p; }
+    Sym const* get(const char *s, size_t len) const { auto p = find(s, len); C4_CHECK_MSG(p != nullptr, "could not find symbol \"%.*s\"", len, s); return p; }
+
+    Sym const* find(Enum v) const;
+    Sym const* find(const char *s) const;
+    Sym const* find(const char *s, size_t len) const;
+
+    Sym const& operator[] (size_t i) const { C4_CHECK(i < m_num); return m_symbols[i]; }
+
+    Sym const* begin() const { return m_symbols; }
+    Sym const* end  () const { return m_symbols + m_num; }
+
+private:
+
+    Sym const* m_symbols;
+    size_t const m_num;
+
+};
+
+//-----------------------------------------------------------------------------
+/** return an EnumSymbols object for the enum type T
+ *
+ * @warning SPECIALIZE! This needs to be specialized for each enum
+ * type. Failure to provide a specialization will cause a linker
+ * error. */
+template<class Enum>
+EnumSymbols<Enum> const esyms();
+
+
+/** return the offset for an enum symbol class. For example,
+ * eoffs_cls<MyEnumClass>() would be 13=strlen("MyEnumClass::").
+ *
+ * With this function you can announce that the full prefix (including
+ * an eventual enclosing class or C++11 enum class) is of a certain
+ * length.
+ *
+ * @warning Needs to be specialized for each enum class type that
+ * wants to use this. When no specialization is given, will return
+ * 0. */
+template<class Enum>
+size_t eoffs_cls()
+{
+    return 0;
+}
+
+
+/** return the offset for an enum symbol prefix. This includes
+ * eoffs_cls().  With this function you can announce that the full
+ * prefix (including an eventual enclosing class or C++11 enum class
+ * plus the string prefix) is of a certain length.
+ *
+ * @warning Needs to be specialized for each enum class type that
+ * wants to use this. When no specialization is given, will return
+ * 0. */
+template<class Enum>
+size_t eoffs_pfx()
+{
+    return 0;
+}
+
+
+template<class Enum>
+size_t eoffs(EnumOffsetType which)
+{
+    switch(which)
+    {
+    case EOFFS_NONE:
+        return 0;
+    case EOFFS_CLS:
+        return eoffs_cls<Enum>();
+    case EOFFS_PFX:
+    {
+        size_t pfx = eoffs_pfx<Enum>();
+        return pfx > 0 ? pfx : eoffs_cls<Enum>();
+    }
+    default:
+        C4_ERROR("unknown offset type %d", (int)which);
+        return 0;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+/** get the enum value corresponding to a c-string */
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   if __GNUC__ >= 6
+#       pragma GCC diagnostic ignored "-Wnull-dereference"
+#   endif
+#endif
+
+template<class Enum>
+Enum str2e(const char* str)
+{
+    auto pairs = esyms<Enum>();
+    auto *p = pairs.get(str);
+    C4_CHECK_MSG(p != nullptr, "no valid enum pair name for '%s'", str);
+    return p->value;
+}
+
+/** get the c-string corresponding to an enum value */
+template<class Enum>
+const char* e2str(Enum e)
+{
+    auto es = esyms<Enum>();
+    auto *p = es.get(e);
+    C4_CHECK_MSG(p != nullptr, "no valid enum pair name");
+    return p->name;
+}
+
+/** like e2str(), but add an offset. */
+template<class Enum>
+const char* e2stroffs(Enum e, EnumOffsetType ot=EOFFS_PFX)
+{
+    const char *s = e2str<Enum>(e) + eoffs<Enum>(ot);
+    return s;
+}
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+//-----------------------------------------------------------------------------
+/** Find a symbol by value. Returns nullptr when none is found */
+template<class Enum>
+typename EnumSymbols<Enum>::Sym const* EnumSymbols<Enum>::find(Enum v) const
+{
+    for(Sym const* p = this->m_symbols, *e = p+this->m_num; p < e; ++p)
+        if(p->value == v)
+            return p;
+    return nullptr;
+}
+
+/** Find a symbol by name. Returns nullptr when none is found */
+template<class Enum>
+typename EnumSymbols<Enum>::Sym const* EnumSymbols<Enum>::find(const char *s) const
+{
+    for(Sym const* p = this->m_symbols, *e = p+this->m_num; p < e; ++p)
+        if(p->cmp(s))
+            return p;
+    return nullptr;
+}
+
+/** Find a symbol by name. Returns nullptr when none is found */
+template<class Enum>
+typename EnumSymbols<Enum>::Sym const* EnumSymbols<Enum>::find(const char *s, size_t len) const
+{
+    for(Sym const* p = this->m_symbols, *e = p+this->m_num; p < e; ++p)
+        if(p->cmp(s, len))
+            return p;
+    return nullptr;
+}
+
+//-----------------------------------------------------------------------------
+template<class Enum>
+bool EnumSymbols<Enum>::Sym::cmp(const char *s) const
+{
+    if(strcmp(name, s) == 0)
+        return true;
+
+    for(int i = 1; i < _EOFFS_LAST; ++i)
+    {
+        auto o = eoffs<Enum>((EnumOffsetType)i);
+        if(o > 0)
+            if(strcmp(name + o, s) == 0)
+                return true;
+    }
+
+    return false;
+}
+
+template<class Enum>
+bool EnumSymbols<Enum>::Sym::cmp(const char *s, size_t len) const
+{
+    if(strncmp(name, s, len) == 0)
+        return true;
+
+    size_t nlen = 0;
+    for(int i = 1; i <_EOFFS_LAST; ++i)
+    {
+        auto o = eoffs<Enum>((EnumOffsetType)i);
+        if(o > 0)
+        {
+            if(!nlen)
+            {
+                nlen = strlen(name);
+            }
+            C4_ASSERT(o < nlen);
+            size_t rem = nlen - o;
+            auto m = len > rem ? len : rem;
+            if(len >= m && strncmp(name + o, s, m) == 0)
+                return true;
+        }
+    }
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+template<class Enum>
+const char* EnumSymbols<Enum>::Sym::name_offs(EnumOffsetType t) const
+{
+    C4_ASSERT(eoffs<Enum>(t) < strlen(name));
+    return name + eoffs<Enum>(t);
+}
+
+} // namespace c4
+
+#endif // _C4_ENUM_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/enum.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/bitmask.hpp
+// https://github.com/biojppm/c4core/src/c4/bitmask.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_BITMASK_HPP_
+#define _C4_BITMASK_HPP_
+
+/** @file bitmask.hpp bitmask utilities */
+
+//included above:
+//#include <cstring>
+//included above:
+//#include <type_traits>
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/enum.hpp
+//#include "c4/enum.hpp"
+#if !defined(C4_ENUM_HPP_) && !defined(_C4_ENUM_HPP_)
+#error "amalgamate: file c4/enum.hpp must have been included at this point"
+#endif /* C4_ENUM_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/format.hpp
+//#include "c4/format.hpp"
+#if !defined(C4_FORMAT_HPP_) && !defined(_C4_FORMAT_HPP_)
+#error "amalgamate: file c4/format.hpp must have been included at this point"
+#endif /* C4_FORMAT_HPP_ */
+
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   pragma warning(disable : 4996) // 'strncpy', fopen, etc: This function or variable may be unsafe
+#elif defined(__clang__)
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   if __GNUC__ >= 8
+#       pragma GCC diagnostic ignored "-Wstringop-truncation"
+#       pragma GCC diagnostic ignored "-Wstringop-overflow"
+#   endif
+#endif
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+/** write a bitmask to a stream, formatted as a string */
+
+template<class Enum, class Stream>
+Stream& bm2stream(Stream &s, typename std::underlying_type<Enum>::type bits, EnumOffsetType offst=EOFFS_PFX)
+{
+    using I = typename std::underlying_type<Enum>::type;
+    bool written = false;
+
+    auto const& pairs = esyms<Enum>();
+
+    // write non null value
+    if(bits)
+    {
+        // do reverse iteration to give preference to composite enum symbols,
+        // which are likely to appear at the end of the enum sequence
+        for(size_t i = pairs.size() - 1; i != size_t(-1); --i)
+        {
+            auto p = pairs[i];
+            I b(static_cast<I>(p.value));
+            if(b && (bits & b) == b)
+            {
+                if(written) s << '|'; // append bit-or character
+                written = true;
+                s << p.name_offs(offst); // append bit string
+                bits &= ~b;
+            }
+        }
+        return s;
+    }
+    else
+    {
+        // write a null value
+        for(size_t i = pairs.size() - 1; i != size_t(-1); --i)
+        {
+            auto p = pairs[i];
+            I b(static_cast<I>(p.value));
+            if(b == 0)
+            {
+                s << p.name_offs(offst);
+                written = true;
+                break;
+            }
+        }
+    }
+    if(!written)
+    {
+        s << '0';
+    }
+    return s;
+}
+
+template<class Enum, class Stream>
+typename std::enable_if<is_scoped_enum<Enum>::value, Stream&>::type
+bm2stream(Stream &s, Enum value, EnumOffsetType offst=EOFFS_PFX)
+{
+    using I = typename std::underlying_type<Enum>::type;
+    return bm2stream<Enum>(s, static_cast<I>(value), offst);
+}
+
+
+//-----------------------------------------------------------------------------
+
+// some utility macros, undefed below
+
+/// @cond dev
+
+/* Execute `code` if the `num` of characters is available in the str
+ * buffer. This macro simplifies the code for bm2str().
+ * @todo improve performance by writing from the end and moving only once. */
+#define _c4prependchars(code, num)                                      \
+    if(str && (pos + num <= sz))                                        \
+    {                                                                   \
+        /* move the current string to the right */                      \
+        memmove(str + num, str, pos);                                   \
+        /* now write in the beginning of the string */                  \
+        code;                                                           \
+    }                                                                   \
+    else if(str && sz)                                                  \
+    {                                                                   \
+        C4_ERROR("cannot write to string pos=%d num=%d sz=%d",          \
+                 (int)pos, (int)num, (int)sz);                          \
+    }                                                                   \
+    pos += num
+
+/* Execute `code` if the `num` of characters is available in the str
+ * buffer. This macro simplifies the code for bm2str(). */
+#define _c4appendchars(code, num)                                       \
+    if(str && (pos + num <= sz))                                        \
+    {                                                                   \
+        code;                                                           \
+    }                                                                   \
+    else if(str && sz)                                                  \
+    {                                                                   \
+        C4_ERROR("cannot write to string pos=%d num=%d sz=%d",          \
+                 (int)pos, (int)num, (int)sz);                          \
+    }                                                                   \
+    pos += num
+
+/// @endcond
+
+
+/** convert a bitmask to string.
+ * return the number of characters written. To find the needed size,
+ * call first with str=nullptr and sz=0 */
+template<class Enum>
+size_t bm2str
+(
+    typename std::underlying_type<Enum>::type bits,
+    char *str=nullptr,
+    size_t sz=0,
+    EnumOffsetType offst=EOFFS_PFX
+)
+{
+    using I = typename std::underlying_type<Enum>::type;
+    C4_ASSERT((str == nullptr) == (sz == 0));
+
+    auto syms = esyms<Enum>();
+    size_t pos = 0;
+    typename EnumSymbols<Enum>::Sym const* C4_RESTRICT zero = nullptr;
+
+    // do reverse iteration to give preference to composite enum symbols,
+    // which are likely to appear later in the enum sequence
+    for(size_t i = syms.size()-1; i != size_t(-1); --i)
+    {
+        auto const &C4_RESTRICT p = syms[i]; // do not copy, we are assigning to `zero`
+        I b = static_cast<I>(p.value);
+        if(b == 0)
+        {
+            zero = &p; // save this symbol for later
+        }
+        else if((bits & b) == b)
+        {
+            bits &= ~b;
+            // append bit-or character
+            if(pos > 0)
+            {
+                _c4prependchars(*str = '|', 1);
+            }
+            // append bit string
+            const char *pname = p.name_offs(offst);
+            size_t len = strlen(pname);
+            _c4prependchars(strncpy(str, pname, len), len);
+        }
+    }
+
+    C4_CHECK_MSG(bits == 0, "could not find all bits");
+    if(pos == 0) // make sure at least something is written
+    {
+        if(zero) // if we have a zero symbol, use that
+        {
+            const char *pname = zero->name_offs(offst);
+            size_t len = strlen(pname);
+            _c4prependchars(strncpy(str, pname, len), len);
+        }
+        else // otherwise just write an integer zero
+        {
+            _c4prependchars(*str = '0', 1);
+        }
+    }
+    _c4appendchars(str[pos] = '\0', 1);
+
+    return pos;
+}
+
+
+// cleanup!
+#undef _c4appendchars
+#undef _c4prependchars
+
+
+/** scoped enums do not convert automatically to their underlying type,
+ * so this SFINAE overload will accept scoped enum symbols and cast them
+ * to the underlying type */
+template<class Enum>
+typename std::enable_if<is_scoped_enum<Enum>::value, size_t>::type
+bm2str
+(
+    Enum bits,
+    char *str=nullptr,
+    size_t sz=0,
+    EnumOffsetType offst=EOFFS_PFX
+)
+{
+    using I = typename std::underlying_type<Enum>::type;
+    return bm2str<Enum>(static_cast<I>(bits), str, sz, offst);
+}
+
+
+//-----------------------------------------------------------------------------
+
+namespace detail {
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   if __GNUC__ >= 6
+#       pragma GCC diagnostic ignored "-Wnull-dereference"
+#   endif
+#endif
+
+template<class Enum>
+typename std::underlying_type<Enum>::type str2bm_read_one(const char *str, size_t sz, bool alnum)
+{
+    using I = typename std::underlying_type<Enum>::type;
+    auto pairs = esyms<Enum>();
+    if(alnum)
+    {
+        auto *p = pairs.find(str, sz);
+        C4_CHECK_MSG(p != nullptr, "no valid enum pair name for '%.*s'", (int)sz, str);
+        return static_cast<I>(p->value);
+    }
+    I tmp;
+    size_t len = uncat(csubstr(str, sz), tmp);
+    C4_CHECK_MSG(len != csubstr::npos, "could not read string as an integral type: '%.*s'", (int)sz, str);
+    return tmp;
+}
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+} // namespace detail
+
+/** convert a string to a bitmask */
+template<class Enum>
+typename std::underlying_type<Enum>::type str2bm(const char *str, size_t sz)
+{
+    using I = typename std::underlying_type<Enum>::type;
+
+    I val = 0;
+    bool started = false;
+    bool alnum = false, num = false;
+    const char *f = nullptr, *pc = str;
+    for( ; pc < str+sz; ++pc)
+    {
+        const char c = *pc;
+        if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')
+        {
+            C4_CHECK(( ! num) || ((pc - f) == 1 && (c == 'x' || c == 'X'))); // accept hexadecimal numbers
+            if( ! started)
+            {
+                f = pc;
+                alnum = started = true;
+            }
+        }
+        else if(c >= '0' && c <= '9')
+        {
+            C4_CHECK( ! alnum);
+            if(!started)
+            {
+                f = pc;
+                num = started = true;
+            }
+        }
+        else if(c == ':' || c == ' ')
+        {
+            // skip this char
+        }
+        else if(c == '|' || c == '\0')
+        {
+            C4_ASSERT(num != alnum);
+            C4_ASSERT(pc >= f);
+            val |= detail::str2bm_read_one<Enum>(f, static_cast<size_t>(pc-f), alnum);
+            started = num = alnum = false;
+            if(c == '\0')
+            {
+                return val;
+            }
+        }
+        else
+        {
+            C4_ERROR("bad character '%c' in bitmask string", c);
+        }
+    }
+
+    if(f)
+    {
+        C4_ASSERT(num != alnum);
+        C4_ASSERT(pc >= f);
+        val |= detail::str2bm_read_one<Enum>(f, static_cast<size_t>(pc-f), alnum);
+    }
+
+    return val;
+}
+
+/** convert a string to a bitmask */
+template<class Enum>
+typename std::underlying_type<Enum>::type str2bm(const char *str)
+{
+    return str2bm<Enum>(str, strlen(str));
+}
+
+} // namespace c4
+
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#elif defined(__clang__)
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif // _C4_BITMASK_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/bitmask.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/span.hpp
+// https://github.com/biojppm/c4core/src/c4/span.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_SPAN_HPP_
+#define _C4_SPAN_HPP_
+
+/** @file span.hpp Provides span classes. */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/config.hpp
+//#include "c4/config.hpp"
+#if !defined(C4_CONFIG_HPP_) && !defined(_C4_CONFIG_HPP_)
+#error "amalgamate: file c4/config.hpp must have been included at this point"
+#endif /* C4_CONFIG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/szconv.hpp
+//#include "c4/szconv.hpp"
+#if !defined(C4_SZCONV_HPP_) && !defined(_C4_SZCONV_HPP_)
+#error "amalgamate: file c4/szconv.hpp must have been included at this point"
+#endif /* C4_SZCONV_HPP_ */
+
+
+//included above:
+//#include <algorithm>
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** a crtp base for implementing span classes
+ *
+ * A span is a non-owning range of elements contiguously stored in memory.
+ * Unlike STL's array_view, the span allows write-access to its members.
+ *
+ * To obtain subspans from a span, the following const member functions
+ * are available:
+ *  - subspan(first, num)
+ *  - range(first, last)
+ *  - first(num)
+ *  - last(num)
+ *
+ * A span can also be resized via the following non-const member functions:
+ *  - resize(sz)
+ *  - ltrim(num)
+ *  - rtrim(num)
+ *
+ * @see span
+ * @see cspan
+ * @see spanrs
+ * @see cspanrs
+ * @see spanrsl
+ * @see cspanrsl
+ */
+template<class T, class I, class SpanImpl>
+class span_crtp
+{
+// some utility defines, undefined at the end of this class
+#define _c4this  ((SpanImpl      *)this)
+#define _c4cthis ((SpanImpl const*)this)
+#define _c4ptr   ((SpanImpl      *)this)->m_ptr
+#define _c4cptr  ((SpanImpl const*)this)->m_ptr
+#define _c4sz    ((SpanImpl      *)this)->m_size
+#define _c4csz   ((SpanImpl const*)this)->m_size
+
+public:
+
+    _c4_DEFINE_ARRAY_TYPES(T, I);
+
+public:
+
+    C4_ALWAYS_INLINE constexpr I value_size() const noexcept { return sizeof(T); }
+    C4_ALWAYS_INLINE constexpr I elm_size  () const noexcept { return sizeof(T); }
+    C4_ALWAYS_INLINE constexpr I type_size () const noexcept { return sizeof(T); }
+    C4_ALWAYS_INLINE           I byte_size () const noexcept { return _c4csz*sizeof(T); }
+
+    C4_ALWAYS_INLINE bool empty()    const noexcept { return _c4csz == 0; }
+    C4_ALWAYS_INLINE I    size()     const noexcept { return _c4csz; }
+    //C4_ALWAYS_INLINE I    capacity() const noexcept { return _c4sz; } // this must be defined by impl classes
+
+    C4_ALWAYS_INLINE void clear() noexcept { _c4sz = 0; }
+
+    C4_ALWAYS_INLINE T      * data()       noexcept { return _c4ptr; }
+    C4_ALWAYS_INLINE T const* data() const noexcept { return _c4cptr; }
+
+    C4_ALWAYS_INLINE       iterator  begin()       noexcept { return _c4ptr; }
+    C4_ALWAYS_INLINE const_iterator  begin() const noexcept { return _c4cptr; }
+    C4_ALWAYS_INLINE const_iterator cbegin() const noexcept { return _c4cptr; }
+
+    C4_ALWAYS_INLINE       iterator  end()       noexcept { return _c4ptr  + _c4sz; }
+    C4_ALWAYS_INLINE const_iterator  end() const noexcept { return _c4cptr + _c4csz; }
+    C4_ALWAYS_INLINE const_iterator cend() const noexcept { return _c4cptr + _c4csz; }
+
+    C4_ALWAYS_INLINE       reverse_iterator  rbegin()       noexcept { return reverse_iterator(_c4ptr + _c4sz); }
+    C4_ALWAYS_INLINE const_reverse_iterator  rbegin() const noexcept { return reverse_iterator(_c4cptr + _c4sz); }
+    C4_ALWAYS_INLINE const_reverse_iterator crbegin() const noexcept { return reverse_iterator(_c4cptr + _c4sz); }
+
+    C4_ALWAYS_INLINE       reverse_iterator  rend()       noexcept { return const_reverse_iterator(_c4ptr); }
+    C4_ALWAYS_INLINE const_reverse_iterator  rend() const noexcept { return const_reverse_iterator(_c4cptr); }
+    C4_ALWAYS_INLINE const_reverse_iterator crend() const noexcept { return const_reverse_iterator(_c4cptr); }
+
+    C4_ALWAYS_INLINE T      & front()       C4_NOEXCEPT_X { C4_XASSERT(!empty()); return _c4ptr [0]; }
+    C4_ALWAYS_INLINE T const& front() const C4_NOEXCEPT_X { C4_XASSERT(!empty()); return _c4cptr[0]; }
+
+    C4_ALWAYS_INLINE T      & back()       C4_NOEXCEPT_X { C4_XASSERT(!empty()); return _c4ptr [_c4sz  - 1]; }
+    C4_ALWAYS_INLINE T const& back() const C4_NOEXCEPT_X { C4_XASSERT(!empty()); return _c4cptr[_c4csz - 1]; }
+
+    C4_ALWAYS_INLINE T      & operator[] (I i)       C4_NOEXCEPT_X { C4_XASSERT(i >= 0 && i < _c4sz ); return _c4ptr [i]; }
+    C4_ALWAYS_INLINE T const& operator[] (I i) const C4_NOEXCEPT_X { C4_XASSERT(i >= 0 && i < _c4csz); return _c4cptr[i]; }
+
+    C4_ALWAYS_INLINE SpanImpl subspan(I first, I num) const C4_NOEXCEPT_X
+    {
+        C4_XASSERT((first >= 0 && first < _c4csz) || (first == _c4csz && num == 0));
+        C4_XASSERT((first + num >= 0) && (first + num <= _c4csz));
+        return _c4cthis->_select(_c4cptr + first, num);
+    }
+    C4_ALWAYS_INLINE SpanImpl subspan(I first) const C4_NOEXCEPT_X ///< goes up until the end of the span
+    {
+        C4_XASSERT(first >= 0 && first <= _c4csz);
+        return _c4cthis->_select(_c4cptr + first, _c4csz - first);
+    }
+
+    C4_ALWAYS_INLINE SpanImpl range(I first, I last) const C4_NOEXCEPT_X ///< last element is NOT included
+    {
+        C4_XASSERT(((first >= 0) && (first < _c4csz)) || (first == _c4csz && first == last));
+        C4_XASSERT((last >= 0) && (last <= _c4csz));
+        C4_XASSERT(last >= first);
+        return _c4cthis->_select(_c4cptr + first, last - first);
+    }
+    C4_ALWAYS_INLINE SpanImpl range(I first) const C4_NOEXCEPT_X ///< goes up until the end of the span
+    {
+        C4_XASSERT(((first >= 0) && (first <= _c4csz)));
+        return _c4cthis->_select(_c4cptr + first, _c4csz - first);
+    }
+
+    C4_ALWAYS_INLINE SpanImpl first(I num) const C4_NOEXCEPT_X ///< get the first num elements, starting at 0
+    {
+        C4_XASSERT((num >= 0) && (num <= _c4csz));
+        return _c4cthis->_select(_c4cptr, num);
+    }
+    C4_ALWAYS_INLINE SpanImpl last(I num) const C4_NOEXCEPT_X ///< get the last num elements, starting at size()-num
+    {
+        C4_XASSERT((num >= 0) && (num <= _c4csz));
+        return _c4cthis->_select(_c4cptr + _c4csz - num, num);
+    }
+
+    bool is_subspan(span_crtp const& ss) const noexcept
+    {
+        if(_c4cptr == nullptr) return false;
+        auto *b = begin(), *e = end();
+        auto *ssb = ss.begin(), *sse = ss.end();
+        if(ssb >= b && sse <= e)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    /** COMPLement Left: return the complement to the left of the beginning of the given subspan.
+     * If ss does not begin inside this, returns an empty substring. */
+    SpanImpl compll(span_crtp const& ss) const C4_NOEXCEPT_X
+    {
+        auto ssb = ss.begin();
+        auto b = begin();
+        auto e = end();
+        if(ssb >= b && ssb <= e)
+        {
+            return subspan(0, static_cast<size_t>(ssb - b));
+        }
+        else
+        {
+            return subspan(0, 0);
+        }
+    }
+
+    /** COMPLement Right: return the complement to the right of the end of the given subspan.
+     * If ss does not end inside this, returns an empty substring. */
+    SpanImpl complr(span_crtp const& ss) const C4_NOEXCEPT_X
+    {
+        auto sse = ss.end();
+        auto b = begin();
+        auto e = end();
+        if(sse >= b && sse <= e)
+        {
+            return subspan(static_cast<size_t>(sse - b), static_cast<size_t>(e - sse));
+        }
+        else
+        {
+            return subspan(0, 0);
+        }
+    }
+
+    C4_ALWAYS_INLINE bool same_span(span_crtp const& that) const noexcept
+    {
+        return size() == that.size() && data() == that.data();
+    }
+    template<class I2, class Impl2>
+    C4_ALWAYS_INLINE bool same_span(span_crtp<T, I2, Impl2> const& that) const C4_NOEXCEPT_X
+    {
+        I tsz = szconv<I>(that.size()); // x-asserts that the size does not overflow
+        return size() == tsz && data() == that.data();
+    }
+
+#undef _c4this
+#undef _c4cthis
+#undef _c4ptr
+#undef _c4cptr
+#undef _c4sz
+#undef _c4csz
+};
+
+//-----------------------------------------------------------------------------
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator==
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+#if C4_CPP >= 14
+    return std::equal(l.begin(), l.end(), r.begin(), r.end());
+#else
+    return l.same_span(r) || std::equal(l.begin(), l.end(), r.begin());
+#endif
+}
+
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator!=
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+    return ! (l == r);
+}
+
+//-----------------------------------------------------------------------------
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator<
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator<=
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+    return ! (l > r);
+}
+
+//-----------------------------------------------------------------------------
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator>
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+    return r < l;
+}
+
+//-----------------------------------------------------------------------------
+template<class T, class Il, class Ir, class _Impll, class _Implr>
+inline constexpr bool operator>=
+(
+    span_crtp<T, Il, _Impll> const& l,
+    span_crtp<T, Ir, _Implr> const& r
+)
+{
+    return ! (l < r);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A non-owning span of elements contiguously stored in memory. */
+template<class T, class I=C4_SIZE_TYPE>
+class span : public span_crtp<T, I, span<T, I>>
+{
+    friend class span_crtp<T, I, span<T, I>>;
+
+    T * C4_RESTRICT m_ptr;
+    I   m_size;
+
+    C4_ALWAYS_INLINE span _select(T *p, I sz) const { return span(p, sz); }
+
+public:
+
+    _c4_DEFINE_ARRAY_TYPES(T, I);
+    using NCT = typename std::remove_const<T>::type; //!< NCT=non const type
+    using CT = typename std::add_const<T>::type; //!< CT=const type
+    using const_type = span<CT, I>;
+
+    /// convert automatically to span of const T
+    operator span<CT, I> () const { span<CT, I> s(m_ptr, m_size); return s; }
+
+public:
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 span() noexcept : m_ptr{nullptr}, m_size{0} {}
+
+    span(span const&) = default;
+    span(span     &&) = default;
+
+    span& operator= (span const&) = default;
+    span& operator= (span     &&) = default;
+
+public:
+
+    /** @name Construction and assignment from same type */
+    /** @{ */
+
+    template<size_t N> C4_ALWAYS_INLINE C4_CONSTEXPR14      span  (T (&arr)[N]) noexcept : m_ptr{arr}, m_size{N} {}
+    template<size_t N> C4_ALWAYS_INLINE C4_CONSTEXPR14 void assign(T (&arr)[N]) noexcept { m_ptr = arr; m_size = N; }
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14        span(T *p, I sz) noexcept : m_ptr{p}, m_size{sz} {}
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 void   assign(T *p, I sz) noexcept { m_ptr = p; m_size = sz; }
+
+    C4_ALWAYS_INLINE C4_CONSTEXPR14      span  (c4::aggregate_t, std::initializer_list<T> il) noexcept : m_ptr{&*il.begin()}, m_size{il.size()} {}
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 void assign(c4::aggregate_t, std::initializer_list<T> il) noexcept { m_ptr = &*il.begin(); m_size = il.size(); }
+
+    /** @} */
+
+public:
+
+    C4_ALWAYS_INLINE I capacity() const noexcept { return m_size; }
+
+    C4_ALWAYS_INLINE void resize(I sz) C4_NOEXCEPT_A { C4_ASSERT(sz <= m_size); m_size = sz; }
+    C4_ALWAYS_INLINE void rtrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; }
+    C4_ALWAYS_INLINE void ltrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; m_ptr += n; }
+
+};
+template<class T, class I=C4_SIZE_TYPE> using cspan = span<const T, I>;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A non-owning span resizeable up to a capacity. Subselection or resizing
+ * will keep the original provided it starts at begin(). If subselection or
+ * resizing change the pointer, then the original capacity information will
+ * be lost.
+ *
+ * Thus, resizing via resize() and ltrim() and subselecting via first()
+ * or any of subspan() or range() when starting from the beginning will keep
+ * the original capacity. OTOH, using last(), or any of subspan() or range()
+ * with an offset from the start will remove from capacity (shifting the
+ * pointer) by the corresponding offset. If this is undesired, then consider
+ * using spanrsl.
+ *
+ * @see spanrs for a span resizeable on the right
+ * @see spanrsl for a span resizeable on the right and left
+ */
+
+template<class T, class I=C4_SIZE_TYPE>
+class spanrs : public span_crtp<T, I, spanrs<T, I>>
+{
+    friend class span_crtp<T, I, spanrs<T, I>>;
+
+    T * C4_RESTRICT m_ptr;
+    I   m_size;
+    I   m_capacity;
+
+    C4_ALWAYS_INLINE spanrs _select(T *p, I sz) const noexcept
+    {
+        C4_ASSERT(p >= m_ptr);
+        size_t delta = static_cast<size_t>(p - m_ptr);
+        C4_ASSERT(m_capacity >= delta);
+        return spanrs(p, sz, static_cast<size_t>(m_capacity - delta));
+    }
+
+public:
+
+    _c4_DEFINE_ARRAY_TYPES(T, I);
+    using NCT = typename std::remove_const<T>::type; //!< NCT=non const type
+    using CT = typename std::add_const<T>::type; //!< CT=const type
+    using const_type = spanrs<CT, I>;
+
+    /// convert automatically to span of T
+    C4_ALWAYS_INLINE operator span<T, I > () const noexcept { return span<T, I>(m_ptr, m_size); }
+    /// convert automatically to span of const T
+    //C4_ALWAYS_INLINE operator span<CT, I> () const noexcept { span<CT, I> s(m_ptr, m_size); return s; }
+    /// convert automatically to spanrs of const T
+    C4_ALWAYS_INLINE operator spanrs<CT, I> () const noexcept { spanrs<CT, I> s(m_ptr, m_size, m_capacity); return s; }
+
+public:
+
+    C4_ALWAYS_INLINE spanrs() noexcept : m_ptr{nullptr}, m_size{0}, m_capacity{0} {}
+
+    spanrs(spanrs const&) = default;
+    spanrs(spanrs     &&) = default;
+
+    spanrs& operator= (spanrs const&) = default;
+    spanrs& operator= (spanrs     &&) = default;
+
+public:
+
+    /** @name Construction and assignment from same type */
+    /** @{ */
+
+    C4_ALWAYS_INLINE      spanrs(T *p, I sz) noexcept : m_ptr{p}, m_size{sz}, m_capacity{sz} {}
+    /** @warning will reset the capacity to sz */
+    C4_ALWAYS_INLINE void assign(T *p, I sz) noexcept { m_ptr = p; m_size = sz; m_capacity = sz; }
+
+    C4_ALWAYS_INLINE      spanrs(T *p, I sz, I cap) noexcept : m_ptr{p}, m_size{sz}, m_capacity{cap} {}
+    C4_ALWAYS_INLINE void assign(T *p, I sz, I cap) noexcept { m_ptr = p; m_size = sz; m_capacity = cap; }
+
+    template<size_t N> C4_ALWAYS_INLINE      spanrs(T (&arr)[N]) noexcept : m_ptr{arr}, m_size{N}, m_capacity{N} {}
+    template<size_t N> C4_ALWAYS_INLINE void assign(T (&arr)[N]) noexcept { m_ptr = arr; m_size = N; m_capacity = N; }
+
+    C4_ALWAYS_INLINE      spanrs(c4::aggregate_t, std::initializer_list<T> il) noexcept : m_ptr{il.begin()}, m_size{il.size()}, m_capacity{il.size()} {}
+    C4_ALWAYS_INLINE void assign(c4::aggregate_t, std::initializer_list<T> il) noexcept { m_ptr = il.begin(); m_size = il.size(); m_capacity = il.size(); }
+
+    /** @} */
+
+public:
+
+    C4_ALWAYS_INLINE I capacity() const noexcept { return m_capacity; }
+
+    C4_ALWAYS_INLINE void resize(I sz) C4_NOEXCEPT_A { C4_ASSERT(sz <= m_capacity); m_size = sz; }
+    C4_ALWAYS_INLINE void rtrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; }
+    C4_ALWAYS_INLINE void ltrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; m_ptr += n; m_capacity -= n; }
+
+};
+template<class T, class I=C4_SIZE_TYPE> using cspanrs = spanrs<const T, I>;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A non-owning span which always retains the capacity of the original
+ * range it was taken from (though it may loose its original size).
+ * The resizing methods resize(), ltrim(), rtrim() as well
+ * as the subselection methods subspan(), range(), first() and last() can be
+ * used at will without loosing the original capacity; the full capacity span
+ * can always be recovered by calling original().
+ */
+template<class T, class I=C4_SIZE_TYPE>
+class spanrsl : public span_crtp<T, I, spanrsl<T, I>>
+{
+    friend class span_crtp<T, I, spanrsl<T, I>>;
+
+    T *C4_RESTRICT m_ptr;      ///< the current ptr. the original ptr is (m_ptr - m_offset).
+    I   m_size;     ///< the current size. the original size is unrecoverable.
+    I   m_capacity; ///< the current capacity. the original capacity is (m_capacity + m_offset).
+    I   m_offset;   ///< the offset of the current m_ptr to the start of the original memory block.
+
+    C4_ALWAYS_INLINE spanrsl _select(T *p, I sz) const noexcept
+    {
+        C4_ASSERT(p >= m_ptr);
+        I delta = static_cast<I>(p - m_ptr);
+        C4_ASSERT(m_capacity >= delta);
+        return spanrsl(p, sz, static_cast<I>(m_capacity - delta), m_offset + delta);
+    }
+
+public:
+
+    _c4_DEFINE_ARRAY_TYPES(T, I);
+    using NCT = typename std::remove_const<T>::type; //!< NCT=non const type
+    using CT = typename std::add_const<T>::type; //!< CT=const type
+    using const_type = spanrsl<CT, I>;
+
+    C4_ALWAYS_INLINE operator span<T, I> () const noexcept { return span<T, I>(m_ptr, m_size); }
+    C4_ALWAYS_INLINE operator spanrs<T, I> () const noexcept { return spanrs<T, I>(m_ptr, m_size, m_capacity); }
+    C4_ALWAYS_INLINE operator spanrsl<CT, I> () const noexcept { return spanrsl<CT, I>(m_ptr, m_size, m_capacity, m_offset); }
+
+public:
+
+    C4_ALWAYS_INLINE spanrsl() noexcept : m_ptr{nullptr}, m_size{0}, m_capacity{0}, m_offset{0} {}
+
+    spanrsl(spanrsl const&) = default;
+    spanrsl(spanrsl     &&) = default;
+
+    spanrsl& operator= (spanrsl const&) = default;
+    spanrsl& operator= (spanrsl     &&) = default;
+
+public:
+
+    C4_ALWAYS_INLINE     spanrsl(T *p, I sz) noexcept : m_ptr{p}, m_size{sz}, m_capacity{sz}, m_offset{0} {}
+    C4_ALWAYS_INLINE void assign(T *p, I sz) noexcept { m_ptr = p; m_size = sz; m_capacity = sz; m_offset = 0; }
+
+    C4_ALWAYS_INLINE     spanrsl(T *p, I sz, I cap) noexcept : m_ptr{p}, m_size{sz}, m_capacity{cap}, m_offset{0} {}
+    C4_ALWAYS_INLINE void assign(T *p, I sz, I cap) noexcept { m_ptr = p; m_size = sz; m_capacity = cap; m_offset = 0; }
+
+    C4_ALWAYS_INLINE     spanrsl(T *p, I sz, I cap, I offs) noexcept : m_ptr{p}, m_size{sz}, m_capacity{cap}, m_offset{offs} {}
+    C4_ALWAYS_INLINE void assign(T *p, I sz, I cap, I offs) noexcept { m_ptr = p; m_size = sz; m_capacity = cap; m_offset = offs; }
+
+    template<size_t N> C4_ALWAYS_INLINE     spanrsl(T (&arr)[N]) noexcept : m_ptr{arr}, m_size{N}, m_capacity{N}, m_offset{0} {}
+    template<size_t N> C4_ALWAYS_INLINE void assign(T (&arr)[N]) noexcept { m_ptr = arr; m_size = N; m_capacity = N; m_offset = 0; }
+
+    C4_ALWAYS_INLINE      spanrsl(c4::aggregate_t, std::initializer_list<T> il) noexcept : m_ptr{il.begin()}, m_size{il.size()}, m_capacity{il.size()}, m_offset{0} {}
+    C4_ALWAYS_INLINE void assign (c4::aggregate_t, std::initializer_list<T> il) noexcept { m_ptr = il.begin(); m_size = il.size(); m_capacity = il.size(); m_offset = 0; }
+
+public:
+
+    C4_ALWAYS_INLINE I offset() const noexcept { return m_offset; }
+    C4_ALWAYS_INLINE I capacity() const noexcept { return m_capacity; }
+
+    C4_ALWAYS_INLINE void resize(I sz) C4_NOEXCEPT_A { C4_ASSERT(sz <= m_capacity); m_size = sz; }
+    C4_ALWAYS_INLINE void rtrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; }
+    C4_ALWAYS_INLINE void ltrim (I n ) C4_NOEXCEPT_A { C4_ASSERT(n >= 0 && n < m_size); m_size -= n; m_ptr += n; m_offset += n; m_capacity -= n; }
+
+    /** recover the original span as an spanrsl */
+    C4_ALWAYS_INLINE spanrsl original() const
+    {
+        return spanrsl(m_ptr - m_offset, m_capacity + m_offset, m_capacity + m_offset, 0);
+    }
+    /** recover the original span as a different span type. Example: spanrs<...> orig = s.original<spanrs>(); */
+    template<template<class, class> class OtherSpanType>
+    C4_ALWAYS_INLINE OtherSpanType<T, I> original()
+    {
+        return OtherSpanType<T, I>(m_ptr - m_offset, m_capacity + m_offset);
+    }
+};
+template<class T, class I=C4_SIZE_TYPE> using cspanrsl = spanrsl<const T, I>;
+
+
+} // namespace c4
+
+
+#endif /* _C4_SPAN_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/span.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/type_name.hpp
+// https://github.com/biojppm/c4core/src/c4/type_name.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_TYPENAME_HPP_
+#define _C4_TYPENAME_HPP_
+
+/** @file type_name.hpp compile-time type name */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/span.hpp
+//#include "c4/span.hpp"
+#if !defined(C4_SPAN_HPP_) && !defined(_C4_SPAN_HPP_)
+#error "amalgamate: file c4/span.hpp must have been included at this point"
+#endif /* C4_SPAN_HPP_ */
+
+
+/// @cond dev
+struct _c4t
+{
+    const char *str;
+    size_t sz;
+    template<size_t N>
+    constexpr _c4t(const char (&s)[N]) : str(s), sz(N-1) {} // take off the \0
+};
+// this is a more abbreviated way of getting the type name
+// (if we used span in the return type, the name would involve
+// templates and would create longer type name strings,
+// as well as larger differences between compilers)
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE
+_c4t _c4tn()
+{
+    auto p = _c4t(C4_PRETTY_FUNC);
+    return p;
+}
+/// @endcond
+
+
+namespace c4 {
+
+/** compile-time type name
+ * @see http://stackoverflow.com/a/20170989/5875572 */
+template<class T>
+C4_CONSTEXPR14 cspan<char> type_name()
+{
+    const _c4t p = _c4tn<T>();
+
+#if (0) // _C4_THIS_IS_A_DEBUG_SCAFFOLD
+    for(size_t index = 0; index < p.sz; ++index)
+    {
+        printf(" %2c", p.str[index]);
+    }
+    printf("\n");
+    for(size_t index = 0; index < p.sz; ++index)
+    {
+        printf(" %2d", (int)index);
+    }
+    printf("\n");
+#endif
+
+#if defined(_MSC_VER)
+#   if defined(__clang__) // Visual Studio has the clang toolset
+    // example:
+    // ..........................xxx.
+    // _c4t __cdecl _c4tn() [T = int]
+    enum : size_t { tstart = 26, tend = 1};
+
+#   elif defined(C4_MSVC_2015) || defined(C4_MSVC_2017) || defined(C4_MSVC_2019) || defined(C4_MSVC_2022)
+    // Note: subtract 7 at the end because the function terminates with ">(void)" in VS2015+
+    cspan<char>::size_type tstart = 26, tend = 7;
+
+    const char *s = p.str + tstart; // look at the start
+
+    // we're not using strcmp() or memcmp() to spare the #include
+
+    // does it start with 'class '?
+    if(p.sz > 6 && s[0] == 'c' && s[1] == 'l' && s[2] == 'a' && s[3] == 's' && s[4] == 's' && s[5] == ' ')
+    {
+        tstart += 6;
+    }
+    // does it start with 'struct '?
+    else if(p.sz > 7 && s[0] == 's' && s[1] == 't' && s[2] == 'r' && s[3] == 'u' && s[4] == 'c' && s[5] == 't' && s[6] == ' ')
+    {
+        tstart += 7;
+    }
+
+#   else
+    C4_NOT_IMPLEMENTED();
+#   endif
+
+#elif defined(__ICC)
+    // example:
+    // ........................xxx.
+    // "_c4t _c4tn() [with T = int]"
+    enum : size_t { tstart = 23, tend = 1};
+
+#elif defined(__clang__)
+    // example:
+    // ...................xxx.
+    // "_c4t _c4tn() [T = int]"
+    enum : size_t { tstart = 18, tend = 1};
+
+#elif defined(__GNUC__)
+    #if __GNUC__ >= 7 && C4_CPP >= 14
+        // example:
+        // ..................................xxx.
+        // "constexpr _c4t _c4tn() [with T = int]"
+        enum : size_t { tstart = 33, tend = 1 };
+    #else
+        // example:
+        // ........................xxx.
+        // "_c4t _c4tn() [with T = int]"
+        enum : size_t { tstart = 23, tend = 1 };
+    #endif
+#else
+    C4_NOT_IMPLEMENTED();
+#endif
+
+    cspan<char> o(p.str + tstart, p.sz - tstart - tend);
+
+    return o;
+}
+
+/** compile-time type name
+ * @overload */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE cspan<char> type_name(T const&)
+{
+    return type_name<T>();
+}
+
+} // namespace c4
+
+#endif //_C4_TYPENAME_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/type_name.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/base64.hpp
+// https://github.com/biojppm/c4core/src/c4/base64.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_BASE64_HPP_
+#define _C4_BASE64_HPP_
+
+/** @file base64.hpp encoding/decoding for base64.
+ * @see https://en.wikipedia.org/wiki/Base64
+ * @see https://www.base64encode.org/
+ * */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/charconv.hpp
+//#include "c4/charconv.hpp"
+#if !defined(C4_CHARCONV_HPP_) && !defined(_C4_CHARCONV_HPP_)
+#error "amalgamate: file c4/charconv.hpp must have been included at this point"
+#endif /* C4_CHARCONV_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/blob.hpp
+//#include "c4/blob.hpp"
+#if !defined(C4_BLOB_HPP_) && !defined(_C4_BLOB_HPP_)
+#error "amalgamate: file c4/blob.hpp must have been included at this point"
+#endif /* C4_BLOB_HPP_ */
+
+
+namespace c4 {
+
+/** check that the given buffer is a valid base64 encoding
+ * @see https://en.wikipedia.org/wiki/Base64 */
+bool base64_valid(csubstr encoded);
+
+/** base64-encode binary data.
+ * @param encoded [out] output buffer for encoded data
+ * @param data [in] the input buffer with the binary data
+ * @return the number of bytes needed to return the output. No writes occur beyond the end of the output buffer.
+ * @see https://en.wikipedia.org/wiki/Base64 */
+size_t base64_encode(substr encoded, cblob data);
+
+/** decode the base64 encoding in the given buffer
+ * @param encoded [in] the encoded base64
+ * @param data [out] the output buffer
+ * @return the number of bytes needed to return the output.. No writes occur beyond the end of the output buffer.
+ * @see https://en.wikipedia.org/wiki/Base64 */
+size_t base64_decode(csubstr encoded, blob data);
+
+
+namespace fmt {
+
+template<typename CharOrConstChar>
+struct base64_wrapper_
+{
+    blob_<CharOrConstChar> data;
+    base64_wrapper_() : data() {}
+    base64_wrapper_(blob_<CharOrConstChar> blob) : data(blob) {}
+};
+using const_base64_wrapper = base64_wrapper_<cbyte>;
+using base64_wrapper = base64_wrapper_<byte>;
+
+
+/** mark a variable to be written in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE const_base64_wrapper cbase64(Args const& C4_RESTRICT ...args)
+{
+    return const_base64_wrapper(cblob(args...));
+}
+/** mark a csubstr to be written in base64 format */
+C4_ALWAYS_INLINE const_base64_wrapper cbase64(csubstr s)
+{
+    return const_base64_wrapper(cblob(s.str, s.len));
+}
+/** mark a variable to be written in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE const_base64_wrapper base64(Args const& C4_RESTRICT ...args)
+{
+    return const_base64_wrapper(cblob(args...));
+}
+/** mark a csubstr to be written in base64 format */
+C4_ALWAYS_INLINE const_base64_wrapper base64(csubstr s)
+{
+    return const_base64_wrapper(cblob(s.str, s.len));
+}
+
+/** mark a variable to be read in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE base64_wrapper base64(Args &... args)
+{
+    return base64_wrapper(blob(args...));
+}
+/** mark a variable to be read in base64 format */
+C4_ALWAYS_INLINE base64_wrapper base64(substr s)
+{
+    return base64_wrapper(blob(s.str, s.len));
+}
+
+} // namespace fmt
+
+
+/** write a variable in base64 format */
+inline size_t to_chars(substr buf, fmt::const_base64_wrapper b)
+{
+    return base64_encode(buf, b.data);
+}
+
+/** read a variable in base64 format */
+inline size_t from_chars(csubstr buf, fmt::base64_wrapper *b)
+{
+    return base64_decode(buf, b->data);
+}
+
+} // namespace c4
+
+#endif /* _C4_BASE64_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/base64.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/string.hpp
+// https://github.com/biojppm/c4core/src/c4/std/string.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_STRING_HPP_
+#define _C4_STD_STRING_HPP_
+
+/** @file string.hpp */
+
+#ifndef C4CORE_SINGLE_HEADER
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr.hpp
+//#include "c4/substr.hpp"
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+#endif
+
+//included above:
+//#include <string>
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+
+/** get a writeable view to an existing std::string */
+inline c4::substr to_substr(std::string &s)
+{
+    char* data = ! s.empty() ? &s[0] : nullptr;
+    return c4::substr(data, s.size());
+}
+
+/** get a readonly view to an existing std::string */
+inline c4::csubstr to_csubstr(std::string const& s)
+{
+    const char* data = ! s.empty() ? &s[0] : nullptr;
+    return c4::csubstr(data, s.size());
+}
+
+//-----------------------------------------------------------------------------
+
+C4_ALWAYS_INLINE bool operator== (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) == 0; }
+C4_ALWAYS_INLINE bool operator!= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) != 0; }
+C4_ALWAYS_INLINE bool operator>= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) >= 0; }
+C4_ALWAYS_INLINE bool operator>  (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) >  0; }
+C4_ALWAYS_INLINE bool operator<= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) <= 0; }
+C4_ALWAYS_INLINE bool operator<  (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) <  0; }
+
+C4_ALWAYS_INLINE bool operator== (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) == 0; }
+C4_ALWAYS_INLINE bool operator!= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) != 0; }
+C4_ALWAYS_INLINE bool operator>= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) <= 0; }
+C4_ALWAYS_INLINE bool operator>  (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) <  0; }
+C4_ALWAYS_INLINE bool operator<= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) >= 0; }
+C4_ALWAYS_INLINE bool operator<  (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) >  0; }
+
+//-----------------------------------------------------------------------------
+
+/** copy an std::string to a writeable string view */
+inline size_t to_chars(c4::substr buf, std::string const& s)
+{
+    C4_ASSERT(!buf.overlaps(to_csubstr(s)));
+    size_t len = buf.len < s.size() ? buf.len : s.size();
+    memcpy(buf.str, s.data(), len);
+    return s.size(); // return the number of needed chars
+}
+
+/** copy a string view to an existing std::string */
+inline bool from_chars(c4::csubstr buf, std::string * s)
+{
+    s->resize(buf.len);
+    C4_ASSERT(!buf.overlaps(to_csubstr(*s)));
+    memcpy(&(*s)[0], buf.str, buf.len);
+    return true;
+}
+
+} // namespace c4
+
+#endif // _C4_STD_STRING_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/string.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/vector.hpp
+// https://github.com/biojppm/c4core/src/c4/std/vector.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_VECTOR_HPP_
+#define _C4_STD_VECTOR_HPP_
+
+/** @file vector.hpp provides conversion and comparison facilities
+ * from/between std::vector<char> to c4::substr and c4::csubstr.
+ * @todo add to_span() and friends
+ */
+
+#ifndef C4CORE_SINGLE_HEADER
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/substr.hpp
+//#include "c4/substr.hpp"
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+#endif
+
+#include <vector>
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+
+/** get a substr (writeable string view) of an existing std::vector<char> */
+template<class Alloc>
+c4::substr to_substr(std::vector<char, Alloc> &vec)
+{
+    char *data = vec.empty() ? nullptr : vec.data(); // data() may or may not return a null pointer.
+    return c4::substr(data, vec.size());
+}
+
+/** get a csubstr (read-only string) view of an existing std::vector<char> */
+template<class Alloc>
+c4::csubstr to_csubstr(std::vector<char, Alloc> const& vec)
+{
+    const char *data = vec.empty() ? nullptr : vec.data(); // data() may or may not return a null pointer.
+    return c4::csubstr(data, vec.size());
+}
+
+//-----------------------------------------------------------------------------
+// comparisons between substrings and std::vector<char>
+
+template<class Alloc> C4_ALWAYS_INLINE bool operator!= (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss != to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator== (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss == to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator>= (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss >= to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator>  (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss >  to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator<= (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss <= to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator<  (c4::csubstr ss, std::vector<char, Alloc> const& s) { return ss <  to_csubstr(s); }
+
+template<class Alloc> C4_ALWAYS_INLINE bool operator!= (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss != to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator== (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss == to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator>= (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss <= to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator>  (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss <  to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator<= (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss >= to_csubstr(s); }
+template<class Alloc> C4_ALWAYS_INLINE bool operator<  (std::vector<char, Alloc> const& s, c4::csubstr ss) { return ss >  to_csubstr(s); }
+
+//-----------------------------------------------------------------------------
+
+/** copy a std::vector<char> to a writeable string view */
+template<class Alloc>
+inline size_t to_chars(c4::substr buf, std::vector<char, Alloc> const& s)
+{
+    C4_ASSERT(!buf.overlaps(to_csubstr(s)));
+    size_t len = buf.len < s.size() ? buf.len : s.size();
+    memcpy(buf.str, s.data(), len);
+    return s.size(); // return the number of needed chars
+}
+
+/** copy a string view to an existing std::vector<char> */
+template<class Alloc>
+inline bool from_chars(c4::csubstr buf, std::vector<char, Alloc> * s)
+{
+    s->resize(buf.len);
+    C4_ASSERT(!buf.overlaps(to_csubstr(*s)));
+    memcpy(&(*s)[0], buf.str, buf.len);
+    return true;
+}
+
+} // namespace c4
+
+#endif // _C4_STD_VECTOR_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/vector.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/tuple.hpp
+// https://github.com/biojppm/c4core/src/c4/std/tuple.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_TUPLE_HPP_
+#define _C4_STD_TUPLE_HPP_
+
+/** @file tuple.hpp */
+
+#ifndef C4CORE_SINGLE_HEADER
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/format.hpp
+//#include "c4/format.hpp"
+#if !defined(C4_FORMAT_HPP_) && !defined(_C4_FORMAT_HPP_)
+#error "amalgamate: file c4/format.hpp must have been included at this point"
+#endif /* C4_FORMAT_HPP_ */
+
+#endif
+
+#include <tuple>
+
+/** this is a work in progress */
+#undef C4_TUPLE_TO_CHARS
+
+namespace c4 {
+
+#ifdef C4_TUPLE_TO_CHARS
+namespace detail {
+
+template< size_t Curr, class... Types >
+struct tuple_helper
+{
+    static size_t do_cat(substr buf, std::tuple< Types... > const& tp)
+    {
+        size_t num = to_chars(buf, std::get<Curr>(tp));
+        buf = buf.len >= num ? buf.sub(num) : substr{};
+        num += tuple_helper< Curr+1, Types... >::do_cat(buf, tp);
+        return num;
+    }
+
+    static size_t do_uncat(csubstr buf, std::tuple< Types... > & tp)
+    {
+        size_t num = from_str_trim(buf, &std::get<Curr>(tp));
+        if(num == csubstr::npos) return csubstr::npos;
+        buf = buf.len >= num ? buf.sub(num) : substr{};
+        num += tuple_helper< Curr+1, Types... >::do_uncat(buf, tp);
+        return num;
+    }
+
+    template< class Sep >
+    static size_t do_catsep_more(substr buf, Sep const& sep, std::tuple< Types... > const& tp)
+    {
+        size_t ret = to_chars(buf, sep), num = ret;
+        buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+        ret  = to_chars(buf, std::get<Curr>(tp));
+        num += ret;
+        buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+        ret  = tuple_helper< Curr+1, Types... >::do_catsep_more(buf, sep, tp);
+        num += ret;
+        return num;
+    }
+
+    template< class Sep >
+    static size_t do_uncatsep_more(csubstr buf, Sep & sep, std::tuple< Types... > & tp)
+    {
+        size_t ret = from_str_trim(buf, &sep), num = ret;
+        if(ret == csubstr::npos) return csubstr::npos;
+        buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+        ret  = from_str_trim(buf, &std::get<Curr>(tp));
+        if(ret == csubstr::npos) return csubstr::npos;
+        num += ret;
+        buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+        ret  = tuple_helper< Curr+1, Types... >::do_uncatsep_more(buf, sep, tp);
+        if(ret == csubstr::npos) return csubstr::npos;
+        num += ret;
+        return num;
+    }
+
+    static size_t do_format(substr buf, csubstr fmt, std::tuple< Types... > const& tp)
+    {
+        auto pos = fmt.find("{}");
+        if(pos != csubstr::npos)
+        {
+            size_t num = to_chars(buf, fmt.sub(0, pos));
+            size_t out = num;
+            buf  = buf.len >= num ? buf.sub(num) : substr{};
+            num  = to_chars(buf, std::get<Curr>(tp));
+            out += num;
+            buf  = buf.len >= num ? buf.sub(num) : substr{};
+            num  = tuple_helper< Curr+1, Types... >::do_format(buf, fmt.sub(pos + 2), tp);
+            out += num;
+            return out;
+        }
+        else
+        {
+            return format(buf, fmt);
+        }
+    }
+
+    static size_t do_unformat(csubstr buf, csubstr fmt, std::tuple< Types... > & tp)
+    {
+        auto pos = fmt.find("{}");
+        if(pos != csubstr::npos)
+        {
+            size_t num = pos;
+            size_t out = num;
+            buf  = buf.len >= num ? buf.sub(num) : substr{};
+            num  = from_str_trim(buf, &std::get<Curr>(tp));
+            out += num;
+            buf  = buf.len >= num ? buf.sub(num) : substr{};
+            num  = tuple_helper< Curr+1, Types... >::do_unformat(buf, fmt.sub(pos + 2), tp);
+            out += num;
+            return out;
+        }
+        else
+        {
+            return tuple_helper< sizeof...(Types), Types... >::do_unformat(buf, fmt, tp);
+        }
+    }
+
+};
+
+/** @todo VS compilation fails for this class */
+template< class... Types >
+struct tuple_helper< sizeof...(Types), Types... >
+{
+    static size_t do_cat(substr /*buf*/, std::tuple<Types...> const& /*tp*/) { return 0; }
+    static size_t do_uncat(csubstr /*buf*/, std::tuple<Types...> & /*tp*/) { return 0; }
+
+    template< class Sep > static size_t do_catsep_more(substr /*buf*/, Sep const& /*sep*/, std::tuple<Types...> const& /*tp*/) { return 0; }
+    template< class Sep > static size_t do_uncatsep_more(csubstr /*buf*/, Sep & /*sep*/, std::tuple<Types...> & /*tp*/) { return 0; }
+
+    static size_t do_format(substr buf, csubstr fmt, std::tuple<Types...> const& /*tp*/)
+    {
+        return to_chars(buf, fmt);
+    }
+
+    static size_t do_unformat(csubstr buf, csubstr fmt, std::tuple<Types...> const& /*tp*/)
+    {
+        return 0;
+    }
+};
+
+} // namespace detail
+
+template< class... Types >
+inline size_t cat(substr buf, std::tuple< Types... > const& tp)
+{
+    return detail::tuple_helper< 0, Types... >::do_cat(buf, tp);
+}
+
+template< class... Types >
+inline size_t uncat(csubstr buf, std::tuple< Types... > & tp)
+{
+    return detail::tuple_helper< 0, Types... >::do_uncat(buf, tp);
+}
+
+template< class Sep, class... Types >
+inline size_t catsep(substr buf, Sep const& sep, std::tuple< Types... > const& tp)
+{
+    size_t num = to_chars(buf, std::cref(std::get<0>(tp)));
+    buf  = buf.len >= num ? buf.sub(num) : substr{};
+    num += detail::tuple_helper< 1, Types... >::do_catsep_more(buf, sep, tp);
+    return num;
+}
+
+template< class Sep, class... Types >
+inline size_t uncatsep(csubstr buf, Sep & sep, std::tuple< Types... > & tp)
+{
+    size_t ret = from_str_trim(buf, &std::get<0>(tp)), num = ret;
+    if(ret == csubstr::npos) return csubstr::npos;
+    buf  = buf.len >= ret ? buf.sub(ret) : substr{};
+    ret  = detail::tuple_helper< 1, Types... >::do_uncatsep_more(buf, sep, tp);
+    if(ret == csubstr::npos) return csubstr::npos;
+    num += ret;
+    return num;
+}
+
+template< class... Types >
+inline size_t format(substr buf, csubstr fmt, std::tuple< Types... > const& tp)
+{
+    return detail::tuple_helper< 0, Types... >::do_format(buf, fmt, tp);
+}
+
+template< class... Types >
+inline size_t unformat(csubstr buf, csubstr fmt, std::tuple< Types... > & tp)
+{
+    return detail::tuple_helper< 0, Types... >::do_unformat(buf, fmt, tp);
+}
+#endif // C4_TUPLE_TO_CHARS
+
+} // namespace c4
+
+#endif /* _C4_STD_TUPLE_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/tuple.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/ext/rng/rng.hpp
+// https://github.com/biojppm/c4core/src/c4/ext/rng/rng.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+/* Copyright (c) 2018 Arvid Gerstmann.
+ *
+ * https://arvid.io/2018/07/02/better-cxx-prng/
+ *
+ * This code is licensed under MIT license. */
+#ifndef AG_RANDOM_H
+#define AG_RANDOM_H
+
+//included above:
+//#include <stdint.h>
+#include <random>
+
+
+namespace c4 {
+namespace rng {
+
+
+class splitmix
+{
+public:
+    using result_type = uint32_t;
+    static constexpr result_type (min)() { return 0; }
+    static constexpr result_type (max)() { return UINT32_MAX; }
+    friend bool operator==(splitmix const &, splitmix const &);
+    friend bool operator!=(splitmix const &, splitmix const &);
+
+    splitmix() : m_seed(1) {}
+    explicit splitmix(std::random_device &rd)
+    {
+        seed(rd);
+    }
+
+    void seed(std::random_device &rd)
+    {
+        m_seed = uint64_t(rd()) << 31 | uint64_t(rd());
+    }
+
+    result_type operator()()
+    {
+        uint64_t z = (m_seed += UINT64_C(0x9E3779B97F4A7C15));
+        z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
+        z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
+        return result_type((z ^ (z >> 31)) >> 31);
+    }
+
+    void discard(unsigned long long n)
+    {
+        for (unsigned long long i = 0; i < n; ++i)
+            operator()();
+    }
+
+private:
+    uint64_t m_seed;
+};
+
+inline bool operator==(splitmix const &lhs, splitmix const &rhs)
+{
+    return lhs.m_seed == rhs.m_seed;
+}
+inline bool operator!=(splitmix const &lhs, splitmix const &rhs)
+{
+    return lhs.m_seed != rhs.m_seed;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+class xorshift
+{
+public:
+    using result_type = uint32_t;
+    static constexpr result_type (min)() { return 0; }
+    static constexpr result_type (max)() { return UINT32_MAX; }
+    friend bool operator==(xorshift const &, xorshift const &);
+    friend bool operator!=(xorshift const &, xorshift const &);
+
+    xorshift() : m_seed(0xc1f651c67c62c6e0ull) {}
+    explicit xorshift(std::random_device &rd)
+    {
+        seed(rd);
+    }
+
+    void seed(std::random_device &rd)
+    {
+        m_seed = uint64_t(rd()) << 31 | uint64_t(rd());
+    }
+
+    result_type operator()()
+    {
+        uint64_t result = m_seed * 0xd989bcacc137dcd5ull;
+        m_seed ^= m_seed >> 11;
+        m_seed ^= m_seed << 31;
+        m_seed ^= m_seed >> 18;
+        return uint32_t(result >> 32ull);
+    }
+
+    void discard(unsigned long long n)
+    {
+        for (unsigned long long i = 0; i < n; ++i)
+            operator()();
+    }
+
+private:
+    uint64_t m_seed;
+};
+
+inline bool operator==(xorshift const &lhs, xorshift const &rhs)
+{
+    return lhs.m_seed == rhs.m_seed;
+}
+inline bool operator!=(xorshift const &lhs, xorshift const &rhs)
+{
+    return lhs.m_seed != rhs.m_seed;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+class pcg
+{
+public:
+    using result_type = uint32_t;
+    static constexpr result_type (min)() { return 0; }
+    static constexpr result_type (max)() { return UINT32_MAX; }
+    friend bool operator==(pcg const &, pcg const &);
+    friend bool operator!=(pcg const &, pcg const &);
+
+    pcg()
+        : m_state(0x853c49e6748fea9bULL)
+        , m_inc(0xda3e39cb94b95bdbULL)
+    {}
+    explicit pcg(std::random_device &rd)
+    {
+        seed(rd);
+    }
+
+    void seed(std::random_device &rd)
+    {
+        uint64_t s0 = uint64_t(rd()) << 31 | uint64_t(rd());
+        uint64_t s1 = uint64_t(rd()) << 31 | uint64_t(rd());
+
+        m_state = 0;
+        m_inc = (s1 << 1) | 1;
+        (void)operator()();
+        m_state += s0;
+        (void)operator()();
+    }
+
+    result_type operator()()
+    {
+        uint64_t oldstate = m_state;
+        m_state = oldstate * 6364136223846793005ULL + m_inc;
+        uint32_t xorshifted = uint32_t(((oldstate >> 18u) ^ oldstate) >> 27u);
+        //int rot = oldstate >> 59u; // the original. error?
+        int64_t rot = (int64_t)oldstate >> 59u; // error?
+        return (xorshifted >> rot) | (xorshifted << ((uint64_t)(-rot) & 31));
+    }
+
+    void discard(unsigned long long n)
+    {
+        for (unsigned long long i = 0; i < n; ++i)
+            operator()();
+    }
+
+private:
+    uint64_t m_state;
+    uint64_t m_inc;
+};
+
+inline bool operator==(pcg const &lhs, pcg const &rhs)
+{
+    return lhs.m_state == rhs.m_state
+        && lhs.m_inc == rhs.m_inc;
+}
+inline bool operator!=(pcg const &lhs, pcg const &rhs)
+{
+    return lhs.m_state != rhs.m_state
+        || lhs.m_inc != rhs.m_inc;
+}
+
+} // namespace rng
+} // namespace c4
+
+#endif /* AG_RANDOM_H */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/ext/rng/rng.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/ext/sg14/inplace_function.h
+// https://github.com/biojppm/c4core/src/c4/ext/sg14/inplace_function.h
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+/*
+ * Boost Software License - Version 1.0 - August 17th, 2003
+ *
+ * Permission is hereby granted, free of charge, to any person or organization
+ * obtaining a copy of the software and accompanying documentation covered by
+ * this license (the "Software") to use, reproduce, display, distribute,
+ * execute, and transmit the Software, and to prepare derivative works of the
+ * Software, and to permit third-parties to whom the Software is furnished to
+ * do so, all subject to the following:
+ *
+ * The copyright notices in the Software and this entire statement, including
+ * the above license grant, this restriction and the following disclaimer,
+ * must be included in all copies of the Software, in whole or in part, and
+ * all derivative works of the Software, unless such copies or derivative
+ * works are solely in the form of machine-executable object code generated by
+ * a source language processor.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+ * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+ * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef _C4_EXT_SG14_INPLACE_FUNCTION_H_
+#define _C4_EXT_SG14_INPLACE_FUNCTION_H_
+
+//included above:
+//#include <type_traits>
+//included above:
+//#include <utility>
+#include <functional>
+
+namespace stdext {
+
+namespace inplace_function_detail {
+
+static constexpr size_t InplaceFunctionDefaultCapacity = 32;
+
+#if defined(__GLIBCXX__)  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61458
+template<size_t Cap>
+union aligned_storage_helper {
+    struct double1 { double a; };
+    struct double4 { double a[4]; };
+    template<class T> using maybe = typename std::conditional<(Cap >= sizeof(T)), T, char>::type;
+    char real_data[Cap];
+    maybe<int> a;
+    maybe<long> b;
+    maybe<long long> c;
+    maybe<void*> d;
+    maybe<void(*)()> e;
+    maybe<double1> f;
+    maybe<double4> g;
+    maybe<long double> h;
+};
+
+template<size_t Cap, size_t Align = std::alignment_of<aligned_storage_helper<Cap>>::value>
+struct aligned_storage {
+    using type = typename std::aligned_storage<Cap, Align>::type;
+};
+#else
+using std::aligned_storage;
+#endif
+
+template<typename T> struct wrapper
+{
+    using type = T;
+};
+
+template<typename R, typename... Args> struct vtable
+{
+    using storage_ptr_t = void*;
+
+    using invoke_ptr_t = R(*)(storage_ptr_t, Args&&...);
+    using process_ptr_t = void(*)(storage_ptr_t, storage_ptr_t);
+    using destructor_ptr_t = void(*)(storage_ptr_t);
+
+    const invoke_ptr_t invoke_ptr;
+    const process_ptr_t copy_ptr;
+    const process_ptr_t move_ptr;
+    const destructor_ptr_t destructor_ptr;
+
+    explicit constexpr vtable() noexcept :
+        invoke_ptr{ [](storage_ptr_t, Args&&...) -> R
+            { throw std::bad_function_call(); }
+        },
+        copy_ptr{ [](storage_ptr_t, storage_ptr_t) noexcept -> void {} },
+        move_ptr{ [](storage_ptr_t, storage_ptr_t) noexcept -> void {} },
+        destructor_ptr{ [](storage_ptr_t) noexcept -> void {} }
+    {}
+
+    template<typename C> explicit constexpr vtable(wrapper<C>) noexcept :
+        invoke_ptr{ [](storage_ptr_t storage_ptr, Args&&... args)
+            noexcept(noexcept(std::declval<C>()(args...))) -> R
+            { return (*static_cast<C*>(storage_ptr))(
+                std::forward<Args>(args)...
+            ); }
+        },
+        copy_ptr{ [](storage_ptr_t dst_ptr, storage_ptr_t src_ptr)
+            noexcept(std::is_nothrow_copy_constructible<C>::value) -> void
+            { new (dst_ptr) C{ (*static_cast<C*>(src_ptr)) }; }
+        },
+        move_ptr{ [](storage_ptr_t dst_ptr, storage_ptr_t src_ptr)
+            noexcept(std::is_nothrow_move_constructible<C>::value) -> void
+            { new (dst_ptr) C{ std::move(*static_cast<C*>(src_ptr)) }; }
+        },
+        destructor_ptr{ [](storage_ptr_t storage_ptr)
+            noexcept -> void
+            { static_cast<C*>(storage_ptr)->~C(); }
+        }
+    {}
+
+    vtable(const vtable&) = delete;
+    vtable(vtable&&) = delete;
+
+    vtable& operator= (const vtable&) = delete;
+    vtable& operator= (vtable&&) = delete;
+
+    ~vtable() = default;
+};
+
+template<size_t DstCap, size_t DstAlign, size_t SrcCap, size_t SrcAlign>
+struct is_valid_inplace_dst : std::true_type
+{
+    static_assert(DstCap >= SrcCap,
+        "Can't squeeze larger inplace_function into a smaller one"
+    );
+
+    static_assert(DstAlign % SrcAlign == 0,
+        "Incompatible inplace_function alignments"
+    );
+};
+
+} // namespace inplace_function_detail
+
+template<
+    typename Signature,
+    size_t Capacity = inplace_function_detail::InplaceFunctionDefaultCapacity,
+    size_t Alignment = std::alignment_of<typename inplace_function_detail::aligned_storage<Capacity>::type>::value
+>
+class inplace_function; // unspecified
+
+template<
+    typename R,
+    typename... Args,
+    size_t Capacity,
+    size_t Alignment
+>
+class inplace_function<R(Args...), Capacity, Alignment>
+{
+    static const constexpr inplace_function_detail::vtable<R, Args...> empty_vtable{};
+public:
+    using capacity = std::integral_constant<size_t, Capacity>;
+    using alignment = std::integral_constant<size_t, Alignment>;
+
+    using storage_t = typename inplace_function_detail::aligned_storage<Capacity, Alignment>::type;
+    using vtable_t = inplace_function_detail::vtable<R, Args...>;
+    using vtable_ptr_t = const vtable_t*;
+
+    template <typename, size_t, size_t>	friend class inplace_function;
+
+    inplace_function() noexcept :
+        vtable_ptr_{std::addressof(empty_vtable)}
+    {}
+
+    template<
+        typename T,
+        typename C = typename std::decay<T>::type,
+        typename = typename std::enable_if<
+            !(std::is_same<C, inplace_function>::value
+            || std::is_convertible<C, inplace_function>::value)
+        >::type
+    >
+    inplace_function(T&& closure)
+    {
+#if __cplusplus >= 201703L
+        static_assert(std::is_invocable_r<R, C, Args...>::value,
+            "inplace_function cannot be constructed from non-callable type"
+        );
+#endif
+        static_assert(std::is_copy_constructible<C>::value,
+            "inplace_function cannot be constructed from non-copyable type"
+        );
+
+        static_assert(sizeof(C) <= Capacity,
+            "inplace_function cannot be constructed from object with this (large) size"
+        );
+
+        static_assert(Alignment % std::alignment_of<C>::value == 0,
+            "inplace_function cannot be constructed from object with this (large) alignment"
+        );
+
+        static const vtable_t vt{inplace_function_detail::wrapper<C>{}};
+        vtable_ptr_ = std::addressof(vt);
+
+        new (std::addressof(storage_)) C{std::forward<T>(closure)};
+    }
+
+    inplace_function(std::nullptr_t) noexcept :
+        vtable_ptr_{std::addressof(empty_vtable)}
+    {}
+
+    inplace_function(const inplace_function& other) :
+        vtable_ptr_{other.vtable_ptr_}
+    {
+        vtable_ptr_->copy_ptr(
+            std::addressof(storage_),
+            std::addressof(other.storage_)
+        );
+    }
+
+    inplace_function(inplace_function&& other) :
+        vtable_ptr_{other.vtable_ptr_}
+    {
+        vtable_ptr_->move_ptr(
+            std::addressof(storage_),
+            std::addressof(other.storage_)
+        );
+    }
+
+    inplace_function& operator= (std::nullptr_t) noexcept
+    {
+        vtable_ptr_->destructor_ptr(std::addressof(storage_));
+        vtable_ptr_ = std::addressof(empty_vtable);
+        return *this;
+    }
+
+    inplace_function& operator= (const inplace_function& other)
+    {
+        if(this != std::addressof(other))
+        {
+            vtable_ptr_->destructor_ptr(std::addressof(storage_));
+
+            vtable_ptr_ = other.vtable_ptr_;
+            vtable_ptr_->copy_ptr(
+                std::addressof(storage_),
+                std::addressof(other.storage_)
+            );
+        }
+        return *this;
+    }
+
+    inplace_function& operator= (inplace_function&& other)
+    {
+        if(this != std::addressof(other))
+        {
+            vtable_ptr_->destructor_ptr(std::addressof(storage_));
+
+            vtable_ptr_ = other.vtable_ptr_;
+            vtable_ptr_->move_ptr(
+                std::addressof(storage_),
+                std::addressof(other.storage_)
+            );
+        }
+        return *this;
+    }
+
+    ~inplace_function()
+    {
+        vtable_ptr_->destructor_ptr(std::addressof(storage_));
+    }
+
+    R operator() (Args... args) const
+    {
+        return vtable_ptr_->invoke_ptr(
+            std::addressof(storage_),
+            std::forward<Args>(args)...
+        );
+    }
+
+    constexpr bool operator== (std::nullptr_t) const noexcept
+    {
+        return !operator bool();
+    }
+
+    constexpr bool operator!= (std::nullptr_t) const noexcept
+    {
+        return operator bool();
+    }
+
+    explicit constexpr operator bool() const noexcept
+    {
+        return vtable_ptr_ != std::addressof(empty_vtable);
+    }
+
+    template<size_t Cap, size_t Align>
+    operator inplace_function<R(Args...), Cap, Align>() const&
+    {
+        static_assert(inplace_function_detail::is_valid_inplace_dst<
+            Cap, Align, Capacity, Alignment
+        >::value, "conversion not allowed");
+
+        return {vtable_ptr_, vtable_ptr_->copy_ptr, std::addressof(storage_)};
+    }
+
+    template<size_t Cap, size_t Align>
+    operator inplace_function<R(Args...), Cap, Align>() &&
+    {
+        static_assert(inplace_function_detail::is_valid_inplace_dst<
+            Cap, Align, Capacity, Alignment
+        >::value, "conversion not allowed");
+
+        return {vtable_ptr_, vtable_ptr_->move_ptr, std::addressof(storage_)};
+    }
+
+    void swap(inplace_function& other)
+    {
+        if (this == std::addressof(other)) return;
+
+        storage_t tmp;
+        vtable_ptr_->move_ptr(
+            std::addressof(tmp),
+            std::addressof(storage_)
+        );
+        vtable_ptr_->destructor_ptr(std::addressof(storage_));
+
+        other.vtable_ptr_->move_ptr(
+            std::addressof(storage_),
+            std::addressof(other.storage_)
+        );
+        other.vtable_ptr_->destructor_ptr(std::addressof(other.storage_));
+
+        vtable_ptr_->move_ptr(
+            std::addressof(other.storage_),
+            std::addressof(tmp)
+        );
+        vtable_ptr_->destructor_ptr(std::addressof(tmp));
+
+        std::swap(vtable_ptr_, other.vtable_ptr_);
+    }
+
+private:
+    vtable_ptr_t vtable_ptr_;
+    mutable storage_t storage_;
+
+    inplace_function(
+        vtable_ptr_t vtable_ptr,
+        typename vtable_t::process_ptr_t process_ptr,
+        typename vtable_t::storage_ptr_t storage_ptr
+    ) : vtable_ptr_{vtable_ptr}
+    {
+        process_ptr(std::addressof(storage_), storage_ptr);
+    }
+};
+
+} // namespace stdext
+
+#endif /* _C4_EXT_SG14_INPLACE_FUNCTION_H_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/ext/sg14/inplace_function.h)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/language.cpp
+// https://github.com/biojppm/c4core/src/c4/language.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/language.hpp
+//#include "c4/language.hpp"
+#if !defined(C4_LANGUAGE_HPP_) && !defined(_C4_LANGUAGE_HPP_)
+#error "amalgamate: file c4/language.hpp must have been included at this point"
+#endif /* C4_LANGUAGE_HPP_ */
+
+
+namespace c4 {
+namespace detail {
+
+#ifndef __GNUC__
+void use_char_pointer(char const volatile* v)
+{
+    C4_UNUSED(v);
+}
+#else
+void foo() {} // to avoid empty file warning from the linker
+#endif
+
+} // namespace detail
+} // namespace c4
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/language.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/format.cpp
+// https://github.com/biojppm/c4core/src/c4/format.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/format.hpp
+//#include "c4/format.hpp"
+#if !defined(C4_FORMAT_HPP_) && !defined(_C4_FORMAT_HPP_)
+#error "amalgamate: file c4/format.hpp must have been included at this point"
+#endif /* C4_FORMAT_HPP_ */
+
+
+//included above:
+//#include <memory> // for std::align
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wformat-nonliteral"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
+
+namespace c4 {
+
+
+size_t to_chars(substr buf, fmt::const_raw_wrapper r)
+{
+    void * vptr = buf.str;
+    size_t space = buf.len;
+    auto ptr = (decltype(buf.str)) std::align(r.alignment, r.len, vptr, space);
+    if(ptr == nullptr)
+    {
+        // if it was not possible to align, return a conservative estimate
+        // of the required space
+        return r.alignment + r.len;
+    }
+    C4_CHECK(ptr >= buf.begin() && ptr <= buf.end());
+    size_t sz = static_cast<size_t>(ptr - buf.str) + r.len;
+    if(sz <= buf.len)
+    {
+        memcpy(ptr, r.buf, r.len);
+    }
+    return sz;
+}
+
+
+bool from_chars(csubstr buf, fmt::raw_wrapper *r)
+{
+    void * vptr = (void*)buf.str;
+    size_t space = buf.len;
+    auto ptr = (decltype(buf.str)) std::align(r->alignment, r->len, vptr, space);
+    C4_CHECK(ptr != nullptr);
+    C4_CHECK(ptr >= buf.begin() && ptr <= buf.end());
+    //size_t dim = (ptr - buf.str) + r->len;
+    memcpy(r->buf, ptr, r->len);
+    return true;
+}
+
+
+} // namespace c4
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/format.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/memory_util.cpp
+// https://github.com/biojppm/c4core/src/c4/memory_util.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_util.hpp
+//#include "c4/memory_util.hpp"
+#if !defined(C4_MEMORY_UTIL_HPP_) && !defined(_C4_MEMORY_UTIL_HPP_)
+#error "amalgamate: file c4/memory_util.hpp must have been included at this point"
+#endif /* C4_MEMORY_UTIL_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+namespace c4 {
+
+/** returns true if the memory overlaps */
+bool mem_overlaps(void const* a, void const* b, size_t sza, size_t szb)
+{
+    if(a < b)
+    {
+        if(size_t(a) + sza > size_t(b))
+            return true;
+    }
+    else if(a > b)
+    {
+        if(size_t(b) + szb > size_t(a))
+            return true;
+    }
+    else if(a == b)
+    {
+        if(sza != 0 && szb != 0)
+            return true;
+    }
+    return false;
+}
+
+/** Fills 'dest' with the first 'pattern_size' bytes at 'pattern', 'num_times'. */
+void mem_repeat(void* dest, void const* pattern, size_t pattern_size, size_t num_times)
+{
+    if(C4_UNLIKELY(num_times == 0))
+        return;
+    C4_ASSERT( ! mem_overlaps(dest, pattern, num_times*pattern_size, pattern_size));
+    char *begin = (char*)dest;
+    char *end   = begin + num_times * pattern_size;
+    // copy the pattern once
+    ::memcpy(begin, pattern, pattern_size);
+    // now copy from dest to itself, doubling up every time
+    size_t n = pattern_size;
+    while(begin + 2*n < end)
+    {
+        ::memcpy(begin + n, begin, n);
+        n <<= 1; // double n
+    }
+    // copy the missing part
+    if(begin + n < end)
+    {
+        ::memcpy(begin + n, begin, static_cast<size_t>(end - (begin + n)));
+    }
+}
+
+} // namespace c4
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/memory_util.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/char_traits.cpp
+// https://github.com/biojppm/c4core/src/c4/char_traits.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/char_traits.hpp
+//#include "c4/char_traits.hpp"
+#if !defined(C4_CHAR_TRAITS_HPP_) && !defined(_C4_CHAR_TRAITS_HPP_)
+#error "amalgamate: file c4/char_traits.hpp must have been included at this point"
+#endif /* C4_CHAR_TRAITS_HPP_ */
+
+
+namespace c4 {
+
+constexpr const char char_traits< char >::whitespace_chars[];
+constexpr const size_t char_traits< char >::num_whitespace_chars;
+constexpr const wchar_t char_traits< wchar_t >::whitespace_chars[];
+constexpr const size_t char_traits< wchar_t >::num_whitespace_chars;
+
+} // namespace c4
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/char_traits.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/memory_resource.cpp
+// https://github.com/biojppm/c4core/src/c4/memory_resource.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_resource.hpp
+//#include "c4/memory_resource.hpp"
+#if !defined(C4_MEMORY_RESOURCE_HPP_) && !defined(_C4_MEMORY_RESOURCE_HPP_)
+#error "amalgamate: file c4/memory_resource.hpp must have been included at this point"
+#endif /* C4_MEMORY_RESOURCE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/memory_util.hpp
+//#include "c4/memory_util.hpp"
+#if !defined(C4_MEMORY_UTIL_HPP_) && !defined(_C4_MEMORY_UTIL_HPP_)
+#error "amalgamate: file c4/memory_util.hpp must have been included at this point"
+#endif /* C4_MEMORY_UTIL_HPP_ */
+
+
+//included above:
+//#include <stdlib.h>
+//included above:
+//#include <string.h>
+#if defined(C4_POSIX) || defined(C4_IOS) || defined(C4_MACOS) || defined(C4_ARM)
+#   include <errno.h>
+#endif
+#if defined(C4_ARM)
+#   include <malloc.h>
+#endif
+
+//included above:
+//#include <memory>
+
+namespace c4 {
+
+namespace detail {
+
+
+#ifdef C4_NO_ALLOC_DEFAULTS
+aalloc_pfn s_aalloc = nullptr;
+free_pfn s_afree = nullptr;
+arealloc_pfn s_arealloc = nullptr;
+#else
+
+
+void afree_impl(void *ptr)
+{
+#if defined(C4_WIN) || defined(C4_XBOX)
+    ::_aligned_free(ptr);
+#else
+    ::free(ptr);
+#endif
+}
+
+
+void* aalloc_impl(size_t size, size_t alignment)
+{
+    void *mem;
+#if defined(C4_WIN) || defined(C4_XBOX)
+    mem = ::_aligned_malloc(size, alignment);
+    C4_CHECK(mem != nullptr || size == 0);
+#elif defined(C4_ARM)
+    // https://stackoverflow.com/questions/53614538/undefined-reference-to-posix-memalign-in-arm-gcc
+    // https://electronics.stackexchange.com/questions/467382/e2-studio-undefined-reference-to-posix-memalign/467753
+    mem = memalign(alignment, size);
+    C4_CHECK(mem != nullptr || size == 0);
+#elif defined(C4_POSIX) || defined(C4_IOS) || defined(C4_MACOS)
+    // NOTE: alignment needs to be sized in multiples of sizeof(void*)
+    size_t amult = alignment;
+    if(C4_UNLIKELY(alignment < sizeof(void*)))
+    {
+        amult = sizeof(void*);
+    }
+    int ret = ::posix_memalign(&mem, amult, size);
+    if(C4_UNLIKELY(ret))
+    {
+        if(ret == EINVAL)
+        {
+            C4_ERROR("The alignment argument %zu was not a power of two, "
+                     "or was not a multiple of sizeof(void*)", alignment);
+        }
+        else if(ret == ENOMEM)
+        {
+            C4_ERROR("There was insufficient memory to fulfill the "
+                     "allocation request of %zu bytes (alignment=%lu)", size, size);
+        }
+        return nullptr;
+    }
+#else
+    C4_NOT_IMPLEMENTED_MSG("need to implement an aligned allocation for this platform");
+#endif
+    C4_ASSERT_MSG((uintptr_t(mem) & (alignment-1)) == 0, "address %p is not aligned to %zu boundary", mem, alignment);
+    return mem;
+}
+
+
+void* arealloc_impl(void* ptr, size_t oldsz, size_t newsz, size_t alignment)
+{
+    /** @todo make this more efficient
+     * @see https://stackoverflow.com/questions/9078259/does-realloc-keep-the-memory-alignment-of-posix-memalign
+     * @see look for qReallocAligned() in http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/global/qmalloc.cpp
+     */
+    void *tmp = aalloc(newsz, alignment);
+    size_t min = newsz < oldsz ? newsz : oldsz;
+    if(mem_overlaps(ptr, tmp, oldsz, newsz))
+    {
+        ::memmove(tmp, ptr, min);
+    }
+    else
+    {
+        ::memcpy(tmp, ptr, min);
+    }
+    afree(ptr);
+    return tmp;
+}
+
+aalloc_pfn s_aalloc = aalloc_impl;
+afree_pfn s_afree = afree_impl;
+arealloc_pfn s_arealloc = arealloc_impl;
+
+#endif // C4_NO_ALLOC_DEFAULTS
+
+} // namespace detail
+
+
+aalloc_pfn get_aalloc()
+{
+    return detail::s_aalloc;
+}
+void set_aalloc(aalloc_pfn fn)
+{
+    detail::s_aalloc = fn;
+}
+
+afree_pfn get_afree()
+{
+    return detail::s_afree;
+}
+void set_afree(afree_pfn fn)
+{
+    detail::s_afree = fn;
+}
+
+arealloc_pfn get_arealloc()
+{
+    return detail::s_arealloc;
+}
+void set_arealloc(arealloc_pfn fn)
+{
+    detail::s_arealloc = fn;
+}
+
+
+void* aalloc(size_t sz, size_t alignment)
+{
+    C4_ASSERT_MSG(c4::get_aalloc() != nullptr, "did you forget to call set_aalloc()?");
+    auto fn = c4::get_aalloc();
+    void* ptr = fn(sz, alignment);
+    return ptr;
+}
+
+void afree(void* ptr)
+{
+    C4_ASSERT_MSG(c4::get_afree() != nullptr, "did you forget to call set_afree()?");
+    auto fn = c4::get_afree();
+    fn(ptr);
+}
+
+void* arealloc(void *ptr, size_t oldsz, size_t newsz, size_t alignment)
+{
+    C4_ASSERT_MSG(c4::get_arealloc() != nullptr, "did you forget to call set_arealloc()?");
+    auto fn = c4::get_arealloc();
+    void* nptr = fn(ptr, oldsz, newsz, alignment);
+    return nptr;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+void detail::_MemoryResourceSingleChunk::release()
+{
+    if(m_mem && m_owner)
+    {
+        impl_type::deallocate(m_mem, m_size);
+    }
+    m_mem = nullptr;
+    m_size = 0;
+    m_owner = false;
+    m_pos = 0;
+}
+
+void detail::_MemoryResourceSingleChunk::acquire(size_t sz)
+{
+    clear();
+    m_owner = true;
+    m_mem = (char*) impl_type::allocate(sz, alignof(max_align_t));
+    m_size = sz;
+    m_pos = 0;
+}
+
+void detail::_MemoryResourceSingleChunk::acquire(void *mem, size_t sz)
+{
+    clear();
+    m_owner = false;
+    m_mem = (char*) mem;
+    m_size = sz;
+    m_pos = 0;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+void* MemoryResourceLinear::do_allocate(size_t sz, size_t alignment, void *hint)
+{
+    C4_UNUSED(hint);
+    if(sz == 0) return nullptr;
+    // make sure there's enough room to allocate
+    if(m_pos + sz > m_size)
+    {
+        C4_ERROR("out of memory");
+        return nullptr;
+    }
+    void *mem = m_mem + m_pos;
+    size_t space = m_size - m_pos;
+    if(std::align(alignment, sz, mem, space))
+    {
+        C4_ASSERT(m_pos <= m_size);
+        C4_ASSERT(m_size - m_pos >= space);
+        m_pos += (m_size - m_pos) - space;
+        m_pos += sz;
+        C4_ASSERT(m_pos <= m_size);
+    }
+    else
+    {
+        C4_ERROR("could not align memory");
+        mem = nullptr;
+    }
+    return mem;
+}
+
+void MemoryResourceLinear::do_deallocate(void* ptr, size_t sz, size_t alignment)
+{
+    C4_UNUSED(ptr);
+    C4_UNUSED(sz);
+    C4_UNUSED(alignment);
+    // nothing to do!!
+}
+
+void* MemoryResourceLinear::do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment)
+{
+    if(newsz == oldsz) return ptr;
+    // is ptr the most recently allocated (MRA) block?
+    char *cptr = (char*)ptr;
+    bool same_pos = (m_mem + m_pos == cptr + oldsz);
+    // no need to get more memory when shrinking
+    if(newsz < oldsz)
+    {
+        // if this is the MRA, we can safely shrink the position
+        if(same_pos)
+        {
+            m_pos -= oldsz - newsz;
+        }
+        return ptr;
+    }
+    // we're growing the block, and it fits in size
+    else if(same_pos && cptr + newsz <= m_mem + m_size)
+    {
+        // if this is the MRA, we can safely shrink the position
+        m_pos += newsz - oldsz;
+        return ptr;
+    }
+    // we're growing the block or it doesn't fit -
+    // delegate any of these situations to do_deallocate()
+    return do_allocate(newsz, alignment, ptr);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @todo add a free list allocator. A good candidate because of its
+ * small size is TLSF.
+ *
+ * @see https://github.com/mattconte/tlsf
+ *
+ * Comparisons:
+ *
+ * @see https://www.researchgate.net/publication/262375150_A_Comparative_Study_on_Memory_Allocators_in_Multicore_and_Multithreaded_Applications_-_SBESC_2011_-_Presentation_Slides
+ * @see http://webkit.sed.hu/blog/20100324/war-allocators-tlsf-action
+ * @see https://github.com/emeryberger/Malloc-Implementations/tree/master/allocators
+ *
+ * */
+
+} // namespace c4
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+#ifdef C4_REDEFINE_CPPNEW
+#include <new>
+void* operator new(size_t size)
+{
+    auto *mr = ::c4::get_memory_resource();
+    return mr->allocate(size);
+}
+void operator delete(void *p) noexcept
+{
+    C4_NEVER_REACH();
+}
+void operator delete(void *p, size_t size)
+{
+    auto *mr = ::c4::get_memory_resource();
+    mr->deallocate(p, size);
+}
+void* operator new[](size_t size)
+{
+    return operator new(size);
+}
+void operator delete[](void *p) noexcept
+{
+    operator delete(p);
+}
+void operator delete[](void *p, size_t size)
+{
+    operator delete(p, size);
+}
+void* operator new(size_t size, std::nothrow_t)
+{
+    return operator new(size);
+}
+void operator delete(void *p, std::nothrow_t)
+{
+    operator delete(p);
+}
+void operator delete(void *p, size_t size, std::nothrow_t)
+{
+    operator delete(p, size);
+}
+void* operator new[](size_t size, std::nothrow_t)
+{
+    return operator new(size);
+}
+void operator delete[](void *p, std::nothrow_t)
+{
+    operator delete(p);
+}
+void operator delete[](void *p, size_t, std::nothrow_t)
+{
+    operator delete(p, size);
+}
+#endif // C4_REDEFINE_CPPNEW
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/memory_resource.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/utf.cpp
+// https://github.com/biojppm/c4core/src/c4/utf.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/utf.hpp
+//#include "c4/utf.hpp"
+#if !defined(C4_UTF_HPP_) && !defined(_C4_UTF_HPP_)
+#error "amalgamate: file c4/utf.hpp must have been included at this point"
+#endif /* C4_UTF_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/charconv.hpp
+//#include "c4/charconv.hpp"
+#if !defined(C4_CHARCONV_HPP_) && !defined(_C4_CHARCONV_HPP_)
+#error "amalgamate: file c4/charconv.hpp must have been included at this point"
+#endif /* C4_CHARCONV_HPP_ */
+
+
+namespace c4 {
+
+size_t decode_code_point(uint8_t *C4_RESTRICT buf, size_t buflen, const uint32_t code)
+{
+    C4_UNUSED(buflen);
+    C4_ASSERT(buflen >= 4);
+    if (code <= UINT32_C(0x7f))
+    {
+        buf[0] = (uint8_t)code;
+        return 1u;
+    }
+    else if(code <= UINT32_C(0x7ff))
+    {
+        buf[0] = (uint8_t)(UINT32_C(0xc0) | (code >> 6));             /* 110xxxxx */
+        buf[1] = (uint8_t)(UINT32_C(0x80) | (code & UINT32_C(0x3f))); /* 10xxxxxx */
+        return 2u;
+    }
+    else if(code <= UINT32_C(0xffff))
+    {
+        buf[0] = (uint8_t)(UINT32_C(0xe0) | ((code >> 12)));                  /* 1110xxxx */
+        buf[1] = (uint8_t)(UINT32_C(0x80) | ((code >>  6) & UINT32_C(0x3f))); /* 10xxxxxx */
+        buf[2] = (uint8_t)(UINT32_C(0x80) | ((code      ) & UINT32_C(0x3f))); /* 10xxxxxx */
+        return 3u;
+    }
+    else if(code <= UINT32_C(0x10ffff))
+    {
+        buf[0] = (uint8_t)(UINT32_C(0xf0) | ((code >> 18)));                  /* 11110xxx */
+        buf[1] = (uint8_t)(UINT32_C(0x80) | ((code >> 12) & UINT32_C(0x3f))); /* 10xxxxxx */
+        buf[2] = (uint8_t)(UINT32_C(0x80) | ((code >>  6) & UINT32_C(0x3f))); /* 10xxxxxx */
+        buf[3] = (uint8_t)(UINT32_C(0x80) | ((code      ) & UINT32_C(0x3f))); /* 10xxxxxx */
+        return 4u;
+    }
+    return 0;
+}
+
+substr decode_code_point(substr out, csubstr code_point)
+{
+    C4_ASSERT(out.len >= 4);
+    C4_ASSERT(!code_point.begins_with("U+"));
+    C4_ASSERT(!code_point.begins_with("\\x"));
+    C4_ASSERT(!code_point.begins_with("\\u"));
+    C4_ASSERT(!code_point.begins_with("\\U"));
+    C4_ASSERT(!code_point.begins_with('0'));
+    C4_ASSERT(code_point.len <= 8);
+    uint32_t code_point_val;
+    C4_CHECK(read_hex(code_point, &code_point_val));
+    size_t ret = decode_code_point((uint8_t*)out.str, out.len, code_point_val);
+    C4_ASSERT(ret <= 4);
+    return out.first(ret);
+}
+
+} // namespace c4
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/utf.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/base64.cpp
+// https://github.com/biojppm/c4core/src/c4/base64.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/base64.hpp
+//#include "c4/base64.hpp"
+#if !defined(C4_BASE64_HPP_) && !defined(_C4_BASE64_HPP_)
+#error "amalgamate: file c4/base64.hpp must have been included at this point"
+#endif /* C4_BASE64_HPP_ */
+
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wchar-subscripts" // array subscript is of type 'char'
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wchar-subscripts"
+#   pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+namespace c4 {
+
+namespace detail {
+
+constexpr static const char base64_sextet_to_char_[64] = {
+    /* 0/ 65*/ 'A', /* 1/ 66*/ 'B', /* 2/ 67*/ 'C', /* 3/ 68*/ 'D',
+    /* 4/ 69*/ 'E', /* 5/ 70*/ 'F', /* 6/ 71*/ 'G', /* 7/ 72*/ 'H',
+    /* 8/ 73*/ 'I', /* 9/ 74*/ 'J', /*10/ 75*/ 'K', /*11/ 74*/ 'L',
+    /*12/ 77*/ 'M', /*13/ 78*/ 'N', /*14/ 79*/ 'O', /*15/ 78*/ 'P',
+    /*16/ 81*/ 'Q', /*17/ 82*/ 'R', /*18/ 83*/ 'S', /*19/ 82*/ 'T',
+    /*20/ 85*/ 'U', /*21/ 86*/ 'V', /*22/ 87*/ 'W', /*23/ 88*/ 'X',
+    /*24/ 89*/ 'Y', /*25/ 90*/ 'Z', /*26/ 97*/ 'a', /*27/ 98*/ 'b',
+    /*28/ 99*/ 'c', /*29/100*/ 'd', /*30/101*/ 'e', /*31/102*/ 'f',
+    /*32/103*/ 'g', /*33/104*/ 'h', /*34/105*/ 'i', /*35/106*/ 'j',
+    /*36/107*/ 'k', /*37/108*/ 'l', /*38/109*/ 'm', /*39/110*/ 'n',
+    /*40/111*/ 'o', /*41/112*/ 'p', /*42/113*/ 'q', /*43/114*/ 'r',
+    /*44/115*/ 's', /*45/116*/ 't', /*46/117*/ 'u', /*47/118*/ 'v',
+    /*48/119*/ 'w', /*49/120*/ 'x', /*50/121*/ 'y', /*51/122*/ 'z',
+    /*52/ 48*/ '0', /*53/ 49*/ '1', /*54/ 50*/ '2', /*55/ 51*/ '3',
+    /*56/ 52*/ '4', /*57/ 53*/ '5', /*58/ 54*/ '6', /*59/ 55*/ '7',
+    /*60/ 56*/ '8', /*61/ 57*/ '9', /*62/ 43*/ '+', /*63/ 47*/ '/',
+};
+
+// https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html
+constexpr static const char base64_char_to_sextet_[128] = {
+    #define __ char(-1) // undefined below
+    /*  0 NUL*/ __, /*  1 SOH*/ __, /*  2 STX*/ __, /*  3 ETX*/ __,
+    /*  4 EOT*/ __, /*  5 ENQ*/ __, /*  6 ACK*/ __, /*  7 BEL*/ __,
+    /*  8 BS */ __, /*  9 TAB*/ __, /* 10 LF */ __, /* 11 VT */ __,
+    /* 12 FF */ __, /* 13 CR */ __, /* 14 SO */ __, /* 15 SI */ __,
+    /* 16 DLE*/ __, /* 17 DC1*/ __, /* 18 DC2*/ __, /* 19 DC3*/ __,
+    /* 20 DC4*/ __, /* 21 NAK*/ __, /* 22 SYN*/ __, /* 23 ETB*/ __,
+    /* 24 CAN*/ __, /* 25 EM */ __, /* 26 SUB*/ __, /* 27 ESC*/ __,
+    /* 28 FS */ __, /* 29 GS */ __, /* 30 RS */ __, /* 31 US */ __,
+    /* 32 SPC*/ __, /* 33 !  */ __, /* 34 "  */ __, /* 35 #  */ __,
+    /* 36 $  */ __, /* 37 %  */ __, /* 38 &  */ __, /* 39 '  */ __,
+    /* 40 (  */ __, /* 41 )  */ __, /* 42 *  */ __, /* 43 +  */ 62,
+    /* 44 ,  */ __, /* 45 -  */ __, /* 46 .  */ __, /* 47 /  */ 63,
+    /* 48 0  */ 52, /* 49 1  */ 53, /* 50 2  */ 54, /* 51 3  */ 55,
+    /* 52 4  */ 56, /* 53 5  */ 57, /* 54 6  */ 58, /* 55 7  */ 59,
+    /* 56 8  */ 60, /* 57 9  */ 61, /* 58 :  */ __, /* 59 ;  */ __,
+    /* 60 <  */ __, /* 61 =  */ __, /* 62 >  */ __, /* 63 ?  */ __,
+    /* 64 @  */ __, /* 65 A  */  0, /* 66 B  */  1, /* 67 C  */  2,
+    /* 68 D  */  3, /* 69 E  */  4, /* 70 F  */  5, /* 71 G  */  6,
+    /* 72 H  */  7, /* 73 I  */  8, /* 74 J  */  9, /* 75 K  */ 10,
+    /* 76 L  */ 11, /* 77 M  */ 12, /* 78 N  */ 13, /* 79 O  */ 14,
+    /* 80 P  */ 15, /* 81 Q  */ 16, /* 82 R  */ 17, /* 83 S  */ 18,
+    /* 84 T  */ 19, /* 85 U  */ 20, /* 86 V  */ 21, /* 87 W  */ 22,
+    /* 88 X  */ 23, /* 89 Y  */ 24, /* 90 Z  */ 25, /* 91 [  */ __,
+    /* 92 \  */ __, /* 93 ]  */ __, /* 94 ^  */ __, /* 95 _  */ __,
+    /* 96 `  */ __, /* 97 a  */ 26, /* 98 b  */ 27, /* 99 c  */ 28,
+    /*100 d  */ 29, /*101 e  */ 30, /*102 f  */ 31, /*103 g  */ 32,
+    /*104 h  */ 33, /*105 i  */ 34, /*106 j  */ 35, /*107 k  */ 36,
+    /*108 l  */ 37, /*109 m  */ 38, /*110 n  */ 39, /*111 o  */ 40,
+    /*112 p  */ 41, /*113 q  */ 42, /*114 r  */ 43, /*115 s  */ 44,
+    /*116 t  */ 45, /*117 u  */ 46, /*118 v  */ 47, /*119 w  */ 48,
+    /*120 x  */ 49, /*121 y  */ 50, /*122 z  */ 51, /*123 {  */ __,
+    /*124 |  */ __, /*125 }  */ __, /*126 ~  */ __, /*127 DEL*/ __,
+    #undef __
+};
+
+#ifndef NDEBUG
+void base64_test_tables()
+{
+    for(size_t i = 0; i < C4_COUNTOF(detail::base64_sextet_to_char_); ++i)
+    {
+        char s2c = base64_sextet_to_char_[i];
+        char c2s = base64_char_to_sextet_[(int)s2c];
+        C4_CHECK((size_t)c2s == i);
+    }
+    for(size_t i = 0; i < C4_COUNTOF(detail::base64_char_to_sextet_); ++i)
+    {
+        char c2s = base64_char_to_sextet_[i];
+        if(c2s == char(-1))
+            continue;
+        char s2c = base64_sextet_to_char_[(int)c2s];
+        C4_CHECK((size_t)s2c == i);
+    }
+}
+#endif
+} // namespace detail
+
+
+bool base64_valid(csubstr encoded)
+{
+    if(encoded.len % 4) return false;
+    for(const char c : encoded)
+    {
+        if(c < 0/* || c >= 128*/)
+            return false;
+        if(c == '=')
+            continue;
+        if(detail::base64_char_to_sextet_[c] == char(-1))
+            return false;
+    }
+    return true;
+}
+
+
+size_t base64_encode(substr buf, cblob data)
+{
+    #define c4append_(c) { if(pos < buf.len) { buf.str[pos] = (c); } ++pos; }
+    #define c4append_idx_(char_idx) \
+    {\
+         C4_XASSERT((char_idx) < sizeof(detail::base64_sextet_to_char_));\
+         c4append_(detail::base64_sextet_to_char_[(char_idx)]);\
+    }
+
+    size_t rem, pos = 0;
+    constexpr const uint32_t sextet_mask = uint32_t(1 << 6) - 1;
+    const unsigned char *C4_RESTRICT d = (unsigned char *) data.buf; // cast to unsigned to avoid wrapping high-bits
+    for(rem = data.len; rem >= 3; rem -= 3, d += 3)
+    {
+        const uint32_t val = ((uint32_t(d[0]) << 16) | (uint32_t(d[1]) << 8) | (uint32_t(d[2])));
+        c4append_idx_((val >> 18) & sextet_mask);
+        c4append_idx_((val >> 12) & sextet_mask);
+        c4append_idx_((val >>  6) & sextet_mask);
+        c4append_idx_((val      ) & sextet_mask);
+    }
+    C4_ASSERT(rem < 3);
+    if(rem == 2)
+    {
+        const uint32_t val = ((uint32_t(d[0]) << 16) | (uint32_t(d[1]) << 8));
+        c4append_idx_((val >> 18) & sextet_mask);
+        c4append_idx_((val >> 12) & sextet_mask);
+        c4append_idx_((val >>  6) & sextet_mask);
+        c4append_('=');
+    }
+    else if(rem == 1)
+    {
+        const uint32_t val = ((uint32_t(d[0]) << 16));
+        c4append_idx_((val >> 18) & sextet_mask);
+        c4append_idx_((val >> 12) & sextet_mask);
+        c4append_('=');
+        c4append_('=');
+    }
+    return pos;
+
+    #undef c4append_
+    #undef c4append_idx_
+}
+
+
+size_t base64_decode(csubstr encoded, blob data)
+{
+    #define c4append_(c) { if(wpos < data.len) { data.buf[wpos] = static_cast<c4::byte>(c); } ++wpos; }
+    #define c4appendval_(c, shift)\
+    {\
+        C4_XASSERT(c >= 0);\
+        C4_XASSERT(size_t(c) < sizeof(detail::base64_char_to_sextet_));\
+        val |= static_cast<uint32_t>(detail::base64_char_to_sextet_[(c)]) << ((shift) * 6);\
+    }
+
+    C4_ASSERT(base64_valid(encoded));
+    C4_CHECK(encoded.len % 4 == 0);
+    size_t wpos = 0;  // the write position
+    const char *C4_RESTRICT d = encoded.str;
+    constexpr const uint32_t full_byte = 0xff;
+    // process every quartet of input 6 bits --> triplet of output bytes
+    for(size_t rpos = 0; rpos < encoded.len; rpos += 4, d += 4)
+    {
+        if(d[2] == '=' || d[3] == '=') // skip the last quartet if it is padded
+        {
+            C4_ASSERT(d + 4 == encoded.str + encoded.len);
+            break;
+        }
+        uint32_t val = 0;
+        c4appendval_(d[3], 0);
+        c4appendval_(d[2], 1);
+        c4appendval_(d[1], 2);
+        c4appendval_(d[0], 3);
+        c4append_((val >> (2 * 8)) & full_byte);
+        c4append_((val >> (1 * 8)) & full_byte);
+        c4append_((val           ) & full_byte);
+    }
+    // deal with the last quartet when it is padded
+    if(d == encoded.str + encoded.len)
+        return wpos;
+    if(d[2] == '=') // 2 padding chars
+    {
+        C4_ASSERT(d + 4 == encoded.str + encoded.len);
+        C4_ASSERT(d[3] == '=');
+        uint32_t val = 0;
+        c4appendval_(d[1], 2);
+        c4appendval_(d[0], 3);
+        c4append_((val >> (2 * 8)) & full_byte);
+    }
+    else if(d[3] == '=') // 1 padding char
+    {
+        C4_ASSERT(d + 4 == encoded.str + encoded.len);
+        uint32_t val = 0;
+        c4appendval_(d[2], 1);
+        c4appendval_(d[1], 2);
+        c4appendval_(d[0], 3);
+        c4append_((val >> (2 * 8)) & full_byte);
+        c4append_((val >> (1 * 8)) & full_byte);
+    }
+    return wpos;
+    #undef c4append_
+    #undef c4appendval_
+}
+
+} // namespace c4
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/base64.cpp)
+
+#define C4_WINDOWS_POP_HPP_
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/windows_push.hpp
+// https://github.com/biojppm/c4core/src/c4/windows_push.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_WINDOWS_PUSH_HPP_
+#define _C4_WINDOWS_PUSH_HPP_
+
+/** @file windows_push.hpp sets up macros to include windows header files
+ * without pulling in all of <windows.h>
+ *
+ * @see #include windows_pop.hpp to undefine these macros
+ *
+ * @see https://aras-p.info/blog/2018/01/12/Minimizing-windows.h/ */
+
+
+#if defined(_WIN64) || defined(_WIN32)
+
+#if defined(_M_AMD64)
+#   ifndef _AMD64_
+#       define _c4_AMD64_
+#       define _AMD64_
+#   endif
+#elif defined(_M_IX86)
+#   ifndef _X86_
+#       define _c4_X86_
+#       define _X86_
+#   endif
+#elif defined(_M_ARM64)
+#   ifndef _ARM64_
+#       define _c4_ARM64_
+#       define _ARM64_
+#   endif
+#elif defined(_M_ARM)
+#   ifndef _ARM_
+#       define _c4_ARM_
+#       define _ARM_
+#   endif
+#endif
+
+#ifndef NOMINMAX
+#    define _c4_NOMINMAX
+#    define NOMINMAX
+#endif
+
+#ifndef NOGDI
+#    define _c4_NOGDI
+#    define NOGDI
+#endif
+
+#ifndef VC_EXTRALEAN
+#    define _c4_VC_EXTRALEAN
+#    define VC_EXTRALEAN
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#    define _c4_WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#endif
+
+/*  If defined, the following flags inhibit definition
+ *     of the indicated items.
+ *
+ *  NOGDICAPMASKS     - CC_*, LC_*, PC_*, CP_*, TC_*, RC_
+ *  NOVIRTUALKEYCODES - VK_*
+ *  NOWINMESSAGES     - WM_*, EM_*, LB_*, CB_*
+ *  NOWINSTYLES       - WS_*, CS_*, ES_*, LBS_*, SBS_*, CBS_*
+ *  NOSYSMETRICS      - SM_*
+ *  NOMENUS           - MF_*
+ *  NOICONS           - IDI_*
+ *  NOKEYSTATES       - MK_*
+ *  NOSYSCOMMANDS     - SC_*
+ *  NORASTEROPS       - Binary and Tertiary raster ops
+ *  NOSHOWWINDOW      - SW_*
+ *  OEMRESOURCE       - OEM Resource values
+ *  NOATOM            - Atom Manager routines
+ *  NOCLIPBOARD       - Clipboard routines
+ *  NOCOLOR           - Screen colors
+ *  NOCTLMGR          - Control and Dialog routines
+ *  NODRAWTEXT        - DrawText() and DT_*
+ *  NOGDI             - All GDI defines and routines
+ *  NOKERNEL          - All KERNEL defines and routines
+ *  NOUSER            - All USER defines and routines
+ *  NONLS             - All NLS defines and routines
+ *  NOMB              - MB_* and MessageBox()
+ *  NOMEMMGR          - GMEM_*, LMEM_*, GHND, LHND, associated routines
+ *  NOMETAFILE        - typedef METAFILEPICT
+ *  NOMINMAX          - Macros min(a,b) and max(a,b)
+ *  NOMSG             - typedef MSG and associated routines
+ *  NOOPENFILE        - OpenFile(), OemToAnsi, AnsiToOem, and OF_*
+ *  NOSCROLL          - SB_* and scrolling routines
+ *  NOSERVICE         - All Service Controller routines, SERVICE_ equates, etc.
+ *  NOSOUND           - Sound driver routines
+ *  NOTEXTMETRIC      - typedef TEXTMETRIC and associated routines
+ *  NOWH              - SetWindowsHook and WH_*
+ *  NOWINOFFSETS      - GWL_*, GCL_*, associated routines
+ *  NOCOMM            - COMM driver routines
+ *  NOKANJI           - Kanji support stuff.
+ *  NOHELP            - Help engine interface.
+ *  NOPROFILER        - Profiler interface.
+ *  NODEFERWINDOWPOS  - DeferWindowPos routines
+ *  NOMCX             - Modem Configuration Extensions
+ */
+
+#endif /* defined(_WIN64) || defined(_WIN32) */
+
+#endif /* _C4_WINDOWS_PUSH_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/windows_push.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/windows.hpp
+// https://github.com/biojppm/c4core/src/c4/windows.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_WINDOWS_HPP_
+#define _C4_WINDOWS_HPP_
+
+#if defined(_WIN64) || defined(_WIN32)
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/windows_push.hpp
+//#include "c4/windows_push.hpp"
+#if !defined(C4_WINDOWS_PUSH_HPP_) && !defined(_C4_WINDOWS_PUSH_HPP_)
+#error "amalgamate: file c4/windows_push.hpp must have been included at this point"
+#endif /* C4_WINDOWS_PUSH_HPP_ */
+
+#include <windows.h>
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/windows_pop.hpp
+//#include "c4/windows_pop.hpp"
+#if !defined(C4_WINDOWS_POP_HPP_) && !defined(_C4_WINDOWS_POP_HPP_)
+#error "amalgamate: file c4/windows_pop.hpp must have been included at this point"
+#endif /* C4_WINDOWS_POP_HPP_ */
+
+#endif
+
+#endif /* _C4_WINDOWS_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/windows.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/windows_pop.hpp
+// https://github.com/biojppm/c4core/src/c4/windows_pop.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_WINDOWS_POP_HPP_
+#define _C4_WINDOWS_POP_HPP_
+
+#if defined(_WIN64) || defined(_WIN32)
+
+#ifdef _c4_AMD64_
+#    undef _c4_AMD64_
+#    undef _AMD64_
+#endif
+#ifdef _c4_X86_
+#    undef _c4_X86_
+#    undef _X86_
+#endif
+#ifdef _c4_ARM_
+#    undef _c4_ARM_
+#    undef _ARM_
+#endif
+
+#ifdef _c4_NOMINMAX
+#    undef _c4_NOMINMAX
+#    undef NOMINMAX
+#endif
+
+#ifdef NOGDI
+#    undef _c4_NOGDI
+#    undef NOGDI
+#endif
+
+#ifdef VC_EXTRALEAN
+#    undef _c4_VC_EXTRALEAN
+#    undef VC_EXTRALEAN
+#endif
+
+#ifdef WIN32_LEAN_AND_MEAN
+#    undef _c4_WIN32_LEAN_AND_MEAN
+#    undef WIN32_LEAN_AND_MEAN
+#endif
+
+#endif /* defined(_WIN64) || defined(_WIN32) */
+
+#endif /* _C4_WINDOWS_POP_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/windows_pop.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/error.cpp
+// https://github.com/biojppm/c4core/src/c4/error.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+
+//included above:
+//#include <stdlib.h>
+//included above:
+//#include <stdio.h>
+//included above:
+//#include <stdarg.h>
+
+#define C4_LOGF_ERR(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
+#define C4_LOGF_WARN(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
+#define C4_LOGP(msg, ...) printf(msg)
+
+#if defined(C4_XBOX) || (defined(C4_WIN) && defined(C4_MSVC))
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/windows.hpp
+//#   include "c4/windows.hpp"
+#if !defined(C4_WINDOWS_HPP_) && !defined(_C4_WINDOWS_HPP_)
+#error "amalgamate: file c4/windows.hpp must have been included at this point"
+#endif /* C4_WINDOWS_HPP_ */
+
+#elif defined(C4_PS4)
+#   include <libdbg.h>
+#elif defined(C4_UNIX) || defined(C4_LINUX)
+#   include <sys/stat.h>
+//included above:
+//#   include <cstring>
+#   include <fcntl.h>
+#elif defined(C4_MACOS) || defined(C4_IOS)
+//included above:
+//#   include <assert.h>
+#   include <stdbool.h>
+#   include <sys/types.h>
+#   include <sys/sysctl.h>
+#endif
+// the amalgamation tool is dumb and was omitting this include under MACOS.
+// So do it only once:
+#if defined(C4_UNIX) || defined(C4_LINUX) || defined(C4_MACOS) || defined(C4_IOS)
+#   include <unistd.h>
+#endif
+
+#if defined(C4_EXCEPTIONS_ENABLED) && defined(C4_ERROR_THROWS_EXCEPTION)
+#   include <exception>
+#endif
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wformat-nonliteral"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#endif
+
+
+//-----------------------------------------------------------------------------
+namespace c4 {
+
+static error_flags         s_error_flags = ON_ERROR_DEFAULTS;
+static error_callback_type s_error_callback = nullptr;
+
+//-----------------------------------------------------------------------------
+
+error_flags get_error_flags()
+{
+    return s_error_flags;
+}
+void set_error_flags(error_flags flags)
+{
+    s_error_flags = flags;
+}
+
+error_callback_type get_error_callback()
+{
+    return s_error_callback;
+}
+/** Set the function which is called when an error occurs. */
+void set_error_callback(error_callback_type cb)
+{
+    s_error_callback = cb;
+}
+
+//-----------------------------------------------------------------------------
+
+void handle_error(srcloc where, const char *fmt, ...)
+{
+    char buf[1024];
+    size_t msglen = 0;
+    if(s_error_flags & (ON_ERROR_LOG|ON_ERROR_CALLBACK))
+    {
+        va_list args;
+        va_start(args, fmt);
+        int ilen = vsnprintf(buf, sizeof(buf), fmt, args); // ss.vprintf(fmt, args);
+        va_end(args);
+        msglen = ilen >= 0 && ilen < (int)sizeof(buf) ? static_cast<size_t>(ilen) : sizeof(buf)-1;
+    }
+
+    if(s_error_flags & ON_ERROR_LOG)
+    {
+        C4_LOGF_ERR("\n");
+#if defined(C4_ERROR_SHOWS_FILELINE) && defined(C4_ERROR_SHOWS_FUNC)
+        C4_LOGF_ERR("%s:%d: ERROR: %s\n", where.file, where.line, buf);
+        C4_LOGF_ERR("%s:%d: ERROR here: %s\n", where.file, where.line, where.func);
+#elif defined(C4_ERROR_SHOWS_FILELINE)
+        C4_LOGF_ERR("%s:%d: ERROR: %s\n", where.file, where.line, buf);
+#elif ! defined(C4_ERROR_SHOWS_FUNC)
+        C4_LOGF_ERR("ERROR: %s\n", buf);
+#endif
+    }
+
+    if(s_error_flags & ON_ERROR_CALLBACK)
+    {
+        if(s_error_callback)
+        {
+            s_error_callback(buf, msglen/*ss.c_strp(), ss.tellp()*/);
+        }
+    }
+
+    if(s_error_flags & ON_ERROR_ABORT)
+    {
+        abort();
+    }
+
+    if(s_error_flags & ON_ERROR_THROW)
+    {
+#if defined(C4_EXCEPTIONS_ENABLED) && defined(C4_ERROR_THROWS_EXCEPTION)
+        throw Exception(buf);
+#else
+        abort();
+#endif
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+void handle_warning(srcloc where, const char *fmt, ...)
+{
+    va_list args;
+    char buf[1024]; //sstream<c4::string> ss;
+    va_start(args, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, args);
+    va_end(args);
+    C4_LOGF_WARN("\n");
+#if defined(C4_ERROR_SHOWS_FILELINE) && defined(C4_ERROR_SHOWS_FUNC)
+    C4_LOGF_WARN("%s:%d: WARNING: %s\n", where.file, where.line, buf/*ss.c_strp()*/);
+    C4_LOGF_WARN("%s:%d: WARNING: here: %s\n", where.file, where.line, where.func);
+#elif defined(C4_ERROR_SHOWS_FILELINE)
+    C4_LOGF_WARN("%s:%d: WARNING: %s\n", where.file, where.line, buf/*ss.c_strp()*/);
+#elif ! defined(C4_ERROR_SHOWS_FUNC)
+    C4_LOGF_WARN("WARNING: %s\n", buf/*ss.c_strp()*/);
+#endif
+    //c4::log.flush();
+}
+
+//-----------------------------------------------------------------------------
+bool is_debugger_attached()
+{
+#if defined(C4_UNIX) || defined(C4_LINUX)
+    static bool first_call = true;
+    static bool first_call_result = false;
+    if(first_call)
+    {
+        first_call = false;
+        //! @see http://stackoverflow.com/questions/3596781/how-to-detect-if-the-current-process-is-being-run-by-gdb
+        //! (this answer: http://stackoverflow.com/a/24969863/3968589 )
+        char buf[1024] = "";
+
+        int status_fd = open("/proc/self/status", O_RDONLY);
+        if (status_fd == -1)
+        {
+            return 0;
+        }
+
+        ssize_t num_read = ::read(status_fd, buf, sizeof(buf));
+
+        if (num_read > 0)
+        {
+            static const char TracerPid[] = "TracerPid:";
+            char *tracer_pid;
+
+            if(num_read < 1024)
+            {
+                buf[num_read] = 0;
+            }
+            tracer_pid = strstr(buf, TracerPid);
+            if (tracer_pid)
+            {
+                first_call_result = !!::atoi(tracer_pid + sizeof(TracerPid) - 1);
+            }
+        }
+    }
+    return first_call_result;
+#elif defined(C4_PS4)
+    return (sceDbgIsDebuggerAttached() != 0);
+#elif defined(C4_XBOX) || (defined(C4_WIN) && defined(C4_MSVC))
+    return IsDebuggerPresent() != 0;
+#elif defined(C4_MACOS) || defined(C4_IOS)
+    // https://stackoverflow.com/questions/2200277/detecting-debugger-on-mac-os-x
+    // Returns true if the current process is being debugged (either
+    // running under the debugger or has a debugger attached post facto).
+    int                 junk;
+    int                 mib[4];
+    struct kinfo_proc   info;
+    size_t              size;
+
+    // Initialize the flags so that, if sysctl fails for some bizarre
+    // reason, we get a predictable result.
+
+    info.kp_proc.p_flag = 0;
+
+    // Initialize mib, which tells sysctl the info we want, in this case
+    // we're looking for information about a specific process ID.
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID;
+    mib[3] = getpid();
+
+    // Call sysctl.
+
+    size = sizeof(info);
+    junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0);
+    assert(junk == 0);
+
+    // We're being debugged if the P_TRACED flag is set.
+    return ((info.kp_proc.p_flag & P_TRACED) != 0);
+#else
+    return false;
+#endif
+} // is_debugger_attached()
+
+} // namespace c4
+
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/error.cpp)
+
+#endif /* _C4CORE_SINGLE_HEADER_AMALGAMATED_HPP_ */
+
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/c4core_all.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/export.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/export.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_YML_EXPORT_HPP_
+#define C4_YML_EXPORT_HPP_
+
+#ifdef _WIN32
+    #ifdef RYML_SHARED
+        #ifdef RYML_EXPORTS
+            #define RYML_EXPORT __declspec(dllexport)
+        #else
+            #define RYML_EXPORT __declspec(dllimport)
+        #endif
+    #else
+        #define RYML_EXPORT
+    #endif
+#else
+    #define RYML_EXPORT
+#endif
+
+#endif /* C4_YML_EXPORT_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/export.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/common.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/common.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_COMMON_HPP_
+#define _C4_YML_COMMON_HPP_
+
+//included above:
+//#include <cstddef>
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/substr.hpp
+//#include <c4/substr.hpp>
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/export.hpp
+//#include <c4/yml/export.hpp>
+#if !defined(C4_YML_EXPORT_HPP_) && !defined(_C4_YML_EXPORT_HPP_)
+#error "amalgamate: file c4/yml/export.hpp must have been included at this point"
+#endif /* C4_YML_EXPORT_HPP_ */
+
+
+
+#ifndef RYML_USE_ASSERT
+#   define RYML_USE_ASSERT C4_USE_ASSERT
+#endif
+
+
+#if RYML_USE_ASSERT
+#   define RYML_ASSERT(cond) RYML_CHECK(cond)
+#   define RYML_ASSERT_MSG(cond, msg) RYML_CHECK_MSG(cond, msg)
+#else
+#   define RYML_ASSERT(cond)
+#   define RYML_ASSERT_MSG(cond, msg)
+#endif
+
+
+#define RYML_CHECK(cond)                                                \
+    do {                                                                \
+        if(!(cond))                                                     \
+        {                                                               \
+            C4_DEBUG_BREAK();                                           \
+            c4::yml::error("check failed: " #cond, c4::yml::Location(__FILE__, __LINE__, 0)); \
+        }                                                               \
+    } while(0)
+
+#define RYML_CHECK_MSG(cond, msg)                                       \
+    do                                                                  \
+    {                                                                   \
+        if(!(cond))                                                     \
+        {                                                               \
+            C4_DEBUG_BREAK();                                           \
+            c4::yml::error(msg ": check failed: " #cond, c4::yml::Location(__FILE__, __LINE__, 0)); \
+        }                                                               \
+    } while(0)
+
+
+#if C4_CPP >= 14
+#   define RYML_DEPRECATED(msg) [[deprecated(msg)]]
+#else
+#   if defined(_MSC_VER)
+#       define RYML_DEPRECATED(msg) __declspec(deprecated)
+#   else // defined(__GNUC__) || defined(__clang__)
+#       define RYML_DEPRECATED(msg) __attribute__((deprecated))
+#   endif
+#endif
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+namespace yml {
+
+enum : size_t {
+    /** a null position */
+    npos = size_t(-1),
+    /** an index to none */
+    NONE = size_t(-1)
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+//! holds a position into a source buffer
+struct RYML_EXPORT LineCol
+{
+    //! number of bytes from the beginning of the source buffer
+    size_t offset;
+    //! line
+    size_t line;
+    //! column
+    size_t col;
+
+    LineCol() : offset(), line(), col() {}
+    //! construct from line and column
+    LineCol(size_t l, size_t c) : offset(0), line(l), col(c) {}
+    //! construct from offset, line and column
+    LineCol(size_t o, size_t l, size_t c) : offset(o), line(l), col(c) {}
+};
+
+
+//! a source file position
+struct RYML_EXPORT Location : public LineCol
+{
+    csubstr name;
+
+    operator bool () const { return !name.empty() || line != 0 || offset != 0; }
+
+    Location() : LineCol(), name() {}
+    Location(                         size_t l, size_t c) : LineCol{   l, c}, name( ) {}
+    Location(    csubstr n,           size_t l, size_t c) : LineCol{   l, c}, name(n) {}
+    Location(    csubstr n, size_t b, size_t l, size_t c) : LineCol{b, l, c}, name(n) {}
+    Location(const char *n,           size_t l, size_t c) : LineCol{   l, c}, name(to_csubstr(n)) {}
+    Location(const char *n, size_t b, size_t l, size_t c) : LineCol{b, l, c}, name(to_csubstr(n)) {}
+};
+
+
+//-----------------------------------------------------------------------------
+
+/** the type of the function used to report errors. This function must
+ * interrupt execution, either by raising an exception or calling
+ * std::abort(). */
+using pfn_error = void (*)(const char* msg, size_t msg_len, Location location, void *user_data);
+/** the type of the function used to allocate memory */
+using pfn_allocate = void* (*)(size_t len, void* hint, void *user_data);
+/** the type of the function used to free memory */
+using pfn_free = void (*)(void* mem, size_t size, void *user_data);
+
+/** trigger an error: call the current error callback. */
+RYML_EXPORT void error(const char *msg, size_t msg_len, Location loc);
+/** @overload error */
+inline void error(const char *msg, size_t msg_len)
+{
+    error(msg, msg_len, Location{});
+}
+/** @overload error */
+template<size_t N>
+inline void error(const char (&msg)[N], Location loc)
+{
+    error(msg, N-1, loc);
+}
+/** @overload error */
+template<size_t N>
+inline void error(const char (&msg)[N])
+{
+    error(msg, N-1, Location{});
+}
+
+//-----------------------------------------------------------------------------
+
+/// a c-style callbacks class
+struct RYML_EXPORT Callbacks
+{
+    void *       m_user_data;
+    pfn_allocate m_allocate;
+    pfn_free     m_free;
+    pfn_error    m_error;
+
+    Callbacks();
+    Callbacks(void *user_data, pfn_allocate alloc, pfn_free free, pfn_error error_);
+
+    bool operator!= (Callbacks const& that) const { return !operator==(that); }
+    bool operator== (Callbacks const& that) const
+    {
+        return (m_user_data == that.m_user_data &&
+                m_allocate == that.m_allocate &&
+                m_free == that.m_free &&
+                m_error == that.m_error);
+    }
+};
+
+/// get the global callbacks
+RYML_EXPORT Callbacks const& get_callbacks();
+/// set the global callbacks
+RYML_EXPORT void set_callbacks(Callbacks const& c);
+/// set the global callbacks to their defaults
+RYML_EXPORT void reset_callbacks();
+
+/// @cond dev
+#define _RYML_CB_ERR(cb, msg_literal)                                   \
+do                                                                      \
+{                                                                       \
+    const char msg[] = msg_literal;                                     \
+    C4_DEBUG_BREAK();                                                   \
+    (cb).m_error(msg, sizeof(msg), c4::yml::Location(__FILE__, 0, __LINE__, 0), (cb).m_user_data); \
+} while(0)
+#define _RYML_CB_CHECK(cb, cond)                                        \
+    do                                                                  \
+    {                                                                   \
+        if(!(cond))                                                     \
+        {                                                               \
+            const char msg[] = "check failed: " #cond;                  \
+            C4_DEBUG_BREAK();                                           \
+            (cb).m_error(msg, sizeof(msg), c4::yml::Location(__FILE__, 0, __LINE__, 0), (cb).m_user_data); \
+        }                                                               \
+    } while(0)
+#ifdef RYML_USE_ASSERT
+#define _RYML_CB_ASSERT(cb, cond) _RYML_CB_CHECK((cb), (cond))
+#else
+#define _RYML_CB_ASSERT(cb, cond) do {} while(0)
+#endif
+#define _RYML_CB_ALLOC_HINT(cb, T, num, hint) (T*) (cb).m_allocate((num) * sizeof(T), (hint), (cb).m_user_data)
+#define _RYML_CB_ALLOC(cb, T, num) _RYML_CB_ALLOC_HINT((cb), (T), (num), nullptr)
+#define _RYML_CB_FREE(cb, buf, T, num)                              \
+    do {                                                            \
+        (cb).m_free((buf), (num) * sizeof(T), (cb).m_user_data);    \
+        (buf) = nullptr;                                            \
+    } while(0)
+
+
+
+namespace detail {
+template<int8_t signedval, uint8_t unsignedval>
+struct _charconstant_t
+    : public std::conditional<std::is_signed<char>::value,
+                              std::integral_constant<int8_t, signedval>,
+                              std::integral_constant<uint8_t, unsignedval>>::type
+{};
+#define _RYML_CHCONST(signedval, unsignedval) ::c4::yml::detail::_charconstant_t<INT8_C(signedval), UINT8_C(unsignedval)>::value
+} // namespace detail
+
+
+namespace detail {
+struct _SubstrWriter
+{
+    substr buf;
+    size_t pos;
+    _SubstrWriter(substr buf_, size_t pos_=0) : buf(buf_), pos(pos_) {}
+    void append(csubstr s)
+    {
+        C4_ASSERT(!s.overlaps(buf));
+        if(pos + s.len <= buf.len)
+            memcpy(buf.str + pos, s.str, s.len);
+        pos += s.len;
+    }
+    void append(char c)
+    {
+        if(pos < buf.len)
+            buf.str[pos] = c;
+        ++pos;
+    }
+    void append_n(char c, size_t numtimes)
+    {
+        if(pos + numtimes < buf.len)
+            memset(buf.str + pos, c, numtimes);
+        pos += numtimes;
+    }
+    size_t slack() const { return pos <= buf.len ? buf.len - pos : 0; }
+    size_t excess() const { return pos > buf.len ? pos - buf.len : 0; }
+    //! get the part written so far
+    csubstr curr() const { return pos <= buf.len ? buf.first(pos) : buf; }
+    //! get the part that is still free to write to (the remainder)
+    substr rem() { return pos < buf.len ? buf.sub(pos) : buf.last(0); }
+
+    size_t advance(size_t more) { pos += more; return pos; }
+};
+} // namespace detail
+
+/// @endcond
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_COMMON_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/common.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/tree.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_TREE_HPP_
+#define _C4_YML_TREE_HPP_
+
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/types.hpp
+//#include "c4/types.hpp"
+#if !defined(C4_TYPES_HPP_) && !defined(_C4_TYPES_HPP_)
+#error "amalgamate: file c4/types.hpp must have been included at this point"
+#endif /* C4_TYPES_HPP_ */
+
+#ifndef _C4_YML_COMMON_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/common.hpp
+//#include "c4/yml/common.hpp"
+#if !defined(C4_YML_COMMON_HPP_) && !defined(_C4_YML_COMMON_HPP_)
+#error "amalgamate: file c4/yml/common.hpp must have been included at this point"
+#endif /* C4_YML_COMMON_HPP_ */
+
+#endif
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/charconv.hpp
+//#include <c4/charconv.hpp>
+#if !defined(C4_CHARCONV_HPP_) && !defined(_C4_CHARCONV_HPP_)
+#error "amalgamate: file c4/charconv.hpp must have been included at this point"
+#endif /* C4_CHARCONV_HPP_ */
+
+//included above:
+//#include <cmath>
+//included above:
+//#include <limits>
+
+
+C4_SUPPRESS_WARNING_MSVC_PUSH
+C4_SUPPRESS_WARNING_MSVC(4251) // needs to have dll-interface to be used by clients of struct
+C4_SUPPRESS_WARNING_MSVC(4296) // expression is always 'boolean_value'
+C4_SUPPRESS_WARNING_GCC_CLANG_PUSH
+C4_SUPPRESS_WARNING_GCC("-Wtype-limits")
+
+
+namespace c4 {
+namespace yml {
+
+struct NodeScalar;
+struct NodeInit;
+struct NodeData;
+class NodeRef;
+class Tree;
+
+
+/** encode a floating point value to a string. */
+template<class T>
+size_t to_chars_float(substr buf, T val)
+{
+    C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wfloat-equal");
+    static_assert(std::is_floating_point<T>::value, "must be floating point");
+    if(C4_UNLIKELY(std::isnan(val)))
+        return to_chars(buf, csubstr(".nan"));
+    else if(C4_UNLIKELY(val == std::numeric_limits<T>::infinity()))
+        return to_chars(buf, csubstr(".inf"));
+    else if(C4_UNLIKELY(val == -std::numeric_limits<T>::infinity()))
+        return to_chars(buf, csubstr("-.inf"));
+    return to_chars(buf, val);
+    C4_SUPPRESS_WARNING_GCC_CLANG_POP
+}
+
+
+/** decode a floating point from string. Accepts special values: .nan,
+ * .inf, -.inf */
+template<class T>
+bool from_chars_float(csubstr buf, T *C4_RESTRICT val)
+{
+    static_assert(std::is_floating_point<T>::value, "must be floating point");
+    if(C4_LIKELY(from_chars(buf, val)))
+    {
+        return true;
+    }
+    else if(C4_UNLIKELY(buf == ".nan" || buf == ".NaN" || buf == ".NAN"))
+    {
+        *val = std::numeric_limits<T>::quiet_NaN();
+        return true;
+    }
+    else if(C4_UNLIKELY(buf == ".inf" || buf == ".Inf" || buf == ".INF"))
+    {
+        *val = std::numeric_limits<T>::infinity();
+        return true;
+    }
+    else if(C4_UNLIKELY(buf == "-.inf" || buf == "-.Inf" || buf == "-.INF"))
+    {
+        *val = -std::numeric_limits<T>::infinity();
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** the integral type necessary to cover all the bits marking node tags */
+using tag_bits = uint16_t;
+
+/** a bit mask for marking tags for types */
+typedef enum : tag_bits {
+    // container types
+    TAG_NONE      =  0,
+    TAG_MAP       =  1, /**< !!map   Unordered set of key: value pairs without duplicates. @see https://yaml.org/type/map.html */
+    TAG_OMAP      =  2, /**< !!omap  Ordered sequence of key: value pairs without duplicates. @see https://yaml.org/type/omap.html */
+    TAG_PAIRS     =  3, /**< !!pairs Ordered sequence of key: value pairs allowing duplicates. @see https://yaml.org/type/pairs.html */
+    TAG_SET       =  4, /**< !!set   Unordered set of non-equal values. @see https://yaml.org/type/set.html */
+    TAG_SEQ       =  5, /**< !!seq   Sequence of arbitrary values. @see https://yaml.org/type/seq.html */
+    // scalar types
+    TAG_BINARY    =  6, /**< !!binary A sequence of zero or more octets (8 bit values). @see https://yaml.org/type/binary.html */
+    TAG_BOOL      =  7, /**< !!bool   Mathematical Booleans. @see https://yaml.org/type/bool.html */
+    TAG_FLOAT     =  8, /**< !!float  Floating-point approximation to real numbers. https://yaml.org/type/float.html */
+    TAG_INT       =  9, /**< !!float  Mathematical integers. https://yaml.org/type/int.html */
+    TAG_MERGE     = 10, /**< !!merge  Specify one or more mapping to be merged with the current one. https://yaml.org/type/merge.html */
+    TAG_NULL      = 11, /**< !!null   Devoid of value. https://yaml.org/type/null.html */
+    TAG_STR       = 12, /**< !!str    A sequence of zero or more Unicode characters. https://yaml.org/type/str.html */
+    TAG_TIMESTAMP = 13, /**< !!timestamp A point in time https://yaml.org/type/timestamp.html */
+    TAG_VALUE     = 14, /**< !!value  Specify the default value of a mapping https://yaml.org/type/value.html */
+    TAG_YAML      = 15, /**< !!yaml   Specify the default value of a mapping https://yaml.org/type/yaml.html */
+} YamlTag_e;
+
+YamlTag_e to_tag(csubstr tag);
+csubstr from_tag(YamlTag_e tag);
+csubstr from_tag_long(YamlTag_e tag);
+csubstr normalize_tag(csubstr tag);
+csubstr normalize_tag_long(csubstr tag);
+
+struct TagDirective
+{
+    /** Eg `!e!` in `%TAG !e! tag:example.com,2000:app/` */
+    csubstr handle;
+    /** Eg `tag:example.com,2000:app/` in `%TAG !e! tag:example.com,2000:app/` */
+    csubstr prefix;
+    /** The next node to which this tag directive applies */
+    size_t next_node_id;
+};
+
+#ifndef RYML_MAX_TAG_DIRECTIVES
+/** the maximum number of tag directives in a Tree */
+#define RYML_MAX_TAG_DIRECTIVES 4
+#endif
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** the integral type necessary to cover all the bits marking node types */
+using type_bits = uint64_t;
+
+
+/** a bit mask for marking node types */
+typedef enum : type_bits {
+    // a convenience define, undefined below
+    #define c4bit(v) (type_bits(1) << v)
+    NOTYPE  = 0,            ///< no node type is set
+    VAL     = c4bit(0),     ///< a leaf node, has a (possibly empty) value
+    KEY     = c4bit(1),     ///< is member of a map, must have non-empty key
+    MAP     = c4bit(2),     ///< a map: a parent of keyvals
+    SEQ     = c4bit(3),     ///< a seq: a parent of vals
+    DOC     = c4bit(4),     ///< a document
+    STREAM  = c4bit(5)|SEQ, ///< a stream: a seq of docs
+    KEYREF  = c4bit(6),     ///< a *reference: the key references an &anchor
+    VALREF  = c4bit(7),     ///< a *reference: the val references an &anchor
+    KEYANCH = c4bit(8),     ///< the key has an &anchor
+    VALANCH = c4bit(9),     ///< the val has an &anchor
+    KEYTAG  = c4bit(10),    ///< the key has an explicit tag/type
+    VALTAG  = c4bit(11),    ///< the val has an explicit tag/type
+    _TYMASK = c4bit(12)-1,  // all the bits up to here
+    VALQUO  = c4bit(12),    ///< the val is quoted by '', "", > or |
+    KEYQUO  = c4bit(13),    ///< the key is quoted by '', "", > or |
+    KEYVAL  = KEY|VAL,
+    KEYSEQ  = KEY|SEQ,
+    KEYMAP  = KEY|MAP,
+    DOCMAP  = DOC|MAP,
+    DOCSEQ  = DOC|SEQ,
+    DOCVAL  = DOC|VAL,
+    // these flags are from a work in progress and should not be used yet
+    _WIP_STYLE_FLOW_SL = c4bit(14), ///< mark container with single-line flow format (seqs as '[val1,val2], maps as '{key: val, key2: val2}')
+    _WIP_STYLE_FLOW_ML = c4bit(15), ///< mark container with multi-line flow format (seqs as '[val1,\nval2], maps as '{key: val,\nkey2: val2}')
+    _WIP_STYLE_BLOCK   = c4bit(16), ///< mark container with block format (seqs as '- val\n', maps as 'key: val')
+    _WIP_KEY_LITERAL   = c4bit(17), ///< mark key scalar as multiline, block literal |
+    _WIP_VAL_LITERAL   = c4bit(18), ///< mark val scalar as multiline, block literal |
+    _WIP_KEY_FOLDED    = c4bit(19), ///< mark key scalar as multiline, block folded >
+    _WIP_VAL_FOLDED    = c4bit(20), ///< mark val scalar as multiline, block folded >
+    _WIP_KEY_SQUO      = c4bit(21), ///< mark key scalar as single quoted
+    _WIP_VAL_SQUO      = c4bit(22), ///< mark val scalar as single quoted
+    _WIP_KEY_DQUO      = c4bit(23), ///< mark key scalar as double quoted
+    _WIP_VAL_DQUO      = c4bit(24), ///< mark val scalar as double quoted
+    _WIP_KEY_PLAIN     = c4bit(25), ///< mark key scalar as plain scalar (unquoted, even when multiline)
+    _WIP_VAL_PLAIN     = c4bit(26), ///< mark val scalar as plain scalar (unquoted, even when multiline)
+    _WIP_KEY_STYLE     = _WIP_KEY_LITERAL|_WIP_KEY_FOLDED|_WIP_KEY_SQUO|_WIP_KEY_DQUO|_WIP_KEY_PLAIN,
+    _WIP_VAL_STYLE     = _WIP_VAL_LITERAL|_WIP_VAL_FOLDED|_WIP_VAL_SQUO|_WIP_VAL_DQUO|_WIP_VAL_PLAIN,
+    _WIP_KEY_FT_NL     = c4bit(27), ///< features: mark key scalar as having \n in its contents
+    _WIP_VAL_FT_NL     = c4bit(28), ///< features: mark val scalar as having \n in its contents
+    _WIP_KEY_FT_SQ     = c4bit(29), ///< features: mark key scalar as having single quotes in its contents
+    _WIP_VAL_FT_SQ     = c4bit(30), ///< features: mark val scalar as having single quotes in its contents
+    _WIP_KEY_FT_DQ     = c4bit(31), ///< features: mark key scalar as having double quotes in its contents
+    _WIP_VAL_FT_DQ     = c4bit(32), ///< features: mark val scalar as having double quotes in its contents
+    #undef c4bit
+} NodeType_e;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** wraps a NodeType_e element with some syntactic sugar and predicates */
+struct NodeType
+{
+public:
+
+    NodeType_e type;
+
+public:
+
+    C4_ALWAYS_INLINE operator NodeType_e      & C4_RESTRICT ()       { return type; }
+    C4_ALWAYS_INLINE operator NodeType_e const& C4_RESTRICT () const { return type; }
+
+    C4_ALWAYS_INLINE NodeType() : type(NOTYPE) {}
+    C4_ALWAYS_INLINE NodeType(NodeType_e t) : type(t) {}
+    C4_ALWAYS_INLINE NodeType(type_bits t) : type((NodeType_e)t) {}
+
+    C4_ALWAYS_INLINE const char *type_str() const { return type_str(type); }
+    static const char* type_str(NodeType_e t);
+
+    C4_ALWAYS_INLINE void set(NodeType_e t) { type = t; }
+    C4_ALWAYS_INLINE void set(type_bits  t) { type = (NodeType_e)t; }
+
+    C4_ALWAYS_INLINE void add(NodeType_e t) { type = (NodeType_e)(type|t); }
+    C4_ALWAYS_INLINE void add(type_bits  t) { type = (NodeType_e)(type|t); }
+
+    C4_ALWAYS_INLINE void rem(NodeType_e t) { type = (NodeType_e)(type & ~t); }
+    C4_ALWAYS_INLINE void rem(type_bits  t) { type = (NodeType_e)(type & ~t); }
+
+    C4_ALWAYS_INLINE void clear() { type = NOTYPE; }
+
+public:
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic push
+    #   pragma clang diagnostic ignored "-Wnull-dereference"
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic push
+    #   if __GNUC__ >= 6
+    #       pragma GCC diagnostic ignored "-Wnull-dereference"
+    #   endif
+    #endif
+
+    C4_ALWAYS_INLINE bool is_stream() const { return ((type & STREAM) == STREAM) != 0; }
+    C4_ALWAYS_INLINE bool is_doc() const { return (type & DOC) != 0; }
+    C4_ALWAYS_INLINE bool is_container() const { return (type & (MAP|SEQ|STREAM)) != 0; }
+    C4_ALWAYS_INLINE bool is_map() const { return (type & MAP) != 0; }
+    C4_ALWAYS_INLINE bool is_seq() const { return (type & SEQ) != 0; }
+    C4_ALWAYS_INLINE bool has_val() const { return (type & VAL) != 0; }
+    C4_ALWAYS_INLINE bool has_key() const { return (type & KEY) != 0; }
+    C4_ALWAYS_INLINE bool is_val() const { return (type & (KEYVAL)) == VAL; }
+    C4_ALWAYS_INLINE bool is_keyval() const { return (type & KEYVAL) == KEYVAL; }
+    C4_ALWAYS_INLINE bool has_key_tag() const { return (type & (KEY|KEYTAG)) == (KEY|KEYTAG); }
+    C4_ALWAYS_INLINE bool has_val_tag() const { return ((type & (VALTAG)) && (type & (VAL|MAP|SEQ))); }
+    C4_ALWAYS_INLINE bool has_key_anchor() const { return (type & (KEY|KEYANCH)) == (KEY|KEYANCH); }
+    C4_ALWAYS_INLINE bool is_key_anchor() const { return (type & (KEY|KEYANCH)) == (KEY|KEYANCH); }
+    C4_ALWAYS_INLINE bool has_val_anchor() const { return (type & VALANCH) != 0 && (type & (VAL|SEQ|MAP)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_anchor() const { return (type & VALANCH) != 0 && (type & (VAL|SEQ|MAP)) != 0; }
+    C4_ALWAYS_INLINE bool has_anchor() const { return (type & (KEYANCH|VALANCH)) != 0; }
+    C4_ALWAYS_INLINE bool is_anchor() const { return (type & (KEYANCH|VALANCH)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_ref() const { return (type & KEYREF) != 0; }
+    C4_ALWAYS_INLINE bool is_val_ref() const { return (type & VALREF) != 0; }
+    C4_ALWAYS_INLINE bool is_ref() const { return (type & (KEYREF|VALREF)) != 0; }
+    C4_ALWAYS_INLINE bool is_anchor_or_ref() const { return (type & (KEYANCH|VALANCH|KEYREF|VALREF)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_quoted() const { return (type & (KEY|KEYQUO)) == (KEY|KEYQUO); }
+    C4_ALWAYS_INLINE bool is_val_quoted() const { return (type & (VAL|VALQUO)) == (VAL|VALQUO); }
+    C4_ALWAYS_INLINE bool is_quoted() const { return (type & (KEY|KEYQUO)) == (KEY|KEYQUO) || (type & (VAL|VALQUO)) == (VAL|VALQUO); }
+
+    // these predicates are a work in progress and subject to change. Don't use yet.
+    C4_ALWAYS_INLINE bool default_block() const { return (type & (_WIP_STYLE_BLOCK|_WIP_STYLE_FLOW_ML|_WIP_STYLE_FLOW_SL)) == 0; }
+    C4_ALWAYS_INLINE bool marked_block() const { return (type & (_WIP_STYLE_BLOCK)) != 0; }
+    C4_ALWAYS_INLINE bool marked_flow_sl() const { return (type & (_WIP_STYLE_FLOW_SL)) != 0; }
+    C4_ALWAYS_INLINE bool marked_flow_ml() const { return (type & (_WIP_STYLE_FLOW_ML)) != 0; }
+    C4_ALWAYS_INLINE bool marked_flow() const { return (type & (_WIP_STYLE_FLOW_ML|_WIP_STYLE_FLOW_SL)) != 0; }
+    C4_ALWAYS_INLINE bool key_marked_literal() const { return (type & (_WIP_KEY_LITERAL)) != 0; }
+    C4_ALWAYS_INLINE bool val_marked_literal() const { return (type & (_WIP_VAL_LITERAL)) != 0; }
+    C4_ALWAYS_INLINE bool key_marked_folded() const { return (type & (_WIP_KEY_FOLDED)) != 0; }
+    C4_ALWAYS_INLINE bool val_marked_folded() const { return (type & (_WIP_VAL_FOLDED)) != 0; }
+    C4_ALWAYS_INLINE bool key_marked_squo() const { return (type & (_WIP_KEY_SQUO)) != 0; }
+    C4_ALWAYS_INLINE bool val_marked_squo() const { return (type & (_WIP_VAL_SQUO)) != 0; }
+    C4_ALWAYS_INLINE bool key_marked_dquo() const { return (type & (_WIP_KEY_DQUO)) != 0; }
+    C4_ALWAYS_INLINE bool val_marked_dquo() const { return (type & (_WIP_VAL_DQUO)) != 0; }
+    C4_ALWAYS_INLINE bool key_marked_plain() const { return (type & (_WIP_KEY_PLAIN)) != 0; }
+    C4_ALWAYS_INLINE bool val_marked_plain() const { return (type & (_WIP_VAL_PLAIN)) != 0; }
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic pop
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic pop
+    #endif
+
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** a node scalar is a csubstr, which may be tagged and anchored. */
+struct NodeScalar
+{
+    csubstr tag;
+    csubstr scalar;
+    csubstr anchor;
+
+public:
+
+    /// initialize as an empty scalar
+    inline NodeScalar() noexcept : tag(), scalar(), anchor() {}
+
+    /// initialize as an untagged scalar
+    template<size_t N>
+    inline NodeScalar(const char (&s)[N]) noexcept : tag(), scalar(s), anchor() {}
+    inline NodeScalar(csubstr      s    ) noexcept : tag(), scalar(s), anchor() {}
+
+    /// initialize as a tagged scalar
+    template<size_t N, size_t M>
+    inline NodeScalar(const char (&t)[N], const char (&s)[N]) noexcept : tag(t), scalar(s), anchor() {}
+    inline NodeScalar(csubstr      t    , csubstr      s    ) noexcept : tag(t), scalar(s), anchor() {}
+
+public:
+
+    ~NodeScalar() noexcept = default;
+    NodeScalar(NodeScalar &&) noexcept = default;
+    NodeScalar(NodeScalar const&) noexcept = default;
+    NodeScalar& operator= (NodeScalar &&) noexcept = default;
+    NodeScalar& operator= (NodeScalar const&) noexcept = default;
+
+public:
+
+    bool empty() const noexcept { return tag.empty() && scalar.empty() && anchor.empty(); }
+
+    void clear() noexcept { tag.clear(); scalar.clear(); anchor.clear(); }
+
+    void set_ref_maybe_replacing_scalar(csubstr ref, bool has_scalar) noexcept
+    {
+        csubstr trimmed = ref.begins_with('*') ? ref.sub(1) : ref;
+        anchor = trimmed;
+        if((!has_scalar) || !scalar.ends_with(trimmed))
+            scalar = ref;
+    }
+};
+C4_MUST_BE_TRIVIAL_COPY(NodeScalar);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** convenience class to initialize nodes */
+struct NodeInit
+{
+
+    NodeType   type;
+    NodeScalar key;
+    NodeScalar val;
+
+public:
+
+    /// initialize as an empty node
+    NodeInit() : type(NOTYPE), key(), val() {}
+    /// initialize as a typed node
+    NodeInit(NodeType_e t) : type(t), key(), val() {}
+    /// initialize as a sequence member
+    NodeInit(NodeScalar const& v) : type(VAL), key(), val(v) { _add_flags(); }
+    /// initialize as a mapping member
+    NodeInit(              NodeScalar const& k, NodeScalar const& v) : type(KEYVAL), key(k.tag, k.scalar), val(v.tag, v.scalar) { _add_flags(); }
+    /// initialize as a mapping member with explicit type
+    NodeInit(NodeType_e t, NodeScalar const& k, NodeScalar const& v) : type(t     ), key(k.tag, k.scalar), val(v.tag, v.scalar) { _add_flags(); }
+    /// initialize as a mapping member with explicit type (eg SEQ or MAP)
+    NodeInit(NodeType_e t, NodeScalar const& k                     ) : type(t     ), key(k.tag, k.scalar), val(               ) { _add_flags(KEY); }
+
+public:
+
+    void clear()
+    {
+        type.clear();
+        key.clear();
+        val.clear();
+    }
+
+    void _add_flags(type_bits more_flags=0)
+    {
+        type = (type|more_flags);
+        if( ! key.tag.empty())
+            type = (type|KEYTAG);
+        if( ! val.tag.empty())
+            type = (type|VALTAG);
+        if( ! key.anchor.empty())
+            type = (type|KEYANCH);
+        if( ! val.anchor.empty())
+            type = (type|VALANCH);
+    }
+
+    bool _check() const
+    {
+        // key cannot be empty
+        RYML_ASSERT(key.scalar.empty() == ((type & KEY) == 0));
+        // key tag cannot be empty
+        RYML_ASSERT(key.tag.empty() == ((type & KEYTAG) == 0));
+        // val may be empty even though VAL is set. But when VAL is not set, val must be empty
+        RYML_ASSERT(((type & VAL) != 0) || val.scalar.empty());
+        // val tag cannot be empty
+        RYML_ASSERT(val.tag.empty() == ((type & VALTAG) == 0));
+        return true;
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** contains the data for each YAML node. */
+struct NodeData
+{
+    NodeType   m_type;
+
+    NodeScalar m_key;
+    NodeScalar m_val;
+
+    size_t     m_parent;
+    size_t     m_first_child;
+    size_t     m_last_child;
+    size_t     m_next_sibling;
+    size_t     m_prev_sibling;
+};
+C4_MUST_BE_TRIVIAL_COPY(NodeData);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+class RYML_EXPORT Tree
+{
+public:
+
+    /** @name construction and assignment */
+    /** @{ */
+
+    Tree() : Tree(get_callbacks()) {}
+    Tree(Callbacks const& cb);
+    Tree(size_t node_capacity, size_t arena_capacity=0) : Tree(node_capacity, arena_capacity, get_callbacks()) {}
+    Tree(size_t node_capacity, size_t arena_capacity, Callbacks const& cb);
+
+    ~Tree();
+
+    Tree(Tree const& that) noexcept;
+    Tree(Tree     && that) noexcept;
+
+    Tree& operator= (Tree const& that) noexcept;
+    Tree& operator= (Tree     && that) noexcept;
+
+    /** @} */
+
+public:
+
+    /** @name memory and sizing */
+    /** @{ */
+
+    void reserve(size_t node_capacity);
+
+    /** clear the tree and zero every node
+     * @note does NOT clear the arena
+     * @see clear_arena() */
+    void clear();
+    inline void clear_arena() { m_arena_pos = 0; }
+
+    inline bool   empty() const { return m_size == 0; }
+
+    inline size_t size () const { return m_size; }
+    inline size_t capacity() const { return m_cap; }
+    inline size_t slack() const { RYML_ASSERT(m_cap >= m_size); return m_cap - m_size; }
+
+    inline size_t arena_size() const { return m_arena_pos; }
+    inline size_t arena_capacity() const { return m_arena.len; }
+    inline size_t arena_slack() const { RYML_ASSERT(m_arena.len >= m_arena_pos); return m_arena.len - m_arena_pos; }
+
+    Callbacks const& callbacks() const { return m_callbacks; }
+    void callbacks(Callbacks const& cb) { m_callbacks = cb; }
+
+    /** @} */
+
+public:
+
+    /** @name node getters */
+    /** @{ */
+
+    //! get the index of a node belonging to this tree.
+    //! @p n can be nullptr, in which case a
+    size_t id(NodeData const* n) const
+    {
+        if( ! n)
+        {
+            return NONE;
+        }
+        RYML_ASSERT(n >= m_buf && n < m_buf + m_cap);
+        return static_cast<size_t>(n - m_buf);
+    }
+
+    //! get a pointer to a node's NodeData.
+    //! i can be NONE, in which case a nullptr is returned
+    inline NodeData *get(size_t i)
+    {
+        if(i == NONE)
+            return nullptr;
+        RYML_ASSERT(i >= 0 && i < m_cap);
+        return m_buf + i;
+    }
+    //! get a pointer to a node's NodeData.
+    //! i can be NONE, in which case a nullptr is returned.
+    inline NodeData const *get(size_t i) const
+    {
+        if(i == NONE)
+            return nullptr;
+        RYML_ASSERT(i >= 0 && i < m_cap);
+        return m_buf + i;
+    }
+
+    //! An if-less form of get() that demands a valid node index.
+    //! This function is implementation only; use at your own risk.
+    inline NodeData       * _p(size_t i)       { RYML_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; }
+    //! An if-less form of get() that demands a valid node index.
+    //! This function is implementation only; use at your own risk.
+    inline NodeData const * _p(size_t i) const { RYML_ASSERT(i != NONE && i >= 0 && i < m_cap); return m_buf + i; }
+
+    //! Get the id of the root node
+    size_t root_id()       { if(m_cap == 0) { reserve(16); } RYML_ASSERT(m_cap > 0 && m_size > 0); return 0; }
+    //! Get the id of the root node
+    size_t root_id() const {                                 RYML_ASSERT(m_cap > 0 && m_size > 0); return 0; }
+
+    //! Get a NodeRef of a node by id
+    NodeRef       ref(size_t id);
+    //! Get a NodeRef of a node by id
+    NodeRef const ref(size_t id) const;
+
+    //! Get the root as a NodeRef
+    NodeRef       rootref();
+    //! Get the root as a NodeRef
+    NodeRef const rootref() const;
+
+    //! find a root child by name, return it as a NodeRef
+    //! @note requires the root to be a map.
+    NodeRef       operator[] (csubstr key);
+    //! find a root child by name, return it as a NodeRef
+    //! @note requires the root to be a map.
+    NodeRef const operator[] (csubstr key) const;
+
+    //! find a root child by index: return the root node's @p i-th child as a NodeRef
+    //! @note @i is NOT the node id, but the child's position
+    NodeRef       operator[] (size_t i);
+    //! find a root child by index: return the root node's @p i-th child as a NodeRef
+    //! @note @i is NOT the node id, but the child's position
+    NodeRef const operator[] (size_t i) const;
+
+    //! get the i-th document of the stream
+    //! @note @i is NOT the node id, but the doc position within the stream
+    NodeRef       docref(size_t i);
+    //! get the i-th document of the stream
+    //! @note @i is NOT the node id, but the doc position within the stream
+    NodeRef const docref(size_t i) const;
+
+    /** @} */
+
+public:
+
+    /** @name node property getters */
+    /** @{ */
+
+    NodeType type(size_t node) const { return _p(node)->m_type; }
+    const char* type_str(size_t node) const { return NodeType::type_str(_p(node)->m_type); }
+
+    csubstr    const& key       (size_t node) const { RYML_ASSERT(has_key(node)); return _p(node)->m_key.scalar; }
+    csubstr    const& key_tag   (size_t node) const { RYML_ASSERT(has_key_tag(node)); return _p(node)->m_key.tag; }
+    csubstr    const& key_ref   (size_t node) const { RYML_ASSERT(is_key_ref(node) && ! has_key_anchor(node)); return _p(node)->m_key.anchor; }
+    csubstr    const& key_anchor(size_t node) const { RYML_ASSERT( ! is_key_ref(node) && has_key_anchor(node)); return _p(node)->m_key.anchor; }
+    NodeScalar const& keysc     (size_t node) const { RYML_ASSERT(has_key(node)); return _p(node)->m_key; }
+
+    csubstr    const& val       (size_t node) const { RYML_ASSERT(has_val(node)); return _p(node)->m_val.scalar; }
+    csubstr    const& val_tag   (size_t node) const { RYML_ASSERT(has_val_tag(node)); return _p(node)->m_val.tag; }
+    csubstr    const& val_ref   (size_t node) const { RYML_ASSERT(is_val_ref(node) && ! has_val_anchor(node)); return _p(node)->m_val.anchor; }
+    csubstr    const& val_anchor(size_t node) const { RYML_ASSERT( ! is_val_ref(node) && has_val_anchor(node)); return _p(node)->m_val.anchor; }
+    NodeScalar const& valsc     (size_t node) const { RYML_ASSERT(has_val(node)); return _p(node)->m_val; }
+
+    bool key_is_null(size_t node) const { RYML_ASSERT(has_key(node)); if(is_key_quoted(node)) return false; csubstr s = _p(node)->m_key.scalar; return s == nullptr || s == "~" || s == "null" || s == "Null" || s == "NULL"; }
+    bool val_is_null(size_t node) const { RYML_ASSERT(has_val(node)); if(is_val_quoted(node)) return false; csubstr s = _p(node)->m_val.scalar; return s == nullptr || s == "~" || s == "null" || s == "Null" || s == "NULL"; }
+
+    /** @} */
+
+public:
+
+    /** @name node type predicates */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool is_stream(size_t node) const { return _p(node)->m_type.is_stream(); }
+    C4_ALWAYS_INLINE bool is_doc(size_t node) const { return _p(node)->m_type.is_doc(); }
+    C4_ALWAYS_INLINE bool is_container(size_t node) const { return _p(node)->m_type.is_container(); }
+    C4_ALWAYS_INLINE bool is_map(size_t node) const { return _p(node)->m_type.is_map(); }
+    C4_ALWAYS_INLINE bool is_seq(size_t node) const { return _p(node)->m_type.is_seq(); }
+    C4_ALWAYS_INLINE bool has_key(size_t node) const { return _p(node)->m_type.has_key(); }
+    C4_ALWAYS_INLINE bool has_val(size_t node) const { return _p(node)->m_type.has_val(); }
+    C4_ALWAYS_INLINE bool is_val(size_t node) const { return _p(node)->m_type.is_val(); }
+    C4_ALWAYS_INLINE bool is_keyval(size_t node) const { return _p(node)->m_type.is_keyval(); }
+    C4_ALWAYS_INLINE bool has_key_tag(size_t node) const { return _p(node)->m_type.has_key_tag(); }
+    C4_ALWAYS_INLINE bool has_val_tag(size_t node) const { return _p(node)->m_type.has_val_tag(); }
+    C4_ALWAYS_INLINE bool has_key_anchor(size_t node) const { return _p(node)->m_type.has_key_anchor(); }
+    C4_ALWAYS_INLINE bool is_key_anchor(size_t node) const { return _p(node)->m_type.is_key_anchor(); }
+    C4_ALWAYS_INLINE bool has_val_anchor(size_t node) const { return _p(node)->m_type.has_val_anchor(); }
+    C4_ALWAYS_INLINE bool is_val_anchor(size_t node) const { return _p(node)->m_type.is_val_anchor(); }
+    C4_ALWAYS_INLINE bool has_anchor(size_t node) const { return _p(node)->m_type.has_anchor(); }
+    C4_ALWAYS_INLINE bool is_anchor(size_t node) const { return _p(node)->m_type.is_anchor(); }
+    C4_ALWAYS_INLINE bool is_key_ref(size_t node) const { return _p(node)->m_type.is_key_ref(); }
+    C4_ALWAYS_INLINE bool is_val_ref(size_t node) const { return _p(node)->m_type.is_val_ref(); }
+    C4_ALWAYS_INLINE bool is_ref(size_t node) const { return _p(node)->m_type.is_ref(); }
+    C4_ALWAYS_INLINE bool is_anchor_or_ref(size_t node) const { return _p(node)->m_type.is_anchor_or_ref(); }
+    C4_ALWAYS_INLINE bool is_key_quoted(size_t node) const { return _p(node)->m_type.is_key_quoted(); }
+    C4_ALWAYS_INLINE bool is_val_quoted(size_t node) const { return _p(node)->m_type.is_val_quoted(); }
+    C4_ALWAYS_INLINE bool is_quoted(size_t node) const { return _p(node)->m_type.is_quoted(); }
+
+    C4_ALWAYS_INLINE bool parent_is_seq(size_t node) const { RYML_ASSERT(has_parent(node)); return is_seq(_p(node)->m_parent); }
+    C4_ALWAYS_INLINE bool parent_is_map(size_t node) const { RYML_ASSERT(has_parent(node)); return is_map(_p(node)->m_parent); }
+
+    /** true when key and val are empty, and has no children */
+    bool empty(size_t node) const { return ! has_children(node) && _p(node)->m_key.empty() && (( ! (_p(node)->m_type & VAL)) || _p(node)->m_val.empty()); }
+    /** true when the node has an anchor named a */
+    bool has_anchor(size_t node, csubstr a) const { return _p(node)->m_key.anchor == a || _p(node)->m_val.anchor == a; }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy predicates */
+    /** @{ */
+
+    bool is_root(size_t node) const { RYML_ASSERT(_p(node)->m_parent != NONE || node == 0); return _p(node)->m_parent == NONE; }
+
+    bool has_parent(size_t node) const { return _p(node)->m_parent != NONE; }
+
+    bool has_child(size_t node, csubstr key) const { return find_child(node, key) != npos; }
+    bool has_child(size_t node, size_t ch) const { return child_pos(node, ch) != npos; }
+    bool has_children(size_t node) const { return _p(node)->m_first_child != NONE; }
+
+    bool has_sibling(size_t node, size_t sib) const { return is_root(node) ? sib==node : child_pos(_p(node)->m_parent, sib) != npos; }
+    bool has_sibling(size_t node, csubstr key) const { return find_sibling(node, key) != npos; }
+    /** counts with *this */
+    bool has_siblings(size_t /*node*/) const { return true; }
+    /** does not count with *this */
+    bool has_other_siblings(size_t node) const { return is_root(node) ? false : (_p(_p(node)->m_parent)->m_first_child != _p(_p(node)->m_parent)->m_last_child); }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy getters */
+    /** @{ */
+
+    size_t parent(size_t node) const { return _p(node)->m_parent; }
+
+    size_t prev_sibling(size_t node) const { return _p(node)->m_prev_sibling; }
+    size_t next_sibling(size_t node) const { return _p(node)->m_next_sibling; }
+
+    /** O(#num_children) */
+    size_t num_children(size_t node) const;
+    size_t child_pos(size_t node, size_t ch) const;
+    size_t first_child(size_t node) const { return _p(node)->m_first_child; }
+    size_t last_child(size_t node) const { return _p(node)->m_last_child; }
+    size_t child(size_t node, size_t pos) const;
+    size_t find_child(size_t node, csubstr const& key) const;
+
+    /** O(#num_siblings) */
+    /** counts with this */
+    size_t num_siblings(size_t node) const { return is_root(node) ? 1 : num_children(_p(node)->m_parent); }
+    /** does not count with this */
+    size_t num_other_siblings(size_t node) const { size_t ns = num_siblings(node); RYML_ASSERT(ns > 0); return ns-1; }
+    size_t sibling_pos(size_t node, size_t sib) const { RYML_ASSERT( ! is_root(node) || node == root_id()); return child_pos(_p(node)->m_parent, sib); }
+    size_t first_sibling(size_t node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_first_child; }
+    size_t last_sibling(size_t node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_last_child; }
+    size_t sibling(size_t node, size_t pos) const { return child(_p(node)->m_parent, pos); }
+    size_t find_sibling(size_t node, csubstr const& key) const { return find_child(_p(node)->m_parent, key); }
+
+    size_t doc(size_t i) const { size_t rid = root_id(); RYML_ASSERT(is_stream(rid)); return child(rid, i); } //!< gets the @p i document node index. requires that the root node is a stream.
+
+    /** @} */
+
+public:
+
+    /** @name node modifiers */
+    /** @{ */
+
+    void to_keyval(size_t node, csubstr key, csubstr val, type_bits more_flags=0);
+    void to_map(size_t node, csubstr key, type_bits more_flags=0);
+    void to_seq(size_t node, csubstr key, type_bits more_flags=0);
+    void to_val(size_t node, csubstr val, type_bits more_flags=0);
+    void to_map(size_t node, type_bits more_flags=0);
+    void to_seq(size_t node, type_bits more_flags=0);
+    void to_doc(size_t node, type_bits more_flags=0);
+    void to_stream(size_t node, type_bits more_flags=0);
+
+    void set_key(size_t node, csubstr key) { RYML_ASSERT(has_key(node)); _p(node)->m_key.scalar = key; }
+    void set_val(size_t node, csubstr val) { RYML_ASSERT(has_val(node)); _p(node)->m_val.scalar = val; }
+
+    void set_key_tag(size_t node, csubstr tag) { RYML_ASSERT(has_key(node)); _p(node)->m_key.tag = tag; _add_flags(node, KEYTAG); }
+    void set_val_tag(size_t node, csubstr tag) { RYML_ASSERT(has_val(node) || is_container(node)); _p(node)->m_val.tag = tag; _add_flags(node, VALTAG); }
+
+    void set_key_anchor(size_t node, csubstr anchor) { RYML_ASSERT( ! is_key_ref(node)); _p(node)->m_key.anchor = anchor.triml('&'); _add_flags(node, KEYANCH); }
+    void set_val_anchor(size_t node, csubstr anchor) { RYML_ASSERT( ! is_val_ref(node)); _p(node)->m_val.anchor = anchor.triml('&'); _add_flags(node, VALANCH); }
+    void set_key_ref   (size_t node, csubstr ref   ) { RYML_ASSERT( ! has_key_anchor(node)); NodeData* C4_RESTRICT n = _p(node); n->m_key.set_ref_maybe_replacing_scalar(ref, n->m_type.has_key()); _add_flags(node, KEY|KEYREF); }
+    void set_val_ref   (size_t node, csubstr ref   ) { RYML_ASSERT( ! has_val_anchor(node)); NodeData* C4_RESTRICT n = _p(node); n->m_val.set_ref_maybe_replacing_scalar(ref, n->m_type.has_val()); _add_flags(node, VAL|VALREF); }
+
+    void rem_key_anchor(size_t node) { _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYANCH); }
+    void rem_val_anchor(size_t node) { _p(node)->m_val.anchor.clear(); _rem_flags(node, VALANCH); }
+    void rem_key_ref   (size_t node) { _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYREF); }
+    void rem_val_ref   (size_t node) { _p(node)->m_val.anchor.clear(); _rem_flags(node, VALREF); }
+    void rem_anchor_ref(size_t node) { _p(node)->m_key.anchor.clear(); _p(node)->m_val.anchor.clear(); _rem_flags(node, KEYANCH|VALANCH|KEYREF|VALREF); }
+
+    /** @} */
+
+public:
+
+    /** @name tree modifiers */
+    /** @{ */
+
+    /** reorder the tree in memory so that all the nodes are stored
+     * in a linear sequence when visited in depth-first order.
+     * This will invalidate existing ids, since the node id is its
+     * position in the node array. */
+    void reorder();
+
+    /** Resolve references (aliases <- anchors) in the tree.
+     *
+     * Dereferencing is opt-in; after parsing, Tree::resolve()
+     * has to be called explicitly for obtaining resolved references in the
+     * tree. This method will resolve all references and substitute the
+     * anchored values in place of the reference.
+     *
+     * This method first does a full traversal of the tree to gather all
+     * anchors and references in a separate collection, then it goes through
+     * that collection to locate the names, which it does by obeying the YAML
+     * standard diktat that "an alias node refers to the most recent node in
+     * the serialization having the specified anchor"
+     *
+     * So, depending on the number of anchor/alias nodes, this is a
+     * potentially expensive operation, with a best-case linear complexity
+     * (from the initial traversal). This potential cost is the reason for
+     * requiring an explicit call.
+     */
+    void resolve();
+
+    /** @} */
+
+public:
+
+    /** @name tag directives */
+    /** @{ */
+
+    void resolve_tags();
+
+    size_t num_tag_directives() const;
+    size_t add_tag_directive(TagDirective const& td);
+    void clear_tag_directives();
+
+    size_t resolve_tag(substr output, csubstr tag, size_t node_id) const;
+    csubstr resolve_tag_sub(substr output, csubstr tag, size_t node_id) const
+    {
+        size_t needed = resolve_tag(output, tag, node_id);
+        return needed <= output.len ? output.first(needed) : output;
+    }
+
+    using tag_directive_const_iterator = TagDirective const*;
+    tag_directive_const_iterator begin_tag_directives() const { return m_tag_directives; }
+    tag_directive_const_iterator end_tag_directives() const { return m_tag_directives + num_tag_directives(); }
+
+    struct TagDirectiveProxy
+    {
+        tag_directive_const_iterator b, e;
+        tag_directive_const_iterator begin() const { return b; }
+        tag_directive_const_iterator end() const { return e; }
+    };
+
+    TagDirectiveProxy tag_directives() const { return TagDirectiveProxy{begin_tag_directives(), end_tag_directives()}; }
+
+    /** @} */
+
+public:
+
+    /** @name modifying hierarchy */
+    /** @{ */
+
+    /** create and insert a new child of "parent". insert after the (to-be)
+     * sibling "after", which must be a child of "parent". To insert as the
+     * first child, set after to NONE */
+    inline size_t insert_child(size_t parent, size_t after)
+    {
+        RYML_ASSERT(parent != NONE);
+        RYML_ASSERT(is_container(parent) || is_root(parent));
+        RYML_ASSERT(after == NONE || has_child(parent, after));
+        size_t child = _claim();
+        _set_hierarchy(child, parent, after);
+        return child;
+    }
+    inline size_t prepend_child(size_t parent) { return insert_child(parent, NONE); }
+    inline size_t  append_child(size_t parent) { return insert_child(parent, last_child(parent)); }
+
+public:
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic push
+    #   pragma clang diagnostic ignored "-Wnull-dereference"
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic push
+    #   if __GNUC__ >= 6
+    #       pragma GCC diagnostic ignored "-Wnull-dereference"
+    #   endif
+    #endif
+
+    //! create and insert a new sibling of n. insert after "after"
+    inline size_t insert_sibling(size_t node, size_t after)
+    {
+        RYML_ASSERT(node != NONE);
+        RYML_ASSERT( ! is_root(node));
+        RYML_ASSERT(parent(node) != NONE);
+        RYML_ASSERT(after == NONE || (has_sibling(node, after) && has_sibling(after, node)));
+        RYML_ASSERT(get(node) != nullptr);
+        return insert_child(get(node)->m_parent, after);
+    }
+    inline size_t prepend_sibling(size_t node) { return insert_sibling(node, NONE); }
+    inline size_t  append_sibling(size_t node) { return insert_sibling(node, last_sibling(node)); }
+
+public:
+
+    /** remove an entire branch at once: ie remove the children and the node itself */
+    inline void remove(size_t node)
+    {
+        remove_children(node);
+        _release(node);
+    }
+
+    /** remove all the node's children, but keep the node itself */
+    void remove_children(size_t node);
+
+    /** change the @p type of the node to one of MAP, SEQ or VAL.  @p
+     * type must have one and only one of MAP,SEQ,VAL; @p type may
+     * possibly have KEY, but if it does, then the @p node must also
+     * have KEY. Changing to the same type is a no-op. Otherwise,
+     * changing to a different type will initialize the node with an
+     * empty value of the desired type: changing to VAL will
+     * initialize with a null scalar (~), changing to MAP will
+     * initialize with an empty map ({}), and changing to SEQ will
+     * initialize with an empty seq ([]). */
+    bool change_type(size_t node, NodeType type);
+
+    bool change_type(size_t node, type_bits type)
+    {
+        return change_type(node, (NodeType)type);
+    }
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic pop
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic pop
+    #endif
+
+public:
+
+    /** change the node's position in the parent */
+    void move(size_t node, size_t after);
+
+    /** change the node's parent and position */
+    void move(size_t node, size_t new_parent, size_t after);
+
+    /** change the node's parent and position to a different tree
+     * @return the index of the new node in the destination tree */
+    size_t move(Tree * src, size_t node, size_t new_parent, size_t after);
+
+    /** ensure the first node is a stream. Eg, change this tree
+     *
+     *  DOCMAP
+     *    MAP
+     *      KEYVAL
+     *      KEYVAL
+     *    SEQ
+     *      VAL
+     *
+     * to
+     *
+     *  STREAM
+     *    DOCMAP
+     *      MAP
+     *        KEYVAL
+     *        KEYVAL
+     *      SEQ
+     *        VAL
+     *
+     * If the root is already a stream, this is a no-op.
+     */
+    void set_root_as_stream();
+
+public:
+
+    /** recursively duplicate a node from this tree into a new parent,
+     * placing it after one of its children
+     * @return the index of the copy */
+    size_t duplicate(size_t node, size_t new_parent, size_t after);
+    /** recursively duplicate a node from a different tree into a new parent,
+     * placing it after one of its children
+     * @return the index of the copy */
+    size_t duplicate(Tree const* src, size_t node, size_t new_parent, size_t after);
+
+    /** recursively duplicate the node's children (but not the node)
+     * @return the index of the last duplicated child */
+    size_t duplicate_children(size_t node, size_t parent, size_t after);
+    /** recursively duplicate the node's children (but not the node), where
+     * the node is from a different tree
+     * @return the index of the last duplicated child */
+    size_t duplicate_children(Tree const* src, size_t node, size_t parent, size_t after);
+
+    void duplicate_contents(size_t node, size_t where);
+    void duplicate_contents(Tree const* src, size_t node, size_t where);
+
+    /** duplicate the node's children (but not the node) in a new parent, but
+     * omit repetitions where a duplicated node has the same key (in maps) or
+     * value (in seqs). If one of the duplicated children has the same key
+     * (in maps) or value (in seqs) as one of the parent's children, the one
+     * that is placed closest to the end will prevail. */
+    size_t duplicate_children_no_rep(size_t node, size_t parent, size_t after);
+    size_t duplicate_children_no_rep(Tree const* src, size_t node, size_t parent, size_t after);
+
+public:
+
+    void merge_with(Tree const* src, size_t src_node=NONE, size_t dst_root=NONE);
+
+    /** @} */
+
+public:
+
+    /** @name internal string arena */
+    /** @{ */
+
+    /** get the current size of the tree's internal arena */
+    size_t arena_pos() const { return m_arena_pos; }
+
+    /** get the current arena */
+    substr arena() const { return m_arena.first(m_arena_pos); }
+
+    /** return true if the given substring is part of the tree's string arena */
+    bool in_arena(csubstr s) const
+    {
+        return m_arena.is_super(s);
+    }
+
+    /** serialize the given non-floating-point variable to the tree's arena, growing it as
+     * needed to accomodate the serialization.
+     * @note Growing the arena may cause relocation of the entire
+     * existing arena, and thus change the contents of individual nodes.
+     * @see alloc_arena() */
+    template<class T>
+    typename std::enable_if<!std::is_floating_point<T>::value, csubstr>::type
+    to_arena(T const& C4_RESTRICT a)
+    {
+        substr rem(m_arena.sub(m_arena_pos));
+        size_t num = to_chars(rem, a);
+        if(num > rem.len)
+        {
+            rem = _grow_arena(num);
+            num = to_chars(rem, a);
+            RYML_ASSERT(num <= rem.len);
+        }
+        rem = _request_span(num);
+        return rem;
+    }
+
+    /** serialize the given floating-point variable to the tree's arena, growing it as
+     * needed to accomodate the serialization.
+     * @note Growing the arena may cause relocation of the entire
+     * existing arena, and thus change the contents of individual nodes.
+     * @see alloc_arena() */
+    template<class T>
+    typename std::enable_if<std::is_floating_point<T>::value, csubstr>::type
+    to_arena(T const& C4_RESTRICT a)
+    {
+        substr rem(m_arena.sub(m_arena_pos));
+        size_t num = to_chars_float(rem, a);
+        if(num > rem.len)
+        {
+            rem = _grow_arena(num);
+            num = to_chars_float(rem, a);
+            RYML_ASSERT(num <= rem.len);
+        }
+        rem = _request_span(num);
+        return rem;
+    }
+
+    /** copy the given substr to the tree's arena, growing it by the required size
+     * @note Growing the arena may cause relocation of the entire
+     * existing arena, and thus change the contents of individual nodes.
+     * @see alloc_arena() */
+    substr copy_to_arena(csubstr s)
+    {
+        substr cp = alloc_arena(s.len);
+        RYML_ASSERT(cp.len == s.len);
+        RYML_ASSERT(!s.overlaps(cp));
+        #if (!defined(__clang__)) && (defined(__GNUC__) && __GNUC__ >= 10)
+        C4_SUPPRESS_WARNING_GCC_PUSH
+        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow=") // no need for terminating \0
+        C4_SUPPRESS_WARNING_GCC( "-Wrestrict") // there's an assert to ensure no violation of restrict behavior
+        #endif
+        memcpy(cp.str, s.str, s.len);
+        #if (!defined(__clang__)) && (defined(__GNUC__) && __GNUC__ >= 10)
+        C4_SUPPRESS_WARNING_GCC_POP
+        #endif
+        return cp;
+    }
+
+    /** grow the tree's string arena by the given size and return a substr
+     * of the added portion
+     * @note Growing the arena may cause relocation of the entire
+     * existing arena, and thus change the contents of individual nodes. */
+    substr alloc_arena(size_t sz)
+    {
+        if(sz > arena_slack())
+            _grow_arena(sz - arena_slack());
+        substr s = _request_span(sz);
+        return s;
+    }
+
+    /** ensure the tree's internal string arena is at least the given capacity
+     * @note Growing the arena may cause relocation of the entire
+     * existing arena, and thus change the contents of individual nodes. */
+    void reserve_arena(size_t arena_cap)
+    {
+        if(arena_cap > m_arena.len)
+        {
+            substr buf;
+            buf.str = (char*) m_callbacks.m_allocate(arena_cap, m_arena.str, m_callbacks.m_user_data);
+            buf.len = arena_cap;
+            if(m_arena.str)
+            {
+                RYML_ASSERT(m_arena.len >= 0);
+                _relocate(buf); // does a memcpy and changes nodes using the arena
+                m_callbacks.m_free(m_arena.str, m_arena.len, m_callbacks.m_user_data);
+            }
+            m_arena = buf;
+        }
+    }
+
+    /** @} */
+
+private:
+
+    substr _grow_arena(size_t more)
+    {
+        size_t cap = m_arena_pos + more;
+        cap = cap < 2 * m_arena.len ? 2 * m_arena.len : cap;
+        cap = cap < 64 ? 64 : cap;
+        reserve_arena(cap);
+        return m_arena.sub(m_arena_pos);
+    }
+
+    substr _request_span(size_t sz)
+    {
+        substr s;
+        s = m_arena.sub(m_arena_pos, sz);
+        m_arena_pos += sz;
+        return s;
+    }
+
+    substr _relocated(csubstr s, substr next_arena) const
+    {
+        RYML_ASSERT(m_arena.is_super(s));
+        RYML_ASSERT(m_arena.sub(0, m_arena_pos).is_super(s));
+        auto pos = (s.str - m_arena.str);
+        substr r(next_arena.str + pos, s.len);
+        RYML_ASSERT(r.str - next_arena.str == pos);
+        RYML_ASSERT(next_arena.sub(0, m_arena_pos).is_super(r));
+        return r;
+    }
+
+public:
+
+    /** @name lookup */
+    /** @{ */
+
+    struct lookup_result
+    {
+        size_t  target;
+        size_t  closest;
+        size_t  path_pos;
+        csubstr path;
+
+        inline operator bool() const { return target != NONE; }
+
+        lookup_result() : target(NONE), closest(NONE), path_pos(0), path() {}
+        lookup_result(csubstr path_, size_t start) : target(NONE), closest(start), path_pos(0), path(path_) {}
+
+        /** get the part ot the input path that was resolved */
+        csubstr resolved() const;
+        /** get the part ot the input path that was unresolved */
+        csubstr unresolved() const;
+    };
+
+    /** for example foo.bar[0].baz */
+    lookup_result lookup_path(csubstr path, size_t start=NONE) const;
+
+    /** defaulted lookup: lookup @p path; if the lookup fails, recursively modify
+     * the tree so that the corresponding lookup_path() would return the
+     * default value.
+     * @see lookup_path() */
+    size_t lookup_path_or_modify(csubstr default_value, csubstr path, size_t start=NONE);
+
+    /** defaulted lookup: lookup @p path; if the lookup fails, recursively modify
+     * the tree so that the corresponding lookup_path() would return the
+     * branch @p src_node (from the tree @p src).
+     * @see lookup_path() */
+    size_t lookup_path_or_modify(Tree const *src, size_t src_node, csubstr path, size_t start=NONE);
+
+    /** @} */
+
+private:
+
+    struct _lookup_path_token
+    {
+        csubstr value;
+        NodeType type;
+        _lookup_path_token() : value(), type() {}
+        _lookup_path_token(csubstr v, NodeType t) : value(v), type(t) {}
+        inline operator bool() const { return type != NOTYPE; }
+        bool is_index() const { return value.begins_with('[') && value.ends_with(']'); }
+    };
+
+    size_t _lookup_path_or_create(csubstr path, size_t start);
+
+    void   _lookup_path       (lookup_result *r) const;
+    void   _lookup_path_modify(lookup_result *r);
+
+    size_t _next_node       (lookup_result *r, _lookup_path_token *parent) const;
+    size_t _next_node_modify(lookup_result *r, _lookup_path_token *parent);
+
+    void   _advance(lookup_result *r, size_t more) const;
+
+    _lookup_path_token _next_token(lookup_result *r, _lookup_path_token const& parent) const;
+
+private:
+
+    void _clear();
+    void _free();
+    void _copy(Tree const& that);
+    void _move(Tree      & that);
+
+    void _relocate(substr next_arena);
+
+public:
+
+    #if ! RYML_USE_ASSERT
+    C4_ALWAYS_INLINE void _check_next_flags(size_t, type_bits) {}
+    #else
+    void _check_next_flags(size_t node, type_bits f)
+    {
+        auto n = _p(node);
+        type_bits o = n->m_type; // old
+        C4_UNUSED(o);
+        if(f & MAP)
+        {
+            RYML_ASSERT_MSG((f & SEQ) == 0, "cannot mark simultaneously as map and seq");
+            RYML_ASSERT_MSG((f & VAL) == 0, "cannot mark simultaneously as map and val");
+            RYML_ASSERT_MSG((o & SEQ) == 0, "cannot turn a seq into a map; clear first");
+            RYML_ASSERT_MSG((o & VAL) == 0, "cannot turn a val into a map; clear first");
+        }
+        else if(f & SEQ)
+        {
+            RYML_ASSERT_MSG((f & MAP) == 0, "cannot mark simultaneously as seq and map");
+            RYML_ASSERT_MSG((f & VAL) == 0, "cannot mark simultaneously as seq and val");
+            RYML_ASSERT_MSG((o & MAP) == 0, "cannot turn a map into a seq; clear first");
+            RYML_ASSERT_MSG((o & VAL) == 0, "cannot turn a val into a seq; clear first");
+        }
+        if(f & KEY)
+        {
+            RYML_ASSERT(!is_root(node));
+            auto pid = parent(node); C4_UNUSED(pid);
+            RYML_ASSERT(is_map(pid));
+        }
+        if((f & VAL) && !is_root(node))
+        {
+            auto pid = parent(node); C4_UNUSED(pid);
+            RYML_ASSERT(is_map(pid) || is_seq(pid));
+        }
+    }
+    #endif
+
+    inline void _set_flags(size_t node, NodeType_e f) { _check_next_flags(node, f); _p(node)->m_type = f; }
+    inline void _set_flags(size_t node, type_bits  f) { _check_next_flags(node, f); _p(node)->m_type = f; }
+
+    inline void _add_flags(size_t node, NodeType_e f) { NodeData *d = _p(node); type_bits fb = f |  d->m_type; _check_next_flags(node, fb); d->m_type = (NodeType_e) fb; }
+    inline void _add_flags(size_t node, type_bits  f) { NodeData *d = _p(node);                f |= d->m_type; _check_next_flags(node,  f); d->m_type = f; }
+
+    inline void _rem_flags(size_t node, NodeType_e f) { NodeData *d = _p(node); type_bits fb = d->m_type & ~f; _check_next_flags(node, fb); d->m_type = (NodeType_e) fb; }
+    inline void _rem_flags(size_t node, type_bits  f) { NodeData *d = _p(node);            f = d->m_type & ~f; _check_next_flags(node,  f); d->m_type = f; }
+
+    void _set_key(size_t node, csubstr key, type_bits more_flags=0)
+    {
+        _p(node)->m_key.scalar = key;
+        _add_flags(node, KEY|more_flags);
+    }
+    void _set_key(size_t node, NodeScalar const& key, type_bits more_flags=0)
+    {
+        _p(node)->m_key = key;
+        _add_flags(node, KEY|more_flags);
+    }
+
+    void _set_val(size_t node, csubstr val, type_bits more_flags=0)
+    {
+        RYML_ASSERT(num_children(node) == 0);
+        RYML_ASSERT(!is_seq(node) && !is_map(node));
+        _p(node)->m_val.scalar = val;
+        _add_flags(node, VAL|more_flags);
+    }
+    void _set_val(size_t node, NodeScalar const& val, type_bits more_flags=0)
+    {
+        RYML_ASSERT(num_children(node) == 0);
+        RYML_ASSERT( ! is_container(node));
+        _p(node)->m_val = val;
+        _add_flags(node, VAL|more_flags);
+    }
+
+    void _set(size_t node, NodeInit const& i)
+    {
+        RYML_ASSERT(i._check());
+        NodeData *n = _p(node);
+        RYML_ASSERT(n->m_key.scalar.empty() || i.key.scalar.empty() || i.key.scalar == n->m_key.scalar);
+        _add_flags(node, i.type);
+        if(n->m_key.scalar.empty())
+        {
+            if( ! i.key.scalar.empty())
+            {
+                _set_key(node, i.key.scalar);
+            }
+        }
+        n->m_key.tag = i.key.tag;
+        n->m_val = i.val;
+    }
+
+    void _set_parent_as_container_if_needed(size_t in)
+    {
+        NodeData const* n = _p(in);
+        size_t ip = parent(in);
+        if(ip != NONE)
+        {
+            if( ! (is_seq(ip) || is_map(ip)))
+            {
+                if((in == first_child(ip)) && (in == last_child(ip)))
+                {
+                    if( ! n->m_key.empty() || has_key(in))
+                    {
+                        _add_flags(ip, MAP);
+                    }
+                    else
+                    {
+                        _add_flags(ip, SEQ);
+                    }
+                }
+            }
+        }
+    }
+
+    void _seq2map(size_t node)
+    {
+        RYML_ASSERT(is_seq(node));
+        for(size_t i = first_child(node); i != NONE; i = next_sibling(i))
+        {
+            NodeData *C4_RESTRICT ch = _p(i);
+            if(ch->m_type.is_keyval())
+                continue;
+            ch->m_type.add(KEY);
+            ch->m_key = ch->m_val;
+        }
+        auto *C4_RESTRICT n = _p(node);
+        n->m_type.rem(SEQ);
+        n->m_type.add(MAP);
+    }
+
+    size_t _do_reorder(size_t *node, size_t count);
+
+    void _swap(size_t n_, size_t m_);
+    void _swap_props(size_t n_, size_t m_);
+    void _swap_hierarchy(size_t n_, size_t m_);
+    void _copy_hierarchy(size_t dst_, size_t src_);
+
+    void _copy_props(size_t dst_, size_t src_)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *_p(src_);
+        dst.m_type = src.m_type;
+        dst.m_key  = src.m_key;
+        dst.m_val  = src.m_val;
+    }
+
+    void _copy_props_wo_key(size_t dst_, size_t src_)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *_p(src_);
+        dst.m_type = src.m_type;
+        dst.m_val  = src.m_val;
+    }
+
+    void _copy_props(size_t dst_, Tree const* that_tree, size_t src_)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *that_tree->_p(src_);
+        dst.m_type = src.m_type;
+        dst.m_key  = src.m_key;
+        dst.m_val  = src.m_val;
+    }
+
+    void _copy_props_wo_key(size_t dst_, Tree const* that_tree, size_t src_)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *that_tree->_p(src_);
+        dst.m_type = src.m_type;
+        dst.m_val  = src.m_val;
+    }
+
+    inline void _clear_type(size_t node)
+    {
+        _p(node)->m_type = NOTYPE;
+    }
+
+    inline void _clear(size_t node)
+    {
+        auto *C4_RESTRICT n = _p(node);
+        n->m_type = NOTYPE;
+        n->m_key.clear();
+        n->m_val.clear();
+        n->m_parent = NONE;
+        n->m_first_child = NONE;
+        n->m_last_child = NONE;
+    }
+
+    inline void _clear_key(size_t node)
+    {
+        _p(node)->m_key.clear();
+        _rem_flags(node, KEY);
+    }
+
+    inline void _clear_val(size_t node)
+    {
+        _p(node)->m_key.clear();
+        _rem_flags(node, VAL);
+    }
+
+private:
+
+    void _clear_range(size_t first, size_t num);
+
+    size_t _claim();
+    void   _claim_root();
+    void   _release(size_t node);
+    void   _free_list_add(size_t node);
+    void   _free_list_rem(size_t node);
+
+    void _set_hierarchy(size_t node, size_t parent, size_t after_sibling);
+    void _rem_hierarchy(size_t node);
+
+public:
+
+    // members are exposed, but you should NOT access them directly
+
+    NodeData * m_buf;
+    size_t m_cap;
+
+    size_t m_size;
+
+    size_t m_free_head;
+    size_t m_free_tail;
+
+    substr m_arena;
+    size_t m_arena_pos;
+
+    Callbacks m_callbacks;
+
+    TagDirective m_tag_directives[RYML_MAX_TAG_DIRECTIVES];
+
+};
+
+} // namespace yml
+} // namespace c4
+
+
+C4_SUPPRESS_WARNING_MSVC_POP
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+
+#endif /* _C4_YML_TREE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/node.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_NODE_HPP_
+#define _C4_YML_NODE_HPP_
+
+/** @file node.hpp
+ * @see NodeRef */
+
+//included above:
+//#include <cstddef>
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/base64.hpp
+//#include "c4/base64.hpp"
+#if !defined(C4_BASE64_HPP_) && !defined(_C4_BASE64_HPP_)
+#error "amalgamate: file c4/base64.hpp must have been included at this point"
+#endif /* C4_BASE64_HPP_ */
+
+
+#ifdef __GNUC__
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4251/*needs to have dll-interface to be used by clients of struct*/)
+#   pragma warning(disable: 4296/*expression is always 'boolean_value'*/)
+#endif
+
+namespace c4 {
+namespace yml {
+
+template<class K> struct Key { K & k; };
+template<> struct Key<fmt::const_base64_wrapper> { fmt::const_base64_wrapper wrapper; };
+template<> struct Key<fmt::base64_wrapper> { fmt::base64_wrapper wrapper; };
+
+template<class K> C4_ALWAYS_INLINE Key<K> key(K & k) { return Key<K>{k}; }
+C4_ALWAYS_INLINE Key<fmt::const_base64_wrapper> key(fmt::const_base64_wrapper w) { return {w}; }
+C4_ALWAYS_INLINE Key<fmt::base64_wrapper> key(fmt::base64_wrapper w) { return {w}; }
+
+template<class T> void write(NodeRef *n, T const& v);
+
+template<class T>
+typename std::enable_if< ! std::is_floating_point<T>::value, bool>::type
+read(NodeRef const& n, T *v);
+
+template<class T>
+typename std::enable_if<   std::is_floating_point<T>::value, bool>::type
+read(NodeRef const& n, T *v);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** a reference to a node in an existing yaml tree, offering a more
+ * convenient API than the index-based API used in the tree. */
+class RYML_EXPORT NodeRef
+{
+private:
+
+    // require valid: a helper macro, undefined at the end
+    #define _C4RV() RYML_ASSERT(valid() && !is_seed())
+
+    Tree *C4_RESTRICT m_tree;
+    size_t m_id;
+
+    /** This member is used to enable lazy operator[] writing. When a child
+     * with a key or index is not found, m_id is set to the id of the parent
+     * and the asked-for key or index are stored in this member until a write
+     * does happen. Then it is given as key or index for creating the child.
+     * When a key is used, the csubstr stores it (so the csubstr's string is
+     * non-null and the csubstr's size is different from NONE). When an index is
+     * used instead, the csubstr's string is set to null, and only the csubstr's
+     * size is set to a value different from NONE. Otherwise, when operator[]
+     * does find the child then this member is empty: the string is null and
+     * the size is NONE. */
+    csubstr m_seed;
+
+public:
+
+    /** @name node construction */
+    /** @{ */
+
+    NodeRef() : m_tree(nullptr), m_id(NONE), m_seed() { _clear_seed(); }
+    NodeRef(Tree &t) : m_tree(&t), m_id(t .root_id()), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t) : m_tree(t ), m_id(t->root_id()), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t, size_t id) : m_tree(t), m_id(id), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t, size_t id, size_t seed_pos) : m_tree(t), m_id(id), m_seed() { m_seed.str = nullptr; m_seed.len = seed_pos; }
+    NodeRef(Tree *t, size_t id, csubstr  seed_key) : m_tree(t), m_id(id), m_seed(seed_key) {}
+    NodeRef(std::nullptr_t) : m_tree(nullptr), m_id(NONE), m_seed() {}
+
+    NodeRef(NodeRef const&) = default;
+    NodeRef(NodeRef     &&) = default;
+
+    NodeRef& operator= (NodeRef const&) = default;
+    NodeRef& operator= (NodeRef     &&) = default;
+
+    /** @} */
+
+public:
+
+    inline Tree      * tree()       { return m_tree; }
+    inline Tree const* tree() const { return m_tree; }
+
+    inline size_t id() const { return m_id; }
+
+    inline NodeData      * get()       { return m_tree->get(m_id); }
+    inline NodeData const* get() const { return m_tree->get(m_id); }
+
+    inline bool operator== (NodeRef const& that) const { _C4RV(); RYML_ASSERT(that.valid() && !that.is_seed()); RYML_ASSERT(that.m_tree == m_tree); return m_id == that.m_id; }
+    inline bool operator!= (NodeRef const& that) const { return ! this->operator==(that); }
+
+    inline bool operator== (std::nullptr_t) const { return m_tree == nullptr || m_id == NONE || is_seed(); }
+    inline bool operator!= (std::nullptr_t) const { return ! this->operator== (nullptr); }
+
+    inline bool operator== (csubstr val) const { _C4RV(); RYML_ASSERT(has_val()); return m_tree->val(m_id) == val; }
+    inline bool operator!= (csubstr val) const { _C4RV(); RYML_ASSERT(has_val()); return m_tree->val(m_id) != val; }
+
+    //inline operator bool () const { return m_tree == nullptr || m_id == NONE || is_seed(); }
+
+public:
+
+    inline bool valid() const { return m_tree != nullptr && m_id != NONE; }
+    inline bool is_seed() const { return m_seed.str != nullptr || m_seed.len != NONE; }
+
+    inline void _clear_seed() { /*do this manually or an assert is triggered*/ m_seed.str = nullptr; m_seed.len = NONE; }
+
+public:
+
+    /** @name node property getters */
+    /** @{ */
+
+    inline NodeType     type() const { _C4RV(); return m_tree->type(m_id); }
+    inline const char*  type_str() const { _C4RV(); RYML_ASSERT(valid() && ! is_seed()); return m_tree->type_str(m_id); }
+
+    inline csubstr    key()        const { _C4RV(); return m_tree->key(m_id); }
+    inline csubstr    key_tag()    const { _C4RV(); return m_tree->key_tag(m_id); }
+    inline csubstr    key_ref()    const { _C4RV(); return m_tree->key_ref(m_id); }
+    inline csubstr    key_anchor() const { _C4RV(); return m_tree->key_anchor(m_id); }
+    inline NodeScalar keysc()      const { _C4RV(); return m_tree->keysc(m_id); }
+
+    inline csubstr    val()        const { _C4RV(); return m_tree->val(m_id); }
+    inline csubstr    val_tag()    const { _C4RV(); return m_tree->val_tag(m_id); }
+    inline csubstr    val_ref()    const { _C4RV(); return m_tree->val_ref(m_id); }
+    inline csubstr    val_anchor() const { _C4RV(); return m_tree->val_anchor(m_id); }
+    inline NodeScalar valsc()      const { _C4RV(); return m_tree->valsc(m_id); }
+
+    inline bool key_is_null() const { _C4RV(); return m_tree->key_is_null(m_id); }
+    inline bool val_is_null() const { _C4RV(); return m_tree->val_is_null(m_id); }
+
+    /** decode the base64-encoded key deserialize and assign the
+     * decoded blob to the given buffer/
+     * @return the size of base64-decoded blob */
+    size_t deserialize_key(fmt::base64_wrapper v) const;
+    /** decode the base64-encoded key deserialize and assign the
+     * decoded blob to the given buffer/
+     * @return the size of base64-decoded blob */
+    size_t deserialize_val(fmt::base64_wrapper v) const;
+
+    /** @} */
+
+public:
+
+    /** @name node property predicates */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool is_stream()        const { _C4RV(); return m_tree->is_stream(m_id); }
+    C4_ALWAYS_INLINE bool is_doc()           const { _C4RV(); return m_tree->is_doc(m_id); }
+    C4_ALWAYS_INLINE bool is_container()     const { _C4RV(); return m_tree->is_container(m_id); }
+    C4_ALWAYS_INLINE bool is_map()           const { _C4RV(); return m_tree->is_map(m_id); }
+    C4_ALWAYS_INLINE bool is_seq()           const { _C4RV(); return m_tree->is_seq(m_id); }
+    C4_ALWAYS_INLINE bool has_val()          const { _C4RV(); return m_tree->has_val(m_id); }
+    C4_ALWAYS_INLINE bool has_key()          const { _C4RV(); return m_tree->has_key(m_id); }
+    C4_ALWAYS_INLINE bool is_val()           const { _C4RV(); return m_tree->is_val(m_id); }
+    C4_ALWAYS_INLINE bool is_keyval()        const { _C4RV(); return m_tree->is_keyval(m_id); }
+    C4_ALWAYS_INLINE bool has_key_tag()      const { _C4RV(); return m_tree->has_key_tag(m_id); }
+    C4_ALWAYS_INLINE bool has_val_tag()      const { _C4RV(); return m_tree->has_val_tag(m_id); }
+    C4_ALWAYS_INLINE bool has_key_anchor()   const { _C4RV(); return m_tree->has_key_anchor(m_id); }
+    C4_ALWAYS_INLINE bool is_key_anchor()    const { _C4RV(); return m_tree->is_key_anchor(m_id); }
+    C4_ALWAYS_INLINE bool has_val_anchor()   const { _C4RV(); return m_tree->has_val_anchor(m_id); }
+    C4_ALWAYS_INLINE bool is_val_anchor()    const { _C4RV(); return m_tree->is_val_anchor(m_id); }
+    C4_ALWAYS_INLINE bool has_anchor()       const { _C4RV(); return m_tree->has_anchor(m_id); }
+    C4_ALWAYS_INLINE bool is_anchor()        const { _C4RV(); return m_tree->is_anchor(m_id); }
+    C4_ALWAYS_INLINE bool is_key_ref()       const { _C4RV(); return m_tree->is_key_ref(m_id); }
+    C4_ALWAYS_INLINE bool is_val_ref()       const { _C4RV(); return m_tree->is_val_ref(m_id); }
+    C4_ALWAYS_INLINE bool is_ref()           const { _C4RV(); return m_tree->is_ref(m_id); }
+    C4_ALWAYS_INLINE bool is_anchor_or_ref() const { _C4RV(); return m_tree->is_anchor_or_ref(m_id); }
+    C4_ALWAYS_INLINE bool is_key_quoted()    const { _C4RV(); return m_tree->is_key_quoted(m_id); }
+    C4_ALWAYS_INLINE bool is_val_quoted()    const { _C4RV(); return m_tree->is_val_quoted(m_id); }
+    C4_ALWAYS_INLINE bool is_quoted()        const { _C4RV(); return m_tree->is_quoted(m_id); }
+
+    C4_ALWAYS_INLINE bool parent_is_seq()    const { _C4RV(); return m_tree->parent_is_seq(m_id); }
+    C4_ALWAYS_INLINE bool parent_is_map()    const { _C4RV(); return m_tree->parent_is_map(m_id); }
+
+    /** true when name and value are empty, and has no children */
+    C4_ALWAYS_INLINE bool empty() const { _C4RV(); return m_tree->empty(m_id); }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy predicates */
+    /** @{ */
+
+    inline bool is_root()    const { _C4RV(); return m_tree->is_root(m_id); }
+    inline bool has_parent() const { _C4RV(); return m_tree->has_parent(m_id); }
+
+    inline bool has_child(NodeRef const& ch) const { _C4RV(); return m_tree->has_child(m_id, ch.m_id); }
+    inline bool has_child(csubstr name) const { _C4RV();  return m_tree->has_child(m_id, name); }
+    inline bool has_children() const { _C4RV(); return m_tree->has_children(m_id); }
+
+    inline bool has_sibling(NodeRef const& n) const { _C4RV(); return m_tree->has_sibling(m_id, n.m_id); }
+    inline bool has_sibling(csubstr name) const { _C4RV();  return m_tree->has_sibling(m_id, name); }
+    /** counts with this */
+    inline bool has_siblings() const { _C4RV(); return m_tree->has_siblings(m_id); }
+    /** does not count with this */
+    inline bool has_other_siblings() const { _C4RV(); return m_tree->has_other_siblings(m_id); }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy getters */
+    /** @{ */
+
+    NodeRef       parent()       { _C4RV(); return {m_tree, m_tree->parent(m_id)}; }
+    NodeRef const parent() const { _C4RV(); return {m_tree, m_tree->parent(m_id)}; }
+
+    NodeRef       prev_sibling()       { _C4RV(); return {m_tree, m_tree->prev_sibling(m_id)}; }
+    NodeRef const prev_sibling() const { _C4RV(); return {m_tree, m_tree->prev_sibling(m_id)}; }
+
+    NodeRef       next_sibling()       { _C4RV(); return {m_tree, m_tree->next_sibling(m_id)}; }
+    NodeRef const next_sibling() const { _C4RV(); return {m_tree, m_tree->next_sibling(m_id)}; }
+
+    /** O(#num_children) */
+    size_t  num_children() const { _C4RV(); return m_tree->num_children(m_id); }
+    size_t  child_pos(NodeRef const& n) const { _C4RV(); return m_tree->child_pos(m_id, n.m_id); }
+    NodeRef       first_child()       { _C4RV(); return {m_tree, m_tree->first_child(m_id)}; }
+    NodeRef const first_child() const { _C4RV(); return {m_tree, m_tree->first_child(m_id)}; }
+    NodeRef       last_child ()       { _C4RV(); return {m_tree, m_tree->last_child (m_id)}; }
+    NodeRef const last_child () const { _C4RV(); return {m_tree, m_tree->last_child (m_id)}; }
+    NodeRef       child(size_t pos)       { _C4RV(); return {m_tree, m_tree->child(m_id, pos)}; }
+    NodeRef const child(size_t pos) const { _C4RV(); return {m_tree, m_tree->child(m_id, pos)}; }
+    NodeRef       find_child(csubstr name)       { _C4RV(); return {m_tree, m_tree->find_child(m_id, name)}; }
+    NodeRef const find_child(csubstr name) const { _C4RV(); return {m_tree, m_tree->find_child(m_id, name)}; }
+
+    /** O(#num_siblings) */
+    size_t  num_siblings() const { _C4RV(); return m_tree->num_siblings(m_id); }
+    size_t  num_other_siblings() const { _C4RV(); return m_tree->num_other_siblings(m_id); }
+    size_t  sibling_pos(NodeRef const& n) const { _C4RV(); return m_tree->child_pos(m_tree->parent(m_id), n.m_id); }
+    NodeRef       first_sibling()       { _C4RV(); return {m_tree, m_tree->first_sibling(m_id)}; }
+    NodeRef const first_sibling() const { _C4RV(); return {m_tree, m_tree->first_sibling(m_id)}; }
+    NodeRef       last_sibling ()       { _C4RV(); return {m_tree, m_tree->last_sibling(m_id)}; }
+    NodeRef const last_sibling () const { _C4RV(); return {m_tree, m_tree->last_sibling(m_id)}; }
+    NodeRef       sibling(size_t pos)       { _C4RV(); return {m_tree, m_tree->sibling(m_id, pos)}; }
+    NodeRef const sibling(size_t pos) const { _C4RV(); return {m_tree, m_tree->sibling(m_id, pos)}; }
+    NodeRef       find_sibling(csubstr name)       { _C4RV(); return {m_tree, m_tree->find_sibling(m_id, name)}; }
+    NodeRef const find_sibling(csubstr name) const { _C4RV(); return {m_tree, m_tree->find_sibling(m_id, name)}; }
+
+    NodeRef       doc(size_t num)       { _C4RV(); return {m_tree, m_tree->doc(num)}; }
+    NodeRef const doc(size_t num) const { _C4RV(); return {m_tree, m_tree->doc(num)}; }
+
+    /** @} */
+
+public:
+
+    /** @name node modifiers */
+    /** @{ */
+
+    void change_type(NodeType t) { _C4RV(); m_tree->change_type(m_id, t); }
+    void set_type(NodeType t) { _C4RV(); m_tree->_set_flags(m_id, t); }
+    void set_key(csubstr key) { _C4RV(); m_tree->_set_key(m_id, key); }
+    void set_val(csubstr val) { _C4RV(); m_tree->_set_val(m_id, val); }
+    void set_key_tag(csubstr key_tag) { _C4RV(); m_tree->set_key_tag(m_id, key_tag); }
+    void set_val_tag(csubstr val_tag) { _C4RV(); m_tree->set_val_tag(m_id, val_tag); }
+    void set_key_anchor(csubstr key_anchor) { _C4RV(); m_tree->set_key_anchor(m_id, key_anchor); }
+    void set_val_anchor(csubstr val_anchor) { _C4RV(); m_tree->set_val_anchor(m_id, val_anchor); }
+    void set_key_ref(csubstr key_ref) { _C4RV(); m_tree->set_key_ref(m_id, key_ref); }
+    void set_val_ref(csubstr val_ref) { _C4RV(); m_tree->set_val_ref(m_id, val_ref); }
+
+    template<class T>
+    size_t set_key_serialized(T const& C4_RESTRICT k)
+    {
+        _C4RV();
+        csubstr s = m_tree->to_arena(k);
+        m_tree->_set_key(m_id, s);
+        return s.len;
+    }
+    template<class T>
+    size_t set_val_serialized(T const& C4_RESTRICT v)
+    {
+        _C4RV();
+        csubstr s = m_tree->to_arena(v);
+        m_tree->_set_val(m_id, s);
+        return s.len;
+    }
+
+    /** encode a blob as base64, then assign the result to the node's key
+     * @return the size of base64-encoded blob */
+    size_t set_key_serialized(fmt::const_base64_wrapper w);
+    /** encode a blob as base64, then assign the result to the node's val
+     * @return the size of base64-encoded blob */
+    size_t set_val_serialized(fmt::const_base64_wrapper w);
+
+public:
+
+    inline void clear()
+    {
+        if(is_seed())
+            return;
+        m_tree->remove_children(m_id);
+        m_tree->_clear(m_id);
+    }
+
+    inline void clear_key()
+    {
+        if(is_seed())
+            return;
+        m_tree->_clear_key(m_id);
+    }
+
+    inline void clear_val()
+    {
+        if(is_seed())
+            return;
+        m_tree->_clear_val(m_id);
+    }
+
+    inline void clear_children()
+    {
+        if(is_seed())
+            return;
+        m_tree->remove_children(m_id);
+    }
+
+    /** @} */
+
+public:
+
+    /** hierarchy getters */
+    /** @{ */
+
+    /** O(num_children) */
+    NodeRef operator[] (csubstr k)
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        size_t ch = m_tree->find_child(m_id, k);
+        NodeRef r = ch != NONE ? NodeRef(m_tree, ch) : NodeRef(m_tree, m_id, k);
+        return r;
+    }
+
+    /** O(num_children) */
+    NodeRef const operator[] (csubstr k) const
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        size_t ch = m_tree->find_child(m_id, k);
+        RYML_ASSERT(ch != NONE);
+        NodeRef const r(m_tree, ch);
+        return r;
+    }
+
+    /** O(num_children) */
+    NodeRef operator[] (size_t pos)
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        size_t ch = m_tree->child(m_id, pos);
+        NodeRef r = ch != NONE ? NodeRef(m_tree, ch) : NodeRef(m_tree, m_id, pos);
+        return r;
+    }
+
+    /** O(num_children) */
+    NodeRef const operator[] (size_t pos) const
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        size_t ch = m_tree->child(m_id, pos);
+        RYML_ASSERT(ch != NONE);
+        NodeRef const r(m_tree, ch);
+        return r;
+    }
+
+    /** @} */
+
+public:
+
+    /** node modification */
+    /** @{ */
+
+    void create() { _apply_seed(); }
+
+    inline void operator= (NodeType_e t)
+    {
+        _apply_seed();
+        m_tree->_add_flags(m_id, t);
+    }
+
+    inline void operator|= (NodeType_e t)
+    {
+        _apply_seed();
+        m_tree->_add_flags(m_id, t);
+    }
+
+    inline void operator= (NodeInit const& v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    inline void operator= (NodeScalar const& v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    inline void operator= (csubstr v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    template<size_t N>
+    inline void operator= (const char (&v)[N])
+    {
+        _apply_seed();
+        csubstr sv;
+        sv.assign<N>(v);
+        _apply(sv);
+    }
+
+    /** @} */
+
+public:
+
+    /** serialize a variable to the arena */
+    template<class T>
+    inline csubstr to_arena(T const& C4_RESTRICT s) const
+    {
+        _C4RV();
+        return m_tree->to_arena(s);
+    }
+
+    /** serialize a variable, then assign the result to the node's val */
+    inline NodeRef& operator<< (csubstr s)
+    {
+        // this overload is needed to prevent ambiguity (there's also
+        // operator<< for writing a substr to a stream)
+        _apply_seed();
+        write(this, s);
+        RYML_ASSERT(val() == s);
+        return *this;
+    }
+
+    template<class T>
+    inline NodeRef& operator<< (T const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        write(this, v);
+        return *this;
+    }
+
+    template<class T>
+    inline NodeRef const& operator>> (T &v) const
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        RYML_ASSERT(get() != nullptr);
+        if( ! read(*this, &v))
+        {
+            c4::yml::error("could not deserialize value");
+        }
+        return *this;
+    }
+
+public:
+
+    /** serialize a variable, then assign the result to the node's key */
+    template<class T>
+    inline NodeRef& operator<< (Key<const T> const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        set_key_serialized(v.k);
+        return *this;
+    }
+
+    /** serialize a variable, then assign the result to the node's key */
+    template<class T>
+    inline NodeRef& operator<< (Key<T> const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        set_key_serialized(v.k);
+        return *this;
+    }
+
+    /** deserialize the node's key to the given variable */
+    template<class T>
+    inline NodeRef const& operator>> (Key<T> v) const
+    {
+        RYML_ASSERT( ! is_seed());
+        RYML_ASSERT(valid());
+        RYML_ASSERT(get() != nullptr);
+        from_chars(key(), &v.k);
+        return *this;
+    }
+
+public:
+
+    NodeRef& operator<< (Key<fmt::const_base64_wrapper> w)
+    {
+        set_key_serialized(w.wrapper);
+        return *this;
+    }
+
+    NodeRef& operator<< (fmt::const_base64_wrapper w)
+    {
+        set_val_serialized(w);
+        return *this;
+    }
+
+    NodeRef const& operator>> (Key<fmt::base64_wrapper> w) const
+    {
+        deserialize_key(w.wrapper);
+        return *this;
+    }
+
+    NodeRef const& operator>> (fmt::base64_wrapper w) const
+    {
+        deserialize_val(w);
+        return *this;
+    }
+
+public:
+
+    template<class T>
+    void get_if(csubstr name, T *var) const
+    {
+        auto ch = find_child(name);
+        if(ch.valid())
+        {
+            ch >> *var;
+        }
+    }
+
+    template<class T>
+    void get_if(csubstr name, T *var, T fallback) const
+    {
+        auto ch = find_child(name);
+        if(ch.valid())
+        {
+            ch >> *var;
+        }
+        else
+        {
+            *var = fallback;
+        }
+    }
+
+private:
+
+    void _apply_seed()
+    {
+        if(m_seed.str) // we have a seed key: use it to create the new child
+        {
+            //RYML_ASSERT(i.key.scalar.empty() || m_key == i.key.scalar || m_key.empty());
+            m_id = m_tree->append_child(m_id);
+            m_tree->_set_key(m_id, m_seed);
+            m_seed.str = nullptr;
+            m_seed.len = NONE;
+        }
+        else if(m_seed.len != NONE) // we have a seed index: create a child at that position
+        {
+            RYML_ASSERT(m_tree->num_children(m_id) == m_seed.len);
+            m_id = m_tree->append_child(m_id);
+            m_seed.str = nullptr;
+            m_seed.len = NONE;
+        }
+        else
+        {
+            RYML_ASSERT(valid());
+        }
+    }
+
+    inline void _apply(csubstr v)
+    {
+        m_tree->_set_val(m_id, v);
+    }
+
+    inline void _apply(NodeScalar const& v)
+    {
+        m_tree->_set_val(m_id, v);
+    }
+
+    inline void _apply(NodeInit const& i)
+    {
+        m_tree->_set(m_id, i);
+    }
+
+public:
+
+    inline NodeRef insert_child(NodeRef after)
+    {
+        _C4RV();
+        RYML_ASSERT(after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id));
+        return r;
+    }
+
+    inline NodeRef insert_child(NodeInit const& i, NodeRef after)
+    {
+        _C4RV();
+        RYML_ASSERT(after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id));
+        r._apply(i);
+        return r;
+    }
+
+    inline NodeRef prepend_child()
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->insert_child(m_id, NONE));
+        return r;
+    }
+
+    inline NodeRef prepend_child(NodeInit const& i)
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->insert_child(m_id, NONE));
+        r._apply(i);
+        return r;
+    }
+
+    inline NodeRef append_child()
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->append_child(m_id));
+        return r;
+    }
+
+    inline NodeRef append_child(NodeInit const& i)
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->append_child(m_id));
+        r._apply(i);
+        return r;
+    }
+
+public:
+
+    inline NodeRef insert_sibling(NodeRef const after)
+    {
+        _C4RV();
+        RYML_ASSERT(after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id));
+        return r;
+    }
+
+    inline NodeRef insert_sibling(NodeInit const& i, NodeRef const after)
+    {
+        _C4RV();
+        RYML_ASSERT(after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id));
+        r._apply(i);
+        return r;
+    }
+
+    inline NodeRef prepend_sibling()
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->prepend_sibling(m_id));
+        return r;
+    }
+
+    inline NodeRef prepend_sibling(NodeInit const& i)
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->prepend_sibling(m_id));
+        r._apply(i);
+        return r;
+    }
+
+    inline NodeRef append_sibling()
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->append_sibling(m_id));
+        return r;
+    }
+
+    inline NodeRef append_sibling(NodeInit const& i)
+    {
+        _C4RV();
+        NodeRef r(m_tree, m_tree->append_sibling(m_id));
+        r._apply(i);
+        return r;
+    }
+
+public:
+
+    inline void remove_child(NodeRef & child)
+    {
+        _C4RV();
+        RYML_ASSERT(has_child(child));
+        RYML_ASSERT(child.parent().id() == id());
+        m_tree->remove(child.id());
+        child.clear();
+    }
+
+    //! remove the nth child of this node
+    inline void remove_child(size_t pos)
+    {
+        _C4RV();
+        RYML_ASSERT(pos >= 0 && pos < num_children());
+        size_t child = m_tree->child(m_id, pos);
+        RYML_ASSERT(child != NONE);
+        m_tree->remove(child);
+    }
+
+    //! remove a child by name
+    inline void remove_child(csubstr key)
+    {
+        _C4RV();
+        size_t child = m_tree->find_child(m_id, key);
+        RYML_ASSERT(child != NONE);
+        m_tree->remove(child);
+    }
+
+public:
+
+    /** change the node's position within its parent */
+    inline void move(NodeRef const after)
+    {
+        _C4RV();
+        m_tree->move(m_id, after.m_id);
+    }
+
+    /** move the node to a different parent, which may belong to a different
+     * tree. When this is the case, then this node's tree pointer is reset to
+     * the tree of the parent node. */
+    inline void move(NodeRef const parent, NodeRef const after)
+    {
+        _C4RV();
+        RYML_ASSERT(parent.m_tree == after.m_tree);
+        if(parent.m_tree == m_tree)
+        {
+            m_tree->move(m_id, parent.m_id, after.m_id);
+        }
+        else
+        {
+            parent.m_tree->move(m_tree, m_id, parent.m_id, after.m_id);
+            m_tree = parent.m_tree;
+        }
+    }
+
+    inline NodeRef duplicate(NodeRef const parent, NodeRef const after) const
+    {
+        _C4RV();
+        RYML_ASSERT(parent.m_tree == after.m_tree);
+        if(parent.m_tree == m_tree)
+        {
+            size_t dup = m_tree->duplicate(m_id, parent.m_id, after.m_id);
+            NodeRef r(m_tree, dup);
+            return r;
+        }
+        else
+        {
+            size_t dup = parent.m_tree->duplicate(m_tree, m_id, parent.m_id, after.m_id);
+            NodeRef r(parent.m_tree, dup);
+            return r;
+        }
+    }
+
+    inline void duplicate_children(NodeRef const parent, NodeRef const after) const
+    {
+        _C4RV();
+        RYML_ASSERT(parent.m_tree == after.m_tree);
+        if(parent.m_tree == m_tree)
+        {
+            m_tree->duplicate_children(m_id, parent.m_id, after.m_id);
+        }
+        else
+        {
+            parent.m_tree->duplicate_children(m_tree, m_id, parent.m_id, after.m_id);
+        }
+    }
+
+private:
+
+    template<class Nd>
+    struct child_iterator
+    {
+        Tree * m_tree;
+        size_t m_child_id;
+
+        using value_type = NodeRef;
+
+        child_iterator(Tree * t, size_t id) : m_tree(t), m_child_id(id) {}
+
+        child_iterator& operator++ () { RYML_ASSERT(m_child_id != NONE); m_child_id = m_tree->next_sibling(m_child_id); return *this; }
+        child_iterator& operator-- () { RYML_ASSERT(m_child_id != NONE); m_child_id = m_tree->prev_sibling(m_child_id); return *this; }
+
+        Nd operator*  () const { return Nd(m_tree, m_child_id); }
+        Nd operator-> () const { return Nd(m_tree, m_child_id); }
+
+        bool operator!= (child_iterator that) const { RYML_ASSERT(m_tree == that.m_tree); return m_child_id != that.m_child_id; }
+        bool operator== (child_iterator that) const { RYML_ASSERT(m_tree == that.m_tree); return m_child_id == that.m_child_id; }
+    };
+
+public:
+
+    using       iterator = child_iterator<      NodeRef>;
+    using const_iterator = child_iterator<const NodeRef>;
+
+    inline iterator begin() { return iterator(m_tree, m_tree->first_child(m_id)); }
+    inline iterator end  () { return iterator(m_tree, NONE); }
+
+    inline const_iterator begin() const { return const_iterator(m_tree, m_tree->first_child(m_id)); }
+    inline const_iterator end  () const { return const_iterator(m_tree, NONE); }
+
+private:
+
+    template<class Nd>
+    struct children_view_
+    {
+        using n_iterator = child_iterator<Nd>;
+
+        n_iterator b, e;
+
+        inline children_view_(n_iterator const& b_, n_iterator const& e_) : b(b_), e(e_) {}
+
+        inline n_iterator begin() const { return b; }
+        inline n_iterator end  () const { return e; }
+    };
+
+public:
+
+    using       children_view = children_view_<      NodeRef>;
+    using const_children_view = children_view_<const NodeRef>;
+
+          children_view children()       { return       children_view(begin(), end()); }
+    const_children_view children() const { return const_children_view(begin(), end()); }
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic push
+    #   pragma clang diagnostic ignored "-Wnull-dereference"
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic push
+    #   if __GNUC__ >= 6
+    #       pragma GCC diagnostic ignored "-Wnull-dereference"
+    #   endif
+    #endif
+
+          children_view siblings()       { if(is_root()) { return       children_view(end(), end()); } else { size_t p = get()->m_parent; return       children_view(iterator(m_tree, m_tree->get(p)->m_first_child), iterator(m_tree, NONE)); } }
+    const_children_view siblings() const { if(is_root()) { return const_children_view(end(), end()); } else { size_t p = get()->m_parent; return const_children_view(const_iterator(m_tree, m_tree->get(p)->m_first_child), const_iterator(m_tree, NONE)); } }
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic pop
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic pop
+    #endif
+
+public:
+
+    /** visit every child node calling fn(node) */
+    template<class Visitor> bool visit(Visitor fn, size_t indentation_level=0, bool skip_root=true);
+    /** visit every child node calling fn(node) */
+    template<class Visitor> bool visit(Visitor fn, size_t indentation_level=0, bool skip_root=true) const;
+
+    /** visit every child node calling fn(node, level) */
+    template<class Visitor> bool visit_stacked(Visitor fn, size_t indentation_level=0, bool skip_root=true);
+    /** visit every child node calling fn(node, level) */
+    template<class Visitor> bool visit_stacked(Visitor fn, size_t indentation_level=0, bool skip_root=true) const;
+
+#undef _C4RV
+};
+
+//-----------------------------------------------------------------------------
+template<class T>
+inline void write(NodeRef *n, T const& v)
+{
+    n->set_val_serialized(v);
+}
+
+template<class T>
+typename std::enable_if< ! std::is_floating_point<T>::value, bool>::type
+inline read(NodeRef const& n, T *v)
+{
+    return from_chars(n.val(), v);
+}
+
+template<class T>
+typename std::enable_if< std::is_floating_point<T>::value, bool>::type
+inline read(NodeRef const& n, T *v)
+{
+    return from_chars_float(n.val(), v);
+}
+
+
+//-----------------------------------------------------------------------------
+template<class Visitor>
+bool NodeRef::visit(Visitor fn, size_t indentation_level, bool skip_root)
+{
+    return const_cast<NodeRef const*>(this)->visit(fn, indentation_level, skip_root);
+}
+
+template<class Visitor>
+bool NodeRef::visit(Visitor fn, size_t indentation_level, bool skip_root) const
+{
+    size_t increment = 0;
+    if( ! (is_root() && skip_root))
+    {
+        if(fn(this, indentation_level))
+        {
+            return true;
+        }
+        ++increment;
+    }
+    if(has_children())
+    {
+        for(auto ch : children())
+        {
+            if(ch.visit(fn, indentation_level + increment)) // no need to forward skip_root as it won't be root
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+
+template<class Visitor>
+bool NodeRef::visit_stacked(Visitor fn, size_t indentation_level, bool skip_root)
+{
+    return const_cast< NodeRef const* >(this)->visit_stacked(fn, indentation_level, skip_root);
+}
+
+template<class Visitor>
+bool NodeRef::visit_stacked(Visitor fn, size_t indentation_level, bool skip_root) const
+{
+    size_t increment = 0;
+    if( ! (is_root() && skip_root))
+    {
+        if(fn(this, indentation_level))
+        {
+            return true;
+        }
+        ++increment;
+    }
+    if(has_children())
+    {
+        fn.push(this, indentation_level);
+        for(auto ch : children())
+        {
+            if(ch.visit(fn, indentation_level + increment)) // no need to forward skip_root as it won't be root
+            {
+                fn.pop(this, indentation_level);
+                return true;
+            }
+        }
+        fn.pop(this, indentation_level);
+    }
+    return false;
+}
+
+} // namespace yml
+} // namespace c4
+
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+#ifdef __GNUC__
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* _C4_YML_NODE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/writer.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/writer.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_WRITER_HPP_
+#define _C4_YML_WRITER_HPP_
+
+#ifndef _C4_YML_COMMON_HPP_
+#include "./common.hpp"
+#endif
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/substr.hpp
+//#include <c4/substr.hpp>
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+//included above:
+//#include <stdio.h>  // fwrite(), fputc()
+//included above:
+//#include <string.h> // memcpy()
+
+
+namespace c4 {
+namespace yml {
+
+
+/** Repeat-Character: a character to be written a number of times. */
+struct RepC
+{
+    char c;
+    size_t num_times;
+};
+inline RepC indent_to(size_t num_levels)
+{
+    return {' ', size_t(2) * num_levels};
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A writer that outputs to a file. Defaults to stdout. */
+struct WriterFile
+{
+    FILE * m_file;
+    size_t m_pos;
+
+    WriterFile(FILE *f = nullptr) : m_file(f ? f : stdout), m_pos(0) {}
+
+    inline substr _get(bool /*error_on_excess*/)
+    {
+        substr sp;
+        sp.str = nullptr;
+        sp.len = m_pos;
+        return sp;
+    }
+
+    template<size_t N>
+    inline void _do_write(const char (&a)[N])
+    {
+        fwrite(a, sizeof(char), N - 1, m_file);
+        m_pos += N - 1;
+    }
+
+    inline void _do_write(csubstr sp)
+    {
+        #if defined(__clang__)
+        #   pragma clang diagnostic push
+        #   pragma GCC diagnostic ignored "-Wsign-conversion"
+        #elif defined(__GNUC__)
+        #   pragma GCC diagnostic push
+        #   pragma GCC diagnostic ignored "-Wsign-conversion"
+        #endif
+        if(sp.empty()) return;
+        fwrite(sp.str, sizeof(csubstr::char_type), sp.len, m_file);
+        m_pos += sp.len;
+        #if defined(__clang__)
+        #   pragma clang diagnostic pop
+        #elif defined(__GNUC__)
+        #   pragma GCC diagnostic pop
+        #endif
+    }
+
+    inline void _do_write(const char c)
+    {
+        fputc(c, m_file);
+        ++m_pos;
+    }
+
+    inline void _do_write(RepC const rc)
+    {
+        for(size_t i = 0; i < rc.num_times; ++i)
+        {
+            fputc(rc.c, m_file);
+        }
+        m_pos += rc.num_times;
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** A writer that outputs to an STL-like ostream. */
+template<class OStream>
+struct WriterOStream
+{
+    OStream& m_stream;
+    size_t   m_pos;
+
+    WriterOStream(OStream &s) : m_stream(s), m_pos(0) {}
+
+    inline substr _get(bool /*error_on_excess*/)
+    {
+        substr sp;
+        sp.str = nullptr;
+        sp.len = m_pos;
+        return sp;
+    }
+
+    template<size_t N>
+    inline void _do_write(const char (&a)[N])
+    {
+        m_stream.write(a, N - 1);
+        m_pos += N - 1;
+    }
+
+    inline void _do_write(csubstr sp)
+    {
+        #if defined(__clang__)
+        #   pragma clang diagnostic push
+        #   pragma GCC diagnostic ignored "-Wsign-conversion"
+        #elif defined(__GNUC__)
+        #   pragma GCC diagnostic push
+        #   pragma GCC diagnostic ignored "-Wsign-conversion"
+        #endif
+        if(sp.empty()) return;
+        m_stream.write(sp.str, sp.len);
+        m_pos += sp.len;
+        #if defined(__clang__)
+        #   pragma clang diagnostic pop
+        #elif defined(__GNUC__)
+        #   pragma GCC diagnostic pop
+        #endif
+    }
+
+    inline void _do_write(const char c)
+    {
+        m_stream.put(c);
+        ++m_pos;
+    }
+
+    inline void _do_write(RepC const rc)
+    {
+        for(size_t i = 0; i < rc.num_times; ++i)
+        {
+            m_stream.put(rc.c);
+        }
+        m_pos += rc.num_times;
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** a writer to a substr */
+struct WriterBuf
+{
+    substr m_buf;
+    size_t m_pos;
+
+    WriterBuf(substr sp) : m_buf(sp), m_pos(0) {}
+
+    inline substr _get(bool error_on_excess)
+    {
+        if(m_pos <= m_buf.len)
+        {
+            return m_buf.first(m_pos);
+        }
+        if(error_on_excess)
+        {
+            c4::yml::error("not enough space in the given buffer");
+        }
+        substr sp;
+        sp.str = nullptr;
+        sp.len = m_pos;
+        return sp;
+    }
+
+    template<size_t N>
+    inline void _do_write(const char (&a)[N])
+    {
+        RYML_ASSERT( ! m_buf.overlaps(a));
+        if(m_pos + N-1 <= m_buf.len)
+        {
+            memcpy(&(m_buf[m_pos]), a, N-1);
+        }
+        m_pos += N-1;
+    }
+
+    inline void _do_write(csubstr sp)
+    {
+        if(sp.empty()) return;
+        RYML_ASSERT( ! sp.overlaps(m_buf));
+        if(m_pos + sp.len <= m_buf.len)
+        {
+            memcpy(&(m_buf[m_pos]), sp.str, sp.len);
+        }
+        m_pos += sp.len;
+    }
+
+    inline void _do_write(const char c)
+    {
+        if(m_pos + 1 <= m_buf.len)
+        {
+            m_buf[m_pos] = c;
+        }
+        ++m_pos;
+    }
+
+    inline void _do_write(RepC const rc)
+    {
+        if(m_pos + rc.num_times <= m_buf.len)
+        {
+            for(size_t i = 0; i < rc.num_times; ++i)
+            {
+                m_buf[m_pos + i] = rc.c;
+            }
+        }
+        m_pos += rc.num_times;
+    }
+};
+
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_WRITER_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/writer.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/detail/parser_dbg.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/parser_dbg.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_DETAIL_PARSER_DBG_HPP_
+#define _C4_YML_DETAIL_PARSER_DBG_HPP_
+
+#ifndef _C4_YML_COMMON_HPP_
+#include "../common.hpp"
+#endif
+//included above:
+//#include <cstdio>
+
+//-----------------------------------------------------------------------------
+// some debugging scaffolds
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4068/*unknown pragma*/)
+#endif
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+//#pragma GCC diagnostic ignored "-Wpragma-system-header-outside-header"
+#pragma GCC system_header
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Werror"
+#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+
+// some debugging scaffolds
+#ifdef RYML_DBG
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/dump.hpp
+//#include <c4/dump.hpp>
+#if !defined(C4_DUMP_HPP_) && !defined(_C4_DUMP_HPP_)
+#error "amalgamate: file c4/dump.hpp must have been included at this point"
+#endif /* C4_DUMP_HPP_ */
+
+namespace c4 {
+inline void _dbg_dumper(csubstr s) { fwrite(s.str, 1, s.len, stdout); };
+template<class ...Args>
+void _dbg_printf(c4::csubstr fmt, Args&& ...args)
+{
+    static char writebuf[256];
+    auto results = c4::format_dump_resume<&_dbg_dumper>(writebuf, fmt, std::forward<Args>(args)...);
+    // resume writing if the results failed to fit the buffer
+    if(C4_UNLIKELY(results.bufsize > sizeof(writebuf))) // bufsize will be that of the largest element serialized. Eg int(1), will require 1 byte.
+    {
+        results = format_dump_resume<&_dbg_dumper>(results, writebuf, fmt, std::forward<Args>(args)...);
+        if(C4_UNLIKELY(results.bufsize > sizeof(writebuf)))
+        {
+            results = format_dump_resume<&_dbg_dumper>(results, writebuf, fmt, std::forward<Args>(args)...);
+        }
+    }
+}
+} // namespace c4
+
+#   define _c4dbgt(fmt, ...)   this->_dbg ("{}:{}: "   fmt     , __FILE__, __LINE__, ## __VA_ARGS__)
+#   define _c4dbgpf(fmt, ...)  _dbg_printf("{}:{}: "   fmt "\n", __FILE__, __LINE__, ## __VA_ARGS__)
+#   define _c4dbgp(msg)        _dbg_printf("{}:{}: "   msg "\n", __FILE__, __LINE__                )
+#   define _c4dbgq(msg)        _dbg_printf(msg "\n")
+#   define _c4err(fmt, ...)   \
+    do { if(c4::is_debugger_attached()) { C4_DEBUG_BREAK(); } \
+         this->_err("ERROR:\n" "{}:{}: " fmt, __FILE__, __LINE__, ## __VA_ARGS__); } while(0)
+#else
+#   define _c4dbgt(fmt, ...)
+#   define _c4dbgpf(fmt, ...)
+#   define _c4dbgp(msg)
+#   define _c4dbgq(msg)
+#   define _c4err(fmt, ...)   \
+    do { if(c4::is_debugger_attached()) { C4_DEBUG_BREAK(); } \
+         this->_err("ERROR: " fmt, ## __VA_ARGS__); } while(0)
+#endif
+
+#define _c4prsp(sp) sp
+#define _c4presc(s) __c4presc(s.str, s.len)
+inline c4::csubstr _c4prc(const char &C4_RESTRICT c)
+{
+    switch(c)
+    {
+    case '\n': return c4::csubstr("\\n");
+    case '\t': return c4::csubstr("\\t");
+    case '\0': return c4::csubstr("\\0");
+    case '\r': return c4::csubstr("\\r");
+    case '\f': return c4::csubstr("\\f");
+    case '\b': return c4::csubstr("\\b");
+    case '\v': return c4::csubstr("\\v");
+    case '\a': return c4::csubstr("\\a");
+    default: return c4::csubstr(&c, 1);
+    }
+}
+inline void __c4presc(const char *s, size_t len)
+{
+    size_t prev = 0;
+    for(size_t i = 0; i < len; ++i)
+    {
+        switch(s[i])
+        {
+        case '\n'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('n'); putchar('\n'); prev = i+1; break;
+        case '\t'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('t'); prev = i+1; break;
+        case '\0'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('0'); prev = i+1; break;
+        case '\r'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('r'); prev = i+1; break;
+        case '\f'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('f'); prev = i+1; break;
+        case '\b'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('b'); prev = i+1; break;
+        case '\v'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('v'); prev = i+1; break;
+        case '\a'  : fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('a'); prev = i+1; break;
+        case '\x1b': fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('e'); prev = i+1; break;
+        case -0x3e/*0xc2u*/:
+            if(i+1 < len)
+            {
+                if(s[i+1] == -0x60/*0xa0u*/)
+                {
+                    fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('_'); prev = i+2; ++i;
+                }
+                else if(s[i+1] == -0x7b/*0x85u*/)
+                {
+                    fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('N'); prev = i+2; ++i;
+                }
+                break;
+            }
+        case -0x1e/*0xe2u*/:
+            if(i+2 < len && s[i+1] == -0x80/*0x80u*/)
+            {
+                if(s[i+2] == -0x58/*0xa8u*/)
+                {
+                    fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('L'); prev = i+3; i += 2;
+                }
+                else if(s[i+2] == -0x57/*0xa9u*/)
+                {
+                    fwrite(s+prev, 1, i-prev, stdout); putchar('\\'); putchar('P'); prev = i+3; i += 2;
+                }
+                break;
+            }
+        }
+    }
+    fwrite(s + prev, 1, len - prev, stdout);
+}
+
+#pragma clang diagnostic pop
+#pragma GCC diagnostic pop
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+
+#endif /* _C4_YML_DETAIL_PARSER_DBG_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/detail/parser_dbg.hpp)
+
+#define C4_YML_EMIT_DEF_HPP_
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/emit.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_EMIT_HPP_
+#define _C4_YML_EMIT_HPP_
+
+#ifndef _C4_YML_WRITER_HPP_
+#include "./writer.hpp"
+#endif
+
+#ifndef _C4_YML_TREE_HPP_
+#include "./tree.hpp"
+#endif
+
+#ifndef _C4_YML_NODE_HPP_
+#include "./node.hpp"
+#endif
+
+namespace c4 {
+namespace yml {
+
+template<class Writer> class Emitter;
+
+template<class OStream>
+using EmitterOStream = Emitter<WriterOStream<OStream>>;
+using EmitterFile = Emitter<WriterFile>;
+using EmitterBuf  = Emitter<WriterBuf>;
+
+typedef enum {
+    EMIT_YAML = 0,
+    EMIT_JSON = 1
+} EmitType_e;
+
+
+/** mark a tree or node to be emitted as json */
+struct as_json
+{
+    Tree const* tree;
+    size_t node;
+    as_json(Tree const& t) : tree(&t), node(t.empty() ? NONE : t.root_id()) {}
+    as_json(Tree const& t, size_t id) : tree(&t), node(id) {}
+    as_json(NodeRef const& n) : tree(n.tree()), node(n.id()) {}
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class Writer>
+class Emitter : public Writer
+{
+public:
+
+    using Writer::Writer;
+
+    /** emit!
+     *
+     * When writing to a buffer, returns a substr of the emitted YAML.
+     * If the given buffer has insufficient space, the returned span will
+     * be null and its size will be the needed space. No writes are done
+     * after the end of the buffer.
+     *
+     * When writing to a file, the returned substr will be null, but its
+     * length will be set to the number of bytes written. */
+    substr emit(EmitType_e type, Tree const& t, size_t id, bool error_on_excess);
+    /** emit starting at the root node */
+    substr emit(EmitType_e type, Tree const& t, bool error_on_excess=true);
+    /** emit the given node */
+    substr emit(EmitType_e type, NodeRef const& n, bool error_on_excess=true);
+
+private:
+
+    Tree const* C4_RESTRICT m_tree;
+
+    void _emit_yaml(size_t id);
+    void _do_visit_flow_sl(size_t id, size_t ilevel=0);
+    void _do_visit_flow_ml(size_t id, size_t ilevel=0, size_t do_indent=1);
+    void _do_visit_block(size_t id, size_t ilevel=0, size_t do_indent=1);
+    void _do_visit_block_container(size_t id, size_t next_level, size_t do_indent);
+    void _do_visit_json(size_t id);
+
+private:
+
+    void _write(NodeScalar const& C4_RESTRICT sc, NodeType flags, size_t level);
+    void _write_json(NodeScalar const& C4_RESTRICT sc, NodeType flags);
+
+    void _write_doc(size_t id);
+    void _write_scalar(csubstr s, bool was_quoted);
+    void _write_scalar_json(csubstr s, bool as_key, bool was_quoted);
+    void _write_scalar_literal(csubstr s, size_t level, bool as_key, bool explicit_indentation=false);
+    void _write_scalar_folded(csubstr s, size_t level, bool as_key);
+    void _write_scalar_squo(csubstr s, size_t level);
+    void _write_scalar_dquo(csubstr s, size_t level);
+    void _write_scalar_plain(csubstr s, size_t level);
+
+    void _write_tag(csubstr tag)
+    {
+        if(!tag.begins_with('!'))
+            this->Writer::_do_write('!');
+        this->Writer::_do_write(tag);
+    }
+
+    enum : type_bits {
+        _keysc =  (KEY|KEYREF|KEYANCH|KEYQUO|_WIP_KEY_STYLE) | ~(VAL|VALREF|VALANCH|VALQUO|_WIP_VAL_STYLE),
+        _valsc = ~(KEY|KEYREF|KEYANCH|KEYQUO|_WIP_KEY_STYLE) |  (VAL|VALREF|VALANCH|VALQUO|_WIP_VAL_STYLE),
+        _keysc_json =  (KEY)  | ~(VAL),
+        _valsc_json = ~(KEY)  |  (VAL),
+    };
+
+    C4_ALWAYS_INLINE void _writek(size_t id, size_t level) { _write(m_tree->keysc(id), m_tree->_p(id)->m_type.type & ~_valsc, level); }
+    C4_ALWAYS_INLINE void _writev(size_t id, size_t level) { _write(m_tree->valsc(id), m_tree->_p(id)->m_type.type & ~_keysc, level); }
+
+    C4_ALWAYS_INLINE void _writek_json(size_t id) { _write_json(m_tree->keysc(id), m_tree->_p(id)->m_type.type & ~(VAL)); }
+    C4_ALWAYS_INLINE void _writev_json(size_t id) { _write_json(m_tree->valsc(id), m_tree->_p(id)->m_type.type & ~(KEY)); }
+
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** emit YAML to the given file. A null file defaults to stdout.
+ * Return the number of bytes written. */
+inline size_t emit(Tree const& t, size_t id, FILE *f)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_YAML, t, id, /*error_on_excess*/true).len;
+}
+/** emit JSON to the given file. A null file defaults to stdout.
+ * Return the number of bytes written. */
+inline size_t emit_json(Tree const& t, size_t id, FILE *f)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_JSON, t, id, /*error_on_excess*/true).len;
+}
+
+
+/** emit YAML to the given file. A null file defaults to stdout.
+ * Return the number of bytes written.
+ * @overload */
+inline size_t emit(Tree const& t, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_YAML, t, /*error_on_excess*/true).len;
+}
+
+/** emit JSON to the given file. A null file defaults to stdout.
+ * Return the number of bytes written.
+ * @overload */
+inline size_t emit_json(Tree const& t, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_JSON, t, /*error_on_excess*/true).len;
+}
+
+
+/** emit YAML to the given file. A null file defaults to stdout.
+ * Return the number of bytes written.
+ * @overload */
+inline size_t emit(NodeRef const& r, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_YAML, r, /*error_on_excess*/true).len;
+}
+
+/** emit JSON to the given file. A null file defaults to stdout.
+ * Return the number of bytes written.
+ * @overload */
+inline size_t emit_json(NodeRef const& r, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit(EMIT_JSON, r, /*error_on_excess*/true).len;
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** emit YAML to an STL-like ostream */
+template<class OStream>
+inline OStream& operator<< (OStream& s, Tree const& t)
+{
+    EmitterOStream<OStream> em(s);
+    em.emit(EMIT_YAML, t);
+    return s;
+}
+
+/** emit YAML to an STL-like ostream
+ * @overload */
+template<class OStream>
+inline OStream& operator<< (OStream& s, NodeRef const& n)
+{
+    EmitterOStream<OStream> em(s);
+    em.emit(EMIT_YAML, n);
+    return s;
+}
+
+/** emit json to an STL-like stream */
+template<class OStream>
+inline OStream& operator<< (OStream& s, as_json const& j)
+{
+    EmitterOStream<OStream> em(s);
+    em.emit(EMIT_JSON, *j.tree, j.node, true);
+    return s;
+}
+
+
+//-----------------------------------------------------------------------------
+
+
+/** emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload */
+inline substr emit(Tree const& t, size_t id, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_YAML, t, id, error_on_excess);
+}
+
+/** emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload */
+inline substr emit_json(Tree const& t, size_t id, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_JSON, t, id, error_on_excess);
+}
+
+
+/** emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload */
+inline substr emit(Tree const& t, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_YAML, t, error_on_excess);
+}
+
+/** emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload */
+inline substr emit_json(Tree const& t, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_JSON, t, error_on_excess);
+}
+
+
+/** emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload
+ */
+inline substr emit(NodeRef const& r, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_YAML, r, error_on_excess);
+}
+
+/** emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @overload
+ */
+inline substr emit_json(NodeRef const& r, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit(EMIT_JSON, r, error_on_excess);
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** emit+resize: emit YAML to the given std::string/std::vector-like
+ * container, resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+substr emitrs(Tree const& t, size_t id, CharOwningContainer * cont)
+{
+    substr buf = to_substr(*cont);
+    substr ret = emit(t, id, buf, /*error_on_excess*/false);
+    if(ret.str == nullptr && ret.len > 0)
+    {
+        cont->resize(ret.len);
+        buf = to_substr(*cont);
+        ret = emit(t, id, buf, /*error_on_excess*/true);
+    }
+    return ret;
+}
+
+/** emit+resize: emit JSON to the given std::string/std::vector-like
+ * container, resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, size_t id, CharOwningContainer * cont)
+{
+    substr buf = to_substr(*cont);
+    substr ret = emit_json(t, id, buf, /*error_on_excess*/false);
+    if(ret.str == nullptr && ret.len > 0)
+    {
+        cont->resize(ret.len);
+        buf = to_substr(*cont);
+        ret = emit_json(t, id, buf, /*error_on_excess*/true);
+    }
+    return ret;
+}
+
+
+/** emit+resize: emit YAML to the given std::string/std::vector-like
+ * container, resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs(Tree const& t, size_t id)
+{
+    CharOwningContainer c;
+    emitrs(t, id, &c);
+    return c;
+}
+
+/** emit+resize: emit JSON to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(Tree const& t, size_t id)
+{
+    CharOwningContainer c;
+    emitrs_json(t, id, &c);
+    return c;
+}
+
+
+/** emit+resize: YAML to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+substr emitrs(Tree const& t, CharOwningContainer * cont)
+{
+    if(t.empty())
+        return {};
+    return emitrs(t, t.root_id(), cont);
+}
+
+/** emit+resize: JSON to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, CharOwningContainer * cont)
+{
+    if(t.empty())
+        return {};
+    return emitrs_json(t, t.root_id(), cont);
+}
+
+
+/** emit+resize: YAML to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs(Tree const& t)
+{
+    CharOwningContainer c;
+    if(t.empty())
+        return c;
+    emitrs(t, t.root_id(), &c);
+    return c;
+}
+
+/** emit+resize: JSON to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(Tree const& t)
+{
+    CharOwningContainer c;
+    if(t.empty())
+        return c;
+    emitrs_json(t, t.root_id(), &c);
+    return c;
+}
+
+
+/** emit+resize: YAML to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+substr emitrs(NodeRef const& n, CharOwningContainer * cont)
+{
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.valid());
+    return emitrs(*n.tree(), n.id(), cont);
+}
+
+/** emit+resize: JSON to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+substr emitrs_json(NodeRef const& n, CharOwningContainer * cont)
+{
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.valid());
+    return emitrs_json(*n.tree(), n.id(), cont);
+}
+
+
+/** emit+resize: YAML to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted YAML. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs(NodeRef const& n)
+{
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.valid());
+    CharOwningContainer c;
+    emitrs(*n.tree(), n.id(), &c);
+    return c;
+}
+
+/** emit+resize: JSON to the given std::string/std::vector-like container,
+ * resizing it as needed to fit the emitted JSON. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(NodeRef const& n)
+{
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.valid());
+    CharOwningContainer c;
+    emitrs_json(*n.tree(), n.id(), &c);
+    return c;
+}
+
+} // namespace yml
+} // namespace c4
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.def.hpp
+//#include "c4/yml/emit.def.hpp"
+#if !defined(C4_YML_EMIT_DEF_HPP_) && !defined(_C4_YML_EMIT_DEF_HPP_)
+#error "amalgamate: file c4/yml/emit.def.hpp must have been included at this point"
+#endif /* C4_YML_EMIT_DEF_HPP_ */
+
+
+#endif /* _C4_YML_EMIT_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/emit.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/emit.def.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.def.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_EMIT_DEF_HPP_
+#define _C4_YML_EMIT_DEF_HPP_
+
+#ifndef _C4_YML_EMIT_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.hpp
+//#include "c4/yml/emit.hpp"
+#if !defined(C4_YML_EMIT_HPP_) && !defined(_C4_YML_EMIT_HPP_)
+#error "amalgamate: file c4/yml/emit.hpp must have been included at this point"
+#endif /* C4_YML_EMIT_HPP_ */
+
+#endif
+
+namespace c4 {
+namespace yml {
+
+template<class Writer>
+substr Emitter<Writer>::emit(EmitType_e type, Tree const& t, size_t id, bool error_on_excess)
+{
+    if(t.empty())
+    {
+        _RYML_CB_ASSERT(t.callbacks(), id == NONE);
+        return {};
+    }
+    _RYML_CB_CHECK(t.callbacks(), id < t.size());
+    m_tree = &t;
+    if(type == EMIT_YAML)
+        _emit_yaml(id);
+    else if(type == EMIT_JSON)
+        _do_visit_json(id);
+    else
+        _RYML_CB_ERR(m_tree->callbacks(), "unknown emit type");
+    return this->Writer::_get(error_on_excess);
+}
+
+template<class Writer>
+substr Emitter<Writer>::emit(EmitType_e type, Tree const& t, bool error_on_excess)
+{
+    if(t.empty())
+        return {};
+    return emit(type, t, t.root_id(), error_on_excess);
+}
+
+template<class Writer>
+substr Emitter<Writer>::emit(EmitType_e type, NodeRef const& n, bool error_on_excess)
+{
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.valid());
+    return emit(type, *n.tree(), n.id(), error_on_excess);
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class Writer>
+void Emitter<Writer>::_emit_yaml(size_t id)
+{
+    // save branches in the visitor by doing the initial stream/doc
+    // logic here, sparing the need to check stream/val/keyval inside
+    // the visitor functions
+    auto dispatch = [this](size_t node){
+        NodeType ty = m_tree->type(node);
+        if(ty.marked_flow_sl())
+            _do_visit_flow_sl(node, 0);
+        else if(ty.marked_flow_ml())
+            _do_visit_flow_ml(node, 0);
+        else
+        {
+            _do_visit_block(node, 0);
+        }
+    };
+    if(!m_tree->is_root(id))
+    {
+        if(m_tree->is_container(id) && !m_tree->type(id).marked_flow())
+        {
+            size_t ilevel = 0;
+            if(m_tree->has_key(id))
+            {
+                this->Writer::_do_write(m_tree->key(id));
+                this->Writer::_do_write(":\n");
+                ++ilevel;
+            }
+            _do_visit_block_container(id, ilevel, ilevel);
+            return;
+        }
+    }
+
+    auto *btd = m_tree->tag_directives().b;
+    auto *etd = m_tree->tag_directives().e;
+    auto write_tag_directives = [&btd, etd, this](size_t next_node){
+        auto end = btd;
+        while(end < etd)
+        {
+            if(end->next_node_id > next_node)
+                break;
+            ++end;
+        }
+        for( ; btd != end; ++btd)
+        {
+            if(next_node != m_tree->first_child(m_tree->parent(next_node)))
+                this->Writer::_do_write("...\n");
+            this->Writer::_do_write("%TAG ");
+            this->Writer::_do_write(btd->handle);
+            this->Writer::_do_write(' ');
+            this->Writer::_do_write(btd->prefix);
+            this->Writer::_do_write('\n');
+        }
+    };
+    if(m_tree->is_stream(id))
+    {
+        if(m_tree->first_child(id) != NONE)
+            write_tag_directives(m_tree->first_child(id));
+        for(size_t child = m_tree->first_child(id); child != NONE; child = m_tree->next_sibling(child))
+        {
+            dispatch(child);
+            if(m_tree->next_sibling(child) != NONE)
+                write_tag_directives(m_tree->next_sibling(child));
+        }
+    }
+    else if(m_tree->is_container(id))
+    {
+        dispatch(id);
+    }
+    else if(m_tree->is_doc(id))
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->is_container(id)); // checked above
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_val(id)); // so it must be a val
+        _write_doc(id);
+    }
+    else if(m_tree->is_keyval(id))
+    {
+        _writek(id, 0);
+        this->Writer::_do_write(": ");
+        _writev(id, 0);
+        if(!m_tree->type(id).marked_flow())
+            this->Writer::_do_write('\n');
+    }
+    else if(m_tree->is_val(id))
+    {
+        //this->Writer::_do_write("- ");
+        _writev(id, 0);
+        if(!m_tree->type(id).marked_flow())
+            this->Writer::_do_write('\n');
+    }
+    else if(m_tree->type(id) == NOTYPE)
+    {
+        ;
+    }
+    else
+    {
+        _RYML_CB_ERR(m_tree->callbacks(), "unknown type");
+    }
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_doc(size_t id)
+{
+    RYML_ASSERT(m_tree->is_doc(id));
+    if(!m_tree->is_root(id))
+    {
+        RYML_ASSERT(m_tree->is_stream(m_tree->parent(id)));
+        this->Writer::_do_write("---");
+    }
+    if(!m_tree->has_val(id)) // this is more frequent
+    {
+        if(m_tree->has_val_tag(id))
+        {
+            if(!m_tree->is_root(id))
+                this->Writer::_do_write(' ');
+            _write_tag(m_tree->val_tag(id));
+        }
+        if(m_tree->has_val_anchor(id))
+        {
+            if(!m_tree->is_root(id))
+                this->Writer::_do_write(' ');
+            this->Writer::_do_write('&');
+            this->Writer::_do_write(m_tree->val_anchor(id));
+        }
+    }
+    else // docval
+    {
+        RYML_ASSERT(m_tree->has_val(id));
+        RYML_ASSERT(!m_tree->has_key(id));
+        if(!m_tree->is_root(id))
+            this->Writer::_do_write(' ');
+        _writev(id, 0);
+    }
+    this->Writer::_do_write('\n');
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_flow_sl(size_t node, size_t ilevel)
+{
+    RYML_ASSERT(!m_tree->is_stream(node));
+    RYML_ASSERT(m_tree->is_container(node) || m_tree->is_doc(node));
+    RYML_ASSERT(m_tree->is_root(node) || (m_tree->parent_is_map(node) || m_tree->parent_is_seq(node)));
+
+    if(m_tree->is_doc(node))
+    {
+        _write_doc(node);
+        if(!m_tree->has_children(node))
+            return;
+    }
+    else if(m_tree->is_container(node))
+    {
+        RYML_ASSERT(m_tree->is_map(node) || m_tree->is_seq(node));
+
+        bool spc = false; // write a space
+
+        if(m_tree->has_key(node))
+        {
+            _writek(node, ilevel);
+            this->Writer::_do_write(':');
+            spc = true;
+        }
+
+        if(m_tree->has_val_tag(node))
+        {
+            if(spc)
+                this->Writer::_do_write(' ');
+            _write_tag(m_tree->val_tag(node));
+            spc = true;
+        }
+
+        if(m_tree->has_val_anchor(node))
+        {
+            if(spc)
+                this->Writer::_do_write(' ');
+            this->Writer::_do_write('&');
+            this->Writer::_do_write(m_tree->val_anchor(node));
+            spc = true;
+        }
+
+        if(spc)
+            this->Writer::_do_write(' ');
+
+        if(m_tree->is_map(node))
+        {
+            this->Writer::_do_write('{');
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_seq(node));
+            this->Writer::_do_write('[');
+        }
+    } // container
+
+    for(size_t child = m_tree->first_child(node), count = 0; child != NONE; child = m_tree->next_sibling(child))
+    {
+        if(count++)
+            this->Writer::_do_write(',');
+        if(m_tree->is_keyval(child))
+        {
+            _writek(child, ilevel);
+            this->Writer::_do_write(": ");
+            _writev(child, ilevel);
+        }
+        else if(m_tree->is_val(child))
+        {
+            _writev(child, ilevel);
+        }
+        else
+        {
+            // with single-line flow, we can never go back to block
+            _do_visit_flow_sl(child, ilevel + 1);
+        }
+    }
+
+    if(m_tree->is_map(node))
+    {
+        this->Writer::_do_write('}');
+    }
+    else if(m_tree->is_seq(node))
+    {
+        this->Writer::_do_write(']');
+    }
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_flow_ml(size_t id, size_t ilevel, size_t do_indent)
+{
+    C4_UNUSED(id);
+    C4_UNUSED(ilevel);
+    C4_UNUSED(do_indent);
+    RYML_CHECK(false/*not implemented*/);
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_block_container(size_t node, size_t next_level, size_t do_indent)
+{
+    RepC ind = indent_to(do_indent * next_level);
+
+    if(m_tree->is_seq(node))
+    {
+        for(size_t child = m_tree->first_child(node); child != NONE; child = m_tree->next_sibling(child))
+        {
+            _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->has_key(child));
+            if(m_tree->is_val(child))
+            {
+                this->Writer::_do_write(ind);
+                this->Writer::_do_write("- ");
+                _writev(child, next_level);
+                this->Writer::_do_write('\n');
+            }
+            else
+            {
+                _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_container(child));
+                NodeType ty = m_tree->type(child);
+                if(ty.marked_flow_sl())
+                {
+                    this->Writer::_do_write(ind);
+                    this->Writer::_do_write("- ");
+                    _do_visit_flow_sl(child, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else if(ty.marked_flow_ml())
+                {
+                    this->Writer::_do_write(ind);
+                    this->Writer::_do_write("- ");
+                    _do_visit_flow_ml(child, next_level, do_indent);
+                    this->Writer::_do_write('\n');
+                }
+                else
+                {
+                    _do_visit_block(child, next_level, do_indent);
+                }
+            }
+            do_indent = true;
+            ind = indent_to(do_indent * next_level);
+        }
+    }
+    else // map
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_map(node));
+        for(size_t ich = m_tree->first_child(node); ich != NONE; ich = m_tree->next_sibling(ich))
+        {
+            _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->has_key(ich));
+            if(m_tree->is_keyval(ich))
+            {
+                this->Writer::_do_write(ind);
+                _writek(ich, next_level);
+                this->Writer::_do_write(": ");
+                _writev(ich, next_level);
+                this->Writer::_do_write('\n');
+            }
+            else
+            {
+                _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_container(ich));
+                NodeType ty = m_tree->type(ich);
+                if(ty.marked_flow_sl())
+                {
+                    this->Writer::_do_write(ind);
+                    _do_visit_flow_sl(ich, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else if(ty.marked_flow_ml())
+                {
+                    this->Writer::_do_write(ind);
+                    _do_visit_flow_ml(ich, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else
+                {
+                    _do_visit_block(ich, next_level, do_indent);
+                }
+            }
+            do_indent = true;
+            ind = indent_to(do_indent * next_level);
+        }
+    }
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_block(size_t node, size_t ilevel, size_t do_indent)
+{
+    RYML_ASSERT(!m_tree->is_stream(node));
+    RYML_ASSERT(m_tree->is_container(node) || m_tree->is_doc(node));
+    RYML_ASSERT(m_tree->is_root(node) || (m_tree->parent_is_map(node) || m_tree->parent_is_seq(node)));
+    RepC ind = indent_to(do_indent * ilevel);
+
+    if(m_tree->is_doc(node))
+    {
+        _write_doc(node);
+        if(!m_tree->has_children(node))
+            return;
+    }
+    else if(m_tree->is_container(node))
+    {
+        RYML_ASSERT(m_tree->is_map(node) || m_tree->is_seq(node));
+
+        bool spc = false; // write a space
+        bool nl = false;  // write a newline
+
+        if(m_tree->has_key(node))
+        {
+            this->Writer::_do_write(ind);
+            _writek(node, ilevel);
+            this->Writer::_do_write(':');
+            spc = true;
+        }
+        else if(!m_tree->is_root(node))
+        {
+            this->Writer::_do_write(ind);
+            this->Writer::_do_write('-');
+            spc = true;
+        }
+
+        if(m_tree->has_val_tag(node))
+        {
+            if(spc)
+                this->Writer::_do_write(' ');
+            _write_tag(m_tree->val_tag(node));
+            spc = true;
+            nl = true;
+        }
+
+        if(m_tree->has_val_anchor(node))
+        {
+            if(spc)
+                this->Writer::_do_write(' ');
+            this->Writer::_do_write('&');
+            this->Writer::_do_write(m_tree->val_anchor(node));
+            spc = true;
+            nl = true;
+        }
+
+        if(m_tree->has_children(node))
+        {
+            if(m_tree->has_key(node))
+                nl = true;
+            else
+                if(!m_tree->is_root(node) && !nl)
+                    spc = true;
+        }
+        else
+        {
+            if(m_tree->is_seq(node))
+                this->Writer::_do_write(" []\n");
+            else if(m_tree->is_map(node))
+                this->Writer::_do_write(" {}\n");
+            return;
+        }
+
+        if(spc && !nl)
+            this->Writer::_do_write(' ');
+
+        do_indent = 0;
+        if(nl)
+        {
+            this->Writer::_do_write('\n');
+            do_indent = 1;
+        }
+    } // container
+
+    size_t next_level = ilevel + 1;
+    if(m_tree->is_root(node) || m_tree->is_doc(node))
+        next_level = ilevel; // do not indent at top level
+
+    _do_visit_block_container(node, next_level, do_indent);
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_json(size_t id)
+{
+    _RYML_CB_CHECK(m_tree->callbacks(), !m_tree->is_stream(id)); // JSON does not have streams
+    if(m_tree->is_keyval(id))
+    {
+        _writek_json(id);
+        this->Writer::_do_write(": ");
+        _writev_json(id);
+    }
+    else if(m_tree->is_val(id))
+    {
+        _writev_json(id);
+    }
+    else if(m_tree->is_container(id))
+    {
+        if(m_tree->has_key(id))
+        {
+            _writek_json(id);
+            this->Writer::_do_write(": ");
+        }
+        if(m_tree->is_seq(id))
+            this->Writer::_do_write('[');
+        else if(m_tree->is_map(id))
+            this->Writer::_do_write('{');
+    }  // container
+
+    for(size_t ich = m_tree->first_child(id); ich != NONE; ich = m_tree->next_sibling(ich))
+    {
+        if(ich != m_tree->first_child(id))
+            this->Writer::_do_write(',');
+        _do_visit_json(ich);
+    }
+
+    if(m_tree->is_seq(id))
+        this->Writer::_do_write(']');
+    else if(m_tree->is_map(id))
+        this->Writer::_do_write('}');
+}
+
+template<class Writer>
+void Emitter<Writer>::_write(NodeScalar const& C4_RESTRICT sc, NodeType flags, size_t ilevel)
+{
+    if( ! sc.tag.empty())
+    {
+        _write_tag(sc.tag);
+        this->Writer::_do_write(' ');
+    }
+    if(flags.has_anchor())
+    {
+        RYML_ASSERT(flags.is_ref() != flags.has_anchor());
+        RYML_ASSERT( ! sc.anchor.empty());
+        this->Writer::_do_write('&');
+        this->Writer::_do_write(sc.anchor);
+        this->Writer::_do_write(' ');
+    }
+    else if(flags.is_ref())
+    {
+        if(sc.anchor != "<<")
+            this->Writer::_do_write('*');
+        this->Writer::_do_write(sc.anchor);
+        return;
+    }
+
+    // ensure the style flags only have one of KEY or VAL
+    _RYML_CB_ASSERT(m_tree->callbacks(), ((flags & (_WIP_KEY_STYLE|_WIP_VAL_STYLE)) == 0) || (((flags&_WIP_KEY_STYLE) == 0) != ((flags&_WIP_VAL_STYLE) == 0)));
+
+    auto style_marks = flags & (_WIP_KEY_STYLE|_WIP_VAL_STYLE);
+    if(style_marks & (_WIP_KEY_LITERAL|_WIP_VAL_LITERAL))
+    {
+        _write_scalar_literal(sc.scalar, ilevel, flags.has_key());
+    }
+    else if(style_marks & (_WIP_KEY_FOLDED|_WIP_VAL_FOLDED))
+    {
+        _write_scalar_folded(sc.scalar, ilevel, flags.has_key());
+    }
+    else if(style_marks & (_WIP_KEY_SQUO|_WIP_VAL_SQUO))
+    {
+        _write_scalar_squo(sc.scalar, ilevel);
+    }
+    else if(style_marks & (_WIP_KEY_DQUO|_WIP_VAL_DQUO))
+    {
+        _write_scalar_dquo(sc.scalar, ilevel);
+    }
+    else if(style_marks & (_WIP_KEY_PLAIN|_WIP_VAL_PLAIN))
+    {
+        _write_scalar_plain(sc.scalar, ilevel);
+    }
+    else if(!style_marks)
+    {
+        size_t first_non_nl = sc.scalar.first_not_of('\n');
+        bool all_newlines = first_non_nl == npos;
+        bool has_leading_ws = (!all_newlines) && sc.scalar.sub(first_non_nl).begins_with_any(" \t");
+        bool do_literal = ((!sc.scalar.empty() && all_newlines) || (has_leading_ws && !sc.scalar.trim(' ').empty()));
+        if(do_literal)
+        {
+            _write_scalar_literal(sc.scalar, ilevel, flags.has_key(), /*explicit_indentation*/has_leading_ws);
+        }
+        else
+        {
+            for(size_t i = 0; i < sc.scalar.len; ++i)
+            {
+                if(sc.scalar.str[i] == '\n')
+                {
+                    _write_scalar_literal(sc.scalar, ilevel, flags.has_key(), /*explicit_indentation*/has_leading_ws);
+                    goto wrote_special;
+                }
+                // todo: check for escaped characters requiring double quotes
+            }
+            _write_scalar(sc.scalar, flags.is_quoted());
+        wrote_special:
+            ;
+        }
+    }
+    else
+    {
+        _RYML_CB_ERR(m_tree->callbacks(), "not implemented");
+    }
+}
+template<class Writer>
+void Emitter<Writer>::_write_json(NodeScalar const& C4_RESTRICT sc, NodeType flags)
+{
+    if(C4_UNLIKELY( ! sc.tag.empty()))
+        _RYML_CB_ERR(m_tree->callbacks(), "JSON does not have tags");
+    if(C4_UNLIKELY(flags.has_anchor()))
+        _RYML_CB_ERR(m_tree->callbacks(), "JSON does not have anchors");
+    _write_scalar_json(sc.scalar, flags.has_key(), flags.is_quoted());
+}
+
+#define _rymlindent_nextline() for(size_t lv = 0; lv < ilevel+1; ++lv) { this->Writer::_do_write(' '); this->Writer::_do_write(' '); }
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_literal(csubstr s, size_t ilevel, bool explicit_key, bool explicit_indentation)
+{
+    if(explicit_key)
+        this->Writer::_do_write("? ");
+    csubstr trimmed = s.trimr("\n\r");
+    size_t numnewlines_at_end = s.len - trimmed.len - s.sub(trimmed.len).count('\r');
+    //
+    if(!explicit_indentation)
+        this->Writer::_do_write('|');
+    else
+        this->Writer::_do_write("|2");
+    //
+    if(numnewlines_at_end > 1 || (trimmed.len == 0 && s.len > 0)/*only newlines*/)
+        this->Writer::_do_write("+\n");
+    else if(numnewlines_at_end == 1)
+        this->Writer::_do_write('\n');
+    else
+        this->Writer::_do_write("-\n");
+    //
+    if(trimmed.len)
+    {
+        size_t pos = 0; // tracks the last character that was already written
+        for(size_t i = 0; i < trimmed.len; ++i)
+        {
+            if(trimmed[i] != '\n')
+                continue;
+            // write everything up to this point
+            csubstr since_pos = trimmed.range(pos, i+1); // include the newline
+            _rymlindent_nextline()
+            this->Writer::_do_write(since_pos);
+            pos = i+1; // already written
+        }
+        if(pos < trimmed.len)
+        {
+            _rymlindent_nextline()
+            this->Writer::_do_write(trimmed.sub(pos));
+        }
+        if(numnewlines_at_end)
+        {
+            this->Writer::_do_write('\n');
+            --numnewlines_at_end;
+        }
+    }
+    for(size_t i = 0; i < numnewlines_at_end; ++i)
+    {
+        _rymlindent_nextline()
+        if(i+1 < numnewlines_at_end || explicit_key)
+            this->Writer::_do_write('\n');
+    }
+    if(explicit_key && !numnewlines_at_end)
+        this->Writer::_do_write('\n');
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_folded(csubstr s, size_t ilevel, bool explicit_key)
+{
+    if(explicit_key)
+    {
+        this->Writer::_do_write("? ");
+    }
+    RYML_ASSERT(s.find("\r") == csubstr::npos);
+    csubstr trimmed = s.trimr('\n');
+    size_t numnewlines_at_end = s.len - trimmed.len;
+    if(numnewlines_at_end == 0)
+    {
+        this->Writer::_do_write(">-\n");
+    }
+    else if(numnewlines_at_end == 1)
+    {
+        this->Writer::_do_write(">\n");
+    }
+    else if(numnewlines_at_end > 1)
+    {
+        this->Writer::_do_write(">+\n");
+    }
+    if(trimmed.len)
+    {
+        size_t pos = 0; // tracks the last character that was already written
+        for(size_t i = 0; i < trimmed.len; ++i)
+        {
+            if(trimmed[i] != '\n')
+                continue;
+            // write everything up to this point
+            csubstr since_pos = trimmed.range(pos, i+1); // include the newline
+            pos = i+1; // because of the newline
+            _rymlindent_nextline()
+            this->Writer::_do_write(since_pos);
+            this->Writer::_do_write('\n'); // write the newline twice
+        }
+        if(pos < trimmed.len)
+        {
+            _rymlindent_nextline()
+            this->Writer::_do_write(trimmed.sub(pos));
+        }
+        if(numnewlines_at_end)
+        {
+            this->Writer::_do_write('\n');
+            --numnewlines_at_end;
+        }
+    }
+    for(size_t i = 0; i < numnewlines_at_end; ++i)
+    {
+        _rymlindent_nextline()
+        if(i+1 < numnewlines_at_end || explicit_key)
+            this->Writer::_do_write('\n');
+    }
+    if(explicit_key && !numnewlines_at_end)
+        this->Writer::_do_write('\n');
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_squo(csubstr s, size_t ilevel)
+{
+    size_t pos = 0; // tracks the last character that was already written
+    this->Writer::_do_write('\'');
+    for(size_t i = 0; i < s.len; ++i)
+    {
+        if(s[i] == '\n')
+        {
+            csubstr sub = s.range(pos, i+1);
+            this->Writer::_do_write(sub);  // write everything up to (including) this char
+            this->Writer::_do_write('\n'); // write the character again
+            if(i + 1 < s.len)
+                _rymlindent_nextline()     // indent the next line
+            pos = i+1;
+        }
+        else if(s[i] == '\'')
+        {
+            csubstr sub = s.range(pos, i+1);
+            this->Writer::_do_write(sub); // write everything up to (including) this char
+            this->Writer::_do_write('\''); // write the character again
+            pos = i+1;
+        }
+    }
+    // write missing characters at the end of the string
+    if(pos < s.len)
+        this->Writer::_do_write(s.sub(pos));
+    this->Writer::_do_write('\'');
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_dquo(csubstr s, size_t ilevel)
+{
+    size_t pos = 0; // tracks the last character that was already written
+    this->Writer::_do_write('"');
+    for(size_t i = 0; i < s.len; ++i)
+    {
+        const char curr = s.str[i];
+        if(curr == '"' || curr == '\\')
+        {
+            csubstr sub = s.range(pos, i);
+            this->Writer::_do_write(sub);  // write everything up to (excluding) this char
+            this->Writer::_do_write('\\'); // write the escape
+            this->Writer::_do_write(curr); // write the char
+            pos = i+1;
+        }
+        else if(s[i] == '\n')
+        {
+            csubstr sub = s.range(pos, i+1);
+            this->Writer::_do_write(sub);  // write everything up to (including) this newline
+            this->Writer::_do_write('\n'); // write the newline again
+            if(i + 1 < s.len)
+                _rymlindent_nextline()     // indent the next line
+            pos = i+1;
+            if(i+1 < s.len) // escape leading whitespace after the newline
+            {
+                const char next = s.str[i+1];
+                if(next == ' ' || next == '\t')
+                    this->Writer::_do_write('\\');
+            }
+        }
+        else if(curr == ' ' || curr == '\t')
+        {
+            // escape trailing whitespace before a newline
+            size_t next = s.first_not_of(" \t\r", i);
+            if(next != npos && s[next] == '\n')
+            {
+                csubstr sub = s.range(pos, i);
+                this->Writer::_do_write(sub);  // write everything up to (excluding) this char
+                this->Writer::_do_write('\\'); // escape the whitespace
+                pos = i;
+            }
+        }
+    }
+    // write missing characters at the end of the string
+    if(pos < s.len)
+    {
+        csubstr sub = s.sub(pos);
+        this->Writer::_do_write(sub);
+    }
+    this->Writer::_do_write('"');
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_plain(csubstr s, size_t ilevel)
+{
+    size_t pos = 0; // tracks the last character that was already written
+    for(size_t i = 0; i < s.len; ++i)
+    {
+        const char curr = s.str[i];
+        if(curr == '\n')
+        {
+            csubstr sub = s.range(pos, i+1);
+            this->Writer::_do_write(sub);  // write everything up to (including) this newline
+            this->Writer::_do_write('\n'); // write the newline again
+            if(i + 1 < s.len)
+                _rymlindent_nextline()     // indent the next line
+            pos = i+1;
+        }
+    }
+    // write missing characters at the end of the string
+    if(pos < s.len)
+    {
+        csubstr sub = s.sub(pos);
+        this->Writer::_do_write(sub);
+    }
+}
+
+#undef _rymlindent_nextline
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar(csubstr s, bool was_quoted)
+{
+    // this block of code needed to be moved to before the needs_quotes
+    // assignment to work around a g++ optimizer bug where (s.str != nullptr)
+    // was evaluated as true even if s.str was actually a nullptr (!!!)
+    if(s.len == size_t(0))
+    {
+        if(was_quoted)
+            this->Writer::_do_write("''");
+        return;
+    }
+
+    const bool needs_quotes = (
+        was_quoted
+        ||
+        (
+            ( ! s.is_number())
+            &&
+            (
+                // has leading whitespace
+                s.begins_with_any(" \n\t\r")
+                ||
+                // looks like reference or anchor or would be treated as a directive
+                s.begins_with_any("*&%")
+                ||
+                s.begins_with("<<")
+                ||
+                // has trailing whitespace
+                s.ends_with_any(" \n\t\r")
+                ||
+                // has special chars
+                (s.first_of("#:-?,\n{}[]'\"") != npos)
+            )
+        )
+    );
+
+    if( ! needs_quotes)
+    {
+        this->Writer::_do_write(s);
+    }
+    else
+    {
+        const bool has_dquotes = s.first_of( '"') != npos;
+        const bool has_squotes = s.first_of('\'') != npos;
+        if(!has_squotes && has_dquotes)
+        {
+            this->Writer::_do_write('\'');
+            this->Writer::_do_write(s);
+            this->Writer::_do_write('\'');
+        }
+        else if(has_squotes && !has_dquotes)
+        {
+            RYML_ASSERT(s.count('\n') == 0);
+            this->Writer::_do_write('"');
+            this->Writer::_do_write(s);
+            this->Writer::_do_write('"');
+        }
+        else
+        {
+            _write_scalar_squo(s, /*FIXME FIXME FIXME*/0);
+        }
+    }
+}
+template<class Writer>
+void Emitter<Writer>::_write_scalar_json(csubstr s, bool as_key, bool was_quoted)
+{
+    if(was_quoted)
+    {
+        this->Writer::_do_write('"');
+        this->Writer::_do_write(s);
+        this->Writer::_do_write('"');
+    }
+    // json only allows strings as keys
+    else if(!as_key && (s.is_number() || s == "true" || s == "null" || s == "false"))
+    {
+        this->Writer::_do_write(s);
+    }
+    else
+    {
+        size_t pos = 0;
+        this->Writer::_do_write('"');
+        for(size_t i = 0; i < s.len; ++i)
+        {
+            switch (s[i])
+            {
+                case '"':
+                case '\n': {
+                    if(i > 0)
+                    {
+                        csubstr sub = s.range(pos, i);
+                        this->Writer::_do_write(sub);
+                    }
+                    pos = i + 1;
+                    switch (s[i]) {
+                        case '"':
+                            this->Writer::_do_write("\\\"");
+                            break;
+                        case '\n':
+                            this->Writer::_do_write("\\n");
+                            break;
+                    }
+                    break;
+                }
+            }
+        }
+        if(pos < s.len)
+        {
+            csubstr sub = s.sub(pos);
+            this->Writer::_do_write(sub);
+        }
+        this->Writer::_do_write('"');
+    }
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_EMIT_DEF_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/emit.def.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/detail/stack.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/stack.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_DETAIL_STACK_HPP_
+#define _C4_YML_DETAIL_STACK_HPP_
+
+#ifndef _C4_YML_COMMON_HPP_
+//included above:
+//#include "../common.hpp"
+#endif
+
+#ifdef RYML_DBG
+//included above:
+//#   include <type_traits>
+#endif
+
+//included above:
+//#include <string.h>
+
+namespace c4 {
+namespace yml {
+namespace detail {
+
+/** A lightweight contiguous stack with SSO. This avoids a dependency on std. */
+template<class T, size_t N=16>
+class stack
+{
+    static_assert(std::is_trivially_copyable<T>::value, "T must be trivially copyable");
+    static_assert(std::is_trivially_destructible<T>::value, "T must be trivially destructible");
+
+    enum : size_t { sso_size = N };
+
+public:
+
+    T         m_buf[N];
+    T *       m_stack;
+    size_t    m_size;
+    size_t    m_capacity;
+    Callbacks m_callbacks;
+
+public:
+
+    constexpr static bool is_contiguous() { return true; }
+
+    stack(Callbacks const& cb)
+        : m_buf()
+        , m_stack(m_buf)
+        , m_size(0)
+        , m_capacity(N)
+        , m_callbacks(cb) {}
+    stack() : stack(get_callbacks()) {}
+    ~stack()
+    {
+        _free();
+    }
+
+    stack(stack const& that) noexcept : stack(that.m_callbacks)
+    {
+        resize(that.m_size);
+        _cp(&that);
+    }
+
+    stack(stack &&that) noexcept : stack(that.m_callbacks)
+    {
+        _mv(&that);
+    }
+
+    stack& operator= (stack const& that) noexcept
+    {
+        _cb(that.m_callbacks);
+        resize(that.m_size);
+        _cp(&that);
+        return *this;
+    }
+
+    stack& operator= (stack &&that) noexcept
+    {
+        _cb(that.m_callbacks);
+        _mv(&that);
+        return *this;
+    }
+
+public:
+
+    size_t size() const { return m_size; }
+    size_t empty() const { return m_size == 0; }
+    size_t capacity() const { return m_capacity; }
+
+    void clear()
+    {
+        m_size = 0;
+    }
+
+    void resize(size_t sz)
+    {
+        reserve(sz);
+        m_size = sz;
+    }
+
+    void reserve(size_t sz);
+
+    void push(T const& C4_RESTRICT n)
+    {
+        RYML_ASSERT((const char*)&n + sizeof(T) < (const char*)m_stack || &n > m_stack + m_capacity);
+        if(m_size == m_capacity)
+        {
+            size_t cap = m_capacity == 0 ? N : 2 * m_capacity;
+            reserve(cap);
+        }
+        m_stack[m_size] = n;
+        ++m_size;
+    }
+
+    void push_top()
+    {
+        RYML_ASSERT(m_size > 0);
+        if(m_size == m_capacity)
+        {
+            size_t cap = m_capacity == 0 ? N : 2 * m_capacity;
+            reserve(cap);
+        }
+        m_stack[m_size] = m_stack[m_size - 1];
+        ++m_size;
+    }
+
+    T const& C4_RESTRICT pop()
+    {
+        RYML_ASSERT(m_size > 0);
+        --m_size;
+        return m_stack[m_size];
+    }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT top() const { RYML_ASSERT(m_size > 0); return m_stack[m_size - 1]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT top()       { RYML_ASSERT(m_size > 0); return m_stack[m_size - 1]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT bottom() const { RYML_ASSERT(m_size > 0); return m_stack[0]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT bottom()       { RYML_ASSERT(m_size > 0); return m_stack[0]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT top(size_t i) const { RYML_ASSERT(i < m_size); return m_stack[m_size - 1 - i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT top(size_t i)       { RYML_ASSERT(i < m_size); return m_stack[m_size - 1 - i]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT bottom(size_t i) const { RYML_ASSERT(i < m_size); return m_stack[i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT bottom(size_t i)       { RYML_ASSERT(i < m_size); return m_stack[i]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT operator[](size_t i) const { RYML_ASSERT(i < m_size); return m_stack[i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT operator[](size_t i)       { RYML_ASSERT(i < m_size); return m_stack[i]; }
+
+public:
+
+    using       iterator = T       *;
+    using const_iterator = T const *;
+
+    iterator begin() { return m_stack; }
+    iterator end  () { return m_stack + m_size; }
+
+    const_iterator begin() const { return (const_iterator)m_stack; }
+    const_iterator end  () const { return (const_iterator)m_stack + m_size; }
+
+public:
+    void _free();
+    void _cp(stack const* C4_RESTRICT that);
+    void _mv(stack * that);
+    void _cb(Callbacks const& cb);
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class T, size_t N>
+void stack<T, N>::reserve(size_t sz)
+{
+    if(sz <= m_size)
+        return;
+    if(sz <= N)
+    {
+        m_stack = m_buf;
+        m_capacity = N;
+        return;
+    }
+    T *buf = (T*) m_callbacks.m_allocate(sz * sizeof(T), m_stack, m_callbacks.m_user_data);
+    memcpy(buf, m_stack, m_size * sizeof(T));
+    if(m_stack != m_buf)
+    {
+        m_callbacks.m_free(m_stack, m_capacity * sizeof(T), m_callbacks.m_user_data);
+    }
+    m_stack = buf;
+    m_capacity = sz;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, size_t N>
+void stack<T, N>::_free()
+{
+    RYML_ASSERT(m_stack != nullptr); // this structure cannot be memset() to zero
+    if(m_stack != m_buf)
+    {
+        m_callbacks.m_free(m_stack, m_capacity * sizeof(T), m_callbacks.m_user_data);
+        m_stack = m_buf;
+        m_size = N;
+        m_capacity = N;
+    }
+    else
+    {
+        RYML_ASSERT(m_capacity == N);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, size_t N>
+void stack<T, N>::_cp(stack const* C4_RESTRICT that)
+{
+    if(that->m_stack != that->m_buf)
+    {
+        RYML_ASSERT(that->m_capacity > N);
+        RYML_ASSERT(that->m_size <= that->m_capacity);
+    }
+    else
+    {
+        RYML_ASSERT(that->m_capacity <= N);
+        RYML_ASSERT(that->m_size <= that->m_capacity);
+    }
+    memcpy(m_stack, that->m_stack, that->m_size * sizeof(T));
+    m_size = that->m_size;
+    m_capacity = that->m_size < N ? N : that->m_size;
+    m_callbacks = that->m_callbacks;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, size_t N>
+void stack<T, N>::_mv(stack * that)
+{
+    if(that->m_stack != that->m_buf)
+    {
+        RYML_ASSERT(that->m_capacity > N);
+        RYML_ASSERT(that->m_size <= that->m_capacity);
+        m_stack = that->m_stack;
+    }
+    else
+    {
+        RYML_ASSERT(that->m_capacity <= N);
+        RYML_ASSERT(that->m_size <= that->m_capacity);
+        memcpy(m_buf, that->m_buf, that->m_size * sizeof(T));
+        m_stack = m_buf;
+    }
+    m_size = that->m_size;
+    m_capacity = that->m_capacity;
+    m_callbacks = that->m_callbacks;
+    // make sure no deallocation happens on destruction
+    RYML_ASSERT(that->m_stack != m_buf);
+    that->m_stack = that->m_buf;
+    that->m_capacity = N;
+    that->m_size = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, size_t N>
+void stack<T, N>::_cb(Callbacks const& cb)
+{
+    if(cb != m_callbacks)
+    {
+        _free();
+        m_callbacks = cb;
+    }
+}
+
+} // namespace detail
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_DETAIL_STACK_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/detail/stack.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/parse.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_PARSE_HPP_
+#define _C4_YML_PARSE_HPP_
+
+#ifndef _C4_YML_TREE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+#endif
+
+#ifndef _C4_YML_NODE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+#endif
+
+#ifndef _C4_YML_DETAIL_STACK_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/stack.hpp
+//#include "c4/yml/detail/stack.hpp"
+#if !defined(C4_YML_DETAIL_STACK_HPP_) && !defined(_C4_YML_DETAIL_STACK_HPP_)
+#error "amalgamate: file c4/yml/detail/stack.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_STACK_HPP_ */
+
+#endif
+
+//included above:
+//#include <stdarg.h>
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4251/*needs to have dll-interface to be used by clients of struct*/)
+#endif
+
+namespace c4 {
+namespace yml {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class RYML_EXPORT Parser
+{
+public:
+
+    /** @name construction and assignment */
+    /** @{ */
+
+    Parser() : Parser(get_callbacks()) {}
+    Parser(Callbacks const& cb);
+    ~Parser();
+
+    Parser(Parser &&);
+    Parser(Parser const&);
+    Parser& operator=(Parser &&);
+    Parser& operator=(Parser const&);
+
+    /** @} */
+
+public:
+
+    /** @name modifiers */
+    /** @{ */
+
+    /** Reserve a certain capacity for the parsing stack.
+     * This should be larger than the expected depth of the parsed
+     * YAML tree.
+     *
+     * The parsing stack is the only (potential) heap memory used by
+     * the parser.
+     *
+     * If the requested capacity is below the default
+     * stack size of 16, the memory is used directly in the parser
+     * object; otherwise it will be allocated from the heap.
+     *
+     * @note this reserves memory only for the parser itself; all the
+     * allocations for the parsed tree will go through the tree's
+     * allocator.
+     *
+     * @note the tree and the arena can (and should) also be reserved. */
+    void reserve_stack(size_t capacity)
+    {
+        m_stack.reserve(capacity);
+    }
+
+    /** Reserve a certain capacity for the array used to track node
+     * locations in the source buffer. */
+    void reserve_locations(size_t num_source_lines)
+    {
+        _resize_locations(num_source_lines);
+    }
+
+    /** Reserve a certain capacity for the character arena used to
+     * filter scalars. */
+    void reserve_filter_arena(size_t num_characters)
+    {
+        _resize_filter_arena(num_characters);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name getters and modifiers */
+    /** @{ */
+
+    /** Get the current callbacks in the parser. */
+    Callbacks callbacks() const { return m_stack.m_callbacks; }
+
+    /** Get the name of the latest file parsed by this object. */
+    csubstr filename() const { return m_file; }
+
+    /** Get the latest YAML buffer parsed by this object. */
+    csubstr source() const { return m_buf; }
+
+    size_t stack_capacity() const { return m_stack.capacity(); }
+    size_t locations_capacity() const { return m_newline_offsets_capacity; }
+    size_t filter_arena_capacity() const { return m_filter_arena.len; }
+
+    /** @} */
+
+public:
+
+    /** @name parse_in_place */
+    /** @{ */
+
+    /** Create a new tree and parse into its root.
+     * The tree is created with the callbacks currently in the parser. */
+    Tree parse_in_place(csubstr filename, substr src)
+    {
+        Tree t(callbacks());
+        t.reserve(_estimate_capacity(src));
+        this->parse_in_place(filename, src, &t, t.root_id());
+        return t;
+    }
+
+    /** Parse into an existing tree, starting at its root node.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_place(csubstr filename, substr src, Tree *t)
+    {
+        this->parse_in_place(filename, src, t, t->root_id());
+    }
+
+    /** Parse into an existing node.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_place(csubstr filename, substr src, Tree *t, size_t node_id);
+    //   ^^^^^^^^^^^^^ this is the workhorse overload; everything else is syntactic candy
+
+    /** Parse into an existing node.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_place(csubstr filename, substr src, NodeRef node)
+    {
+        this->parse_in_place(filename, src, node.tree(), node.id());
+    }
+
+    RYML_DEPRECATED("use parse_in_place() instead") Tree parse(csubstr filename, substr src) { return parse_in_place(filename, src); }
+    RYML_DEPRECATED("use parse_in_place() instead") void parse(csubstr filename, substr src, Tree *t) { parse_in_place(filename, src, t); }
+    RYML_DEPRECATED("use parse_in_place() instead") void parse(csubstr filename, substr src, Tree *t, size_t node_id) { parse_in_place(filename, src, t, node_id); }
+    RYML_DEPRECATED("use parse_in_place() instead") void parse(csubstr filename, substr src, NodeRef node) { parse_in_place(filename, src, node); }
+
+    /** @} */
+
+public:
+
+    /** @name parse_in_arena: copy the YAML source buffer to the
+     * tree's arena, then parse the copy in situ
+     *
+     * @note overloads receiving a substr YAML buffer are intentionally
+     * left undefined, such that calling parse_in_arena() with a substr
+     * will cause a linker error. This is to prevent an accidental
+     * copy of the source buffer to the tree's arena, because substr
+     * is implicitly convertible to csubstr. If you really intend to parse
+     * a mutable buffer in the tree's arena, convert it first to immutable
+     * by assigning the substr to a csubstr prior to calling parse_in_arena().
+     * This is not needed for parse_in_place() because csubstr is not
+     * implicitly convertible to substr. */
+    /** @{ */
+
+    // READ THE NOTE ABOVE!
+    #define RYML_DONT_PARSE_SUBSTR_IN_ARENA "Do not pass a (mutable) substr to parse_in_arena(); if you have a substr, it should be parsed in place. Consider using parse_in_place() instead, or convert the buffer to csubstr prior to calling. This function is deliberately left undefined and will cause a compiler error."
+    RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_in_arena(csubstr filename, substr csrc);
+    RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr csrc, Tree *t);
+    RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr csrc, Tree *t, size_t node_id);
+    RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr csrc, NodeRef node);
+
+    /** Create a new tree and parse into its root.
+     * The immutable YAML source is first copied to the tree's arena,
+     * and parsed from there.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    Tree parse_in_arena(csubstr filename, csubstr csrc)
+    {
+        Tree t(callbacks());
+        substr src = t.copy_to_arena(csrc);
+        t.reserve(_estimate_capacity(csrc));
+        this->parse_in_place(filename, src, &t, t.root_id());
+        return t;
+    }
+
+    /** Parse into an existing tree, starting at its root node.
+     * The immutable YAML source is first copied to the tree's arena,
+     * and parsed from there.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_arena(csubstr filename, csubstr csrc, Tree *t)
+    {
+        substr src = t->copy_to_arena(csrc);
+        this->parse_in_place(filename, src, t, t->root_id());
+    }
+
+    /** Parse into a specific node in an existing tree.
+     * The immutable YAML source is first copied to the tree's arena,
+     * and parsed from there.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_arena(csubstr filename, csubstr csrc, Tree *t, size_t node_id)
+    {
+        substr src = t->copy_to_arena(csrc);
+        this->parse_in_place(filename, src, t, node_id);
+    }
+
+    /** Parse into a specific node in an existing tree.
+     * The immutable YAML source is first copied to the tree's arena,
+     * and parsed from there.
+     * The callbacks in the tree are kept, and used to allocate
+     * the tree members, if any allocation is required. */
+    void parse_in_arena(csubstr filename, csubstr csrc, NodeRef node)
+    {
+        substr src = node.tree()->copy_to_arena(csrc);
+        this->parse_in_place(filename, src, node.tree(), node.id());
+    }
+
+    RYML_DEPRECATED("use parse_in_arena() instead") Tree parse(csubstr filename, csubstr csrc) { return parse_in_arena(filename, csrc); }
+    RYML_DEPRECATED("use parse_in_arena() instead") void parse(csubstr filename, csubstr csrc, Tree *t) { parse_in_arena(filename, csrc, t); }
+    RYML_DEPRECATED("use parse_in_arena() instead") void parse(csubstr filename, csubstr csrc, Tree *t, size_t node_id) { parse_in_arena(filename, csrc, t, node_id); }
+    RYML_DEPRECATED("use parse_in_arena() instead") void parse(csubstr filename, csubstr csrc, NodeRef node) { parse_in_arena(filename, csrc, node); }
+
+    /** @} */
+
+public:
+
+    /** @name locations */
+    /** @{ */
+
+    /** Get the location of a node of the last tree to be parsed by this parser. */
+    Location location(Tree const& tree, size_t node_id) const;
+    /** Get the location of a node of the last tree to be parsed by this parser. */
+    Location location(NodeRef node) const;
+    /** Get the string starting at a particular location, to the end
+     * of the parsed source buffer. */
+    csubstr location_contents(Location const& loc) const;
+    /** Given a pointer to a buffer position, get the location. @p val
+     * must be pointing to somewhere in the source buffer that was
+     * last parsed by this object. */
+    Location val_location(const char *val) const;
+
+    /** @} */
+
+private:
+
+    typedef enum {
+        BLOCK_LITERAL, //!< keep newlines (|)
+        BLOCK_FOLD     //!< replace newline with single space (>)
+    } BlockStyle_e;
+
+    typedef enum {
+        CHOMP_CLIP,    //!< single newline at end (default)
+        CHOMP_STRIP,   //!< no newline at end     (-)
+        CHOMP_KEEP     //!< all newlines from end (+)
+    } BlockChomp_e;
+
+private:
+
+    using flag_t = int;
+
+    static size_t _estimate_capacity(csubstr src) { size_t c = _count_nlines(src); c = c >= 16 ? c : 16; return c; }
+
+    void  _reset();
+
+    bool  _finished_file() const;
+    bool  _finished_line() const;
+
+    csubstr _peek_next_line(size_t pos=npos) const;
+    bool    _advance_to_peeked();
+    void    _scan_line();
+
+    csubstr _slurp_doc_scalar();
+
+    /**
+     * @param [out] quoted
+     * Will only be written to if this method returns true.
+     * Will be set to true if the scanned scalar was quoted, by '', "", > or |.
+     */
+    bool    _scan_scalar(csubstr *C4_RESTRICT scalar, bool *C4_RESTRICT quoted);
+
+    csubstr _scan_comment();
+    csubstr _scan_squot_scalar();
+    csubstr _scan_dquot_scalar();
+    csubstr _scan_block();
+    substr  _scan_plain_scalar_blck(csubstr currscalar, csubstr peeked_line, size_t indentation);
+    substr  _scan_plain_scalar_flow(csubstr currscalar, csubstr peeked_line);
+    substr  _scan_complex_key(csubstr currscalar, csubstr peeked_line);
+    csubstr _scan_to_next_nonempty_line(size_t indentation);
+    csubstr _extend_scanned_scalar(csubstr currscalar);
+
+    csubstr _filter_squot_scalar(const substr s);
+    csubstr _filter_dquot_scalar(substr s);
+    csubstr _filter_plain_scalar(substr s, size_t indentation);
+    csubstr _filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e chomp, size_t indentation);
+    template<bool backslash_is_escape, bool keep_trailing_whitespace>
+    bool    _filter_nl(substr scalar, size_t *C4_RESTRICT pos, size_t *C4_RESTRICT filter_arena_pos, size_t indentation);
+    template<bool keep_trailing_whitespace>
+    void    _filter_ws(substr scalar, size_t *C4_RESTRICT pos, size_t *C4_RESTRICT filter_arena_pos);
+    bool    _apply_chomp(substr buf, size_t *C4_RESTRICT pos, BlockChomp_e chomp);
+
+    void  _handle_finished_file();
+    void  _handle_line();
+
+    bool  _handle_indentation();
+
+    bool  _handle_unk();
+    bool  _handle_map_flow();
+    bool  _handle_map_blck();
+    bool  _handle_seq_flow();
+    bool  _handle_seq_blck();
+    bool  _handle_top();
+    bool  _handle_types();
+    bool  _handle_key_anchors_and_refs();
+    bool  _handle_val_anchors_and_refs();
+    void  _move_val_tag_to_key_tag();
+    void  _move_key_tag_to_val_tag();
+    void  _move_key_tag2_to_key_tag();
+    void  _move_val_anchor_to_key_anchor();
+    void  _move_key_anchor_to_val_anchor();
+
+    void  _push_level(bool explicit_flow_chars = false);
+    void  _pop_level();
+
+    void  _start_unk(bool as_child=true);
+
+    void  _start_map(bool as_child=true);
+    void  _start_map_unk(bool as_child);
+    void  _stop_map();
+
+    void  _start_seq(bool as_child=true);
+    void  _stop_seq();
+
+    void  _start_seqimap();
+    void  _stop_seqimap();
+
+    void  _start_doc(bool as_child=true);
+    void  _stop_doc();
+    void  _start_new_doc(csubstr rem);
+    void  _end_stream();
+
+    NodeData* _append_val(csubstr val, flag_t quoted=false);
+    NodeData* _append_key_val(csubstr val, flag_t val_quoted=false);
+    bool  _rval_dash_start_or_continue_seq();
+
+    void  _store_scalar(csubstr s, flag_t is_quoted);
+    csubstr _consume_scalar();
+    void  _move_scalar_from_top();
+
+    inline NodeData* _append_val_null(const char *str) { _RYML_CB_ASSERT(m_stack.m_callbacks, str >= m_buf.begin() && str <= m_buf.end()); return _append_val({str, size_t(0)}); }
+    inline NodeData* _append_key_val_null(const char *str) { _RYML_CB_ASSERT(m_stack.m_callbacks, str >= m_buf.begin() && str <= m_buf.end()); return _append_key_val({str, size_t(0)}); }
+    inline void      _store_scalar_null(const char *str) {  _RYML_CB_ASSERT(m_stack.m_callbacks, str >= m_buf.begin() && str <= m_buf.end()); _store_scalar({str, size_t(0)}, false); }
+
+    void  _set_indentation(size_t behind);
+    void  _save_indentation(size_t behind=0);
+    bool  _maybe_set_indentation_from_anchor_or_tag();
+
+    void  _write_key_anchor(size_t node_id);
+    void  _write_val_anchor(size_t node_id);
+
+    void _handle_directive(csubstr directive);
+
+    void _skipchars(char c);
+    template<size_t N>
+    void _skipchars(const char (&chars)[N]);
+
+private:
+
+    static size_t _count_nlines(csubstr src);
+
+private:
+
+    typedef enum : flag_t {
+        RTOP = 0x01 <<  0,   ///< reading at top level
+        RUNK = 0x01 <<  1,   ///< reading an unknown: must determine whether scalar, map or seq
+        RMAP = 0x01 <<  2,   ///< reading a map
+        RSEQ = 0x01 <<  3,   ///< reading a seq
+        FLOW = 0x01 <<  4,   ///< reading is inside explicit flow chars: [] or {}
+        QMRK = 0x01 <<  5,   ///< reading an explicit key (`? key`)
+        RKEY = 0x01 <<  6,   ///< reading a scalar as key
+        RVAL = 0x01 <<  7,   ///< reading a scalar as val
+        RNXT = 0x01 <<  8,   ///< read next val or keyval
+        SSCL = 0x01 <<  9,   ///< there's a stored scalar
+        QSCL = 0x01 << 10,   ///< stored scalar was quoted
+        RSET = 0x01 << 11,   ///< the (implicit) map being read is a !!set. @see https://yaml.org/type/set.html
+        NDOC = 0x01 << 12,   ///< no document mode. a document has ended and another has not started yet.
+        //! reading an implicit map nested in an explicit seq.
+        //! eg, {key: [key2: value2, key3: value3]}
+        //! is parsed as {key: [{key2: value2}, {key3: value3}]}
+        RSEQIMAP = 0x01 << 13,
+    } State_e;
+
+    struct LineContents
+    {
+        csubstr  full;        ///< the full line, including newlines on the right
+        csubstr  stripped;    ///< the stripped line, excluding newlines on the right
+        csubstr  rem;         ///< the stripped line remainder; initially starts at the first non-space character
+        size_t   indentation; ///< the number of spaces on the beginning of the line
+
+        LineContents() : full(), stripped(), rem(), indentation() {}
+
+        void reset_with_next_line(csubstr buf, size_t pos);
+
+        void reset(csubstr full_, csubstr stripped_)
+        {
+            full = full_;
+            stripped = stripped_;
+            rem = stripped_;
+            // find the first column where the character is not a space
+            indentation = full.first_not_of(' ');
+        }
+
+        size_t current_col() const
+        {
+            return current_col(rem);
+        }
+
+        size_t current_col(csubstr s) const
+        {
+            RYML_ASSERT(s.str >= full.str);
+            RYML_ASSERT(full.is_super(s));
+            size_t col = static_cast<size_t>(s.str - full.str);
+            return col;
+        }
+    };
+
+    struct State
+    {
+        flag_t       flags;
+        size_t       level;
+        size_t       node_id; // don't hold a pointer to the node as it will be relocated during tree resizes
+        csubstr      scalar;
+        size_t       scalar_col; // the column where the scalar (or its quotes) begin
+
+        Location     pos;
+        LineContents line_contents;
+        size_t       indref;
+
+        State() : flags(), level(), node_id(), scalar(), scalar_col(), pos(), line_contents(), indref() {}
+
+        void reset(const char *file, size_t node_id_)
+        {
+            flags = RUNK|RTOP;
+            level = 0;
+            pos.name = to_csubstr(file);
+            pos.offset = 0;
+            pos.line = 1;
+            pos.col = 1;
+            node_id = node_id_;
+            scalar_col = 0;
+            scalar.clear();
+            indref = 0;
+        }
+    };
+
+    void _line_progressed(size_t ahead);
+    void _line_ended();
+    void _line_ended_undo();
+
+    void _prepare_pop()
+    {
+        RYML_ASSERT(m_stack.size() > 1);
+        State const& curr = m_stack.top();
+        State      & next = m_stack.top(1);
+        next.pos = curr.pos;
+        next.line_contents = curr.line_contents;
+        next.scalar = curr.scalar;
+    }
+
+    inline bool _at_line_begin() const
+    {
+        return m_state->line_contents.rem.begin() == m_state->line_contents.full.begin();
+    }
+    inline bool _at_line_end() const
+    {
+        csubstr r = m_state->line_contents.rem;
+        return r.empty() || r.begins_with(' ', r.len);
+    }
+    inline bool _token_is_from_this_line(csubstr token) const
+    {
+        return token.is_sub(m_state->line_contents.full);
+    }
+
+    inline NodeData * node(State const* s) const { return m_tree->get(s->node_id); }
+    inline NodeData * node(State const& s) const { return m_tree->get(s .node_id); }
+    inline NodeData * node(size_t node_id) const { return m_tree->get(   node_id); }
+
+    inline bool has_all(flag_t f) const { return (m_state->flags & f) == f; }
+    inline bool has_any(flag_t f) const { return (m_state->flags & f) != 0; }
+    inline bool has_none(flag_t f) const { return (m_state->flags & f) == 0; }
+
+    static inline bool has_all(flag_t f, State const* s) { return (s->flags & f) == f; }
+    static inline bool has_any(flag_t f, State const* s) { return (s->flags & f) != 0; }
+    static inline bool has_none(flag_t f, State const* s) { return (s->flags & f) == 0; }
+
+    inline void set_flags(flag_t f) { set_flags(f, m_state); }
+    inline void add_flags(flag_t on) { add_flags(on, m_state); }
+    inline void addrem_flags(flag_t on, flag_t off) { addrem_flags(on, off, m_state); }
+    inline void rem_flags(flag_t off) { rem_flags(off, m_state); }
+
+    void set_flags(flag_t f, State * s);
+    void add_flags(flag_t on, State * s);
+    void addrem_flags(flag_t on, flag_t off, State * s);
+    void rem_flags(flag_t off, State * s);
+
+    void _resize_filter_arena(size_t num_characters);
+    void _grow_filter_arena(size_t num_characters);
+    substr _finish_filter_arena(substr dst, size_t pos);
+
+    void _prepare_locations() const;         // only changes mutable members
+    void _resize_locations(size_t sz) const; // only changes mutable members
+    void _mark_locations_dirty();
+    bool _locations_dirty() const;
+
+private:
+
+    void _free();
+    void _clr();
+    void _cp(Parser const* that);
+    void _mv(Parser *that);
+
+#ifdef RYML_DBG
+    template<class ...Args> void _dbg(csubstr fmt, Args const& C4_RESTRICT ...args) const;
+#endif
+    template<class ...Args> void _err(csubstr fmt, Args const& C4_RESTRICT ...args) const;
+    template<class DumpFn>  void _fmt_msg(DumpFn &&dumpfn) const;
+    static csubstr _prfl(substr buf, flag_t v);
+
+private:
+
+    csubstr m_file;
+     substr m_buf;
+
+    size_t  m_root_id;
+    Tree *  m_tree;
+
+    detail::stack<State> m_stack;
+    State * m_state;
+
+    size_t  m_key_tag_indentation;
+    size_t  m_key_tag2_indentation;
+    csubstr m_key_tag;
+    csubstr m_key_tag2;
+    size_t  m_val_tag_indentation;
+    csubstr m_val_tag;
+
+    bool    m_key_anchor_was_before;
+    size_t  m_key_anchor_indentation;
+    csubstr m_key_anchor;
+    size_t  m_val_anchor_indentation;
+    csubstr m_val_anchor;
+
+    substr m_filter_arena;
+
+    mutable size_t *m_newline_offsets;
+    mutable size_t  m_newline_offsets_size;
+    mutable size_t  m_newline_offsets_capacity;
+    mutable csubstr m_newline_offsets_buf;
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @name parse_in_place
+ *
+ * @desc parse a mutable YAML source buffer.
+ *
+ * @note These freestanding functions use a temporary parser object,
+ * and are convenience functions to easily parse YAML without the need
+ * to instantiate a separate parser. Note that some properties
+ * (notably node locations in the original source code) are only
+ * available through the parser object after it has parsed the
+ * code. If you need access to any of these properties, use
+ * Parser::parse_in_place() */
+/** @{ */
+
+inline Tree parse_in_place(                  substr yaml                         ) { Parser np; return np.parse_in_place({}      , yaml); } //!< parse in-situ a modifiable YAML source buffer.
+inline Tree parse_in_place(csubstr filename, substr yaml                         ) { Parser np; return np.parse_in_place(filename, yaml); } //!< parse in-situ a modifiable YAML source buffer, providing a filename for error messages.
+inline void parse_in_place(                  substr yaml, Tree *t                ) { Parser np; np.parse_in_place({}      , yaml, t); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer
+inline void parse_in_place(csubstr filename, substr yaml, Tree *t                ) { Parser np; np.parse_in_place(filename, yaml, t); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer, providing a filename for error messages.
+inline void parse_in_place(                  substr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_place({}      , yaml, t, node_id); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer
+inline void parse_in_place(csubstr filename, substr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_place(filename, yaml, t, node_id); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer, providing a filename for error messages.
+inline void parse_in_place(                  substr yaml, NodeRef node           ) { Parser np; np.parse_in_place({}      , yaml, node); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer
+inline void parse_in_place(csubstr filename, substr yaml, NodeRef node           ) { Parser np; np.parse_in_place(filename, yaml, node); } //!< reusing the YAML tree, parse in-situ a modifiable YAML source buffer, providing a filename for error messages.
+
+RYML_DEPRECATED("use parse_in_place() instead") inline Tree parse(                  substr yaml                         ) { Parser np; return np.parse_in_place({}      , yaml); }
+RYML_DEPRECATED("use parse_in_place() instead") inline Tree parse(csubstr filename, substr yaml                         ) { Parser np; return np.parse_in_place(filename, yaml); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(                  substr yaml, Tree *t                ) { Parser np; np.parse_in_place({}      , yaml, t); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(csubstr filename, substr yaml, Tree *t                ) { Parser np; np.parse_in_place(filename, yaml, t); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(                  substr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_place({}      , yaml, t, node_id); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(csubstr filename, substr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_place(filename, yaml, t, node_id); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(                  substr yaml, NodeRef node           ) { Parser np; np.parse_in_place({}      , yaml, node); }
+RYML_DEPRECATED("use parse_in_place() instead") inline void parse(csubstr filename, substr yaml, NodeRef node           ) { Parser np; np.parse_in_place(filename, yaml, node); }
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @name parse_in_arena
+ * @desc parse a read-only YAML source buffer, copying it first to the tree's arena.
+ *
+ * @note These freestanding functions use a temporary parser object,
+ * and are convenience functions to easily parse YAML without the need
+ * to instantiate a separate parser. Note that some properties
+ * (notably node locations in the original source code) are only
+ * available through the parser object after it has parsed the
+ * code. If you need access to any of these properties, use
+ * Parser::parse_in_arena().
+ *
+ * @note overloads receiving a substr YAML buffer are intentionally
+ * left undefined, such that calling parse_in_arena() with a substr
+ * will cause a linker error. This is to prevent an accidental
+ * copy of the source buffer to the tree's arena, because substr
+ * is implicitly convertible to csubstr. If you really intend to parse
+ * a mutable buffer in the tree's arena, convert it first to immutable
+ * by assigning the substr to a csubstr prior to calling parse_in_arena().
+ * This is not needed for parse_in_place() because csubstr is not
+ * implicitly convertible to substr. */
+/** @{ */
+
+/* READ THE NOTE ABOVE! */
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_in_arena(                  substr yaml                         );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_in_arena(csubstr filename, substr yaml                         );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(                  substr yaml, Tree *t                );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr yaml, Tree *t                );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(                  substr yaml, Tree *t, size_t node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr yaml, Tree *t, size_t node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(                  substr yaml, NodeRef node           );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr yaml, NodeRef node           );
+
+inline Tree parse_in_arena(                  csubstr yaml                         ) { Parser np; return np.parse_in_arena({}      , yaml); } //!< parse a read-only YAML source buffer, copying it first to the tree's source arena.
+inline Tree parse_in_arena(csubstr filename, csubstr yaml                         ) { Parser np; return np.parse_in_arena(filename, yaml); } //!< parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+inline void parse_in_arena(                  csubstr yaml, Tree *t                ) { Parser np; np.parse_in_arena({}      , yaml, t); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+inline void parse_in_arena(csubstr filename, csubstr yaml, Tree *t                ) { Parser np; np.parse_in_arena(filename, yaml, t); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+inline void parse_in_arena(                  csubstr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_arena({}      , yaml, t, node_id); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+inline void parse_in_arena(csubstr filename, csubstr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_arena(filename, yaml, t, node_id); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+inline void parse_in_arena(                  csubstr yaml, NodeRef node           ) { Parser np; np.parse_in_arena({}      , yaml, node); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+inline void parse_in_arena(csubstr filename, csubstr yaml, NodeRef node           ) { Parser np; np.parse_in_arena(filename, yaml, node); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+
+RYML_DEPRECATED("use parse_in_arena() instead") inline Tree parse(                  csubstr yaml                         ) { Parser np; return np.parse_in_arena({}      , yaml); } //!< parse a read-only YAML source buffer, copying it first to the tree's source arena.
+RYML_DEPRECATED("use parse_in_arena() instead") inline Tree parse(csubstr filename, csubstr yaml                         ) { Parser np; return np.parse_in_arena(filename, yaml); } //!< parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(                  csubstr yaml, Tree *t                ) { Parser np; np.parse_in_arena({}      , yaml, t); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(csubstr filename, csubstr yaml, Tree *t                ) { Parser np; np.parse_in_arena(filename, yaml, t); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(                  csubstr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_arena({}      , yaml, t, node_id); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(csubstr filename, csubstr yaml, Tree *t, size_t node_id) { Parser np; np.parse_in_arena(filename, yaml, t, node_id); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(                  csubstr yaml, NodeRef node           ) { Parser np; np.parse_in_arena({}      , yaml, node); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena.
+RYML_DEPRECATED("use parse_in_arena() instead") inline void parse(csubstr filename, csubstr yaml, NodeRef node           ) { Parser np; np.parse_in_arena(filename, yaml, node); } //!< reusing the YAML tree, parse a read-only YAML source buffer, copying it first to the tree's source arena, providing a filename for error messages.
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+#endif /* _C4_YML_PARSE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/parse.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/std/map.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/map.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_STD_MAP_HPP_
+#define _C4_YML_STD_MAP_HPP_
+
+/** @file map.hpp write/read std::map to/from a YAML tree. */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+#include <map>
+
+namespace c4 {
+namespace yml {
+
+// std::map requires child nodes in the data
+// tree hierarchy (a MAP node in ryml parlance).
+// So it should be serialized via write()/read().
+
+template<class K, class V, class Less, class Alloc>
+void write(c4::yml::NodeRef *n, std::map<K, V, Less, Alloc> const& m)
+{
+    *n |= c4::yml::MAP;
+    for(auto const& p : m)
+    {
+        auto ch = n->append_child();
+        ch << c4::yml::key(p.first);
+        ch << p.second;
+    }
+}
+
+template<class K, class V, class Less, class Alloc>
+bool read(c4::yml::NodeRef const& n, std::map<K, V, Less, Alloc> * m)
+{
+    K k{};
+    V v;
+    for(auto const ch : n)
+    {
+        ch >> c4::yml::key(k);
+        ch >> v;
+        m->emplace(std::make_pair(std::move(k), std::move(v)));
+    }
+    return true;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif // _C4_YML_STD_MAP_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/std/map.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/std/string.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/string.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_YML_STD_STRING_HPP_
+#define C4_YML_STD_STRING_HPP_
+
+/** @file string.hpp substring conversions for/from std::string */
+
+// everything we need is implemented here:
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/std/string.hpp
+//#include <c4/std/string.hpp>
+#if !defined(C4_STD_STRING_HPP_) && !defined(_C4_STD_STRING_HPP_)
+#error "amalgamate: file c4/std/string.hpp must have been included at this point"
+#endif /* C4_STD_STRING_HPP_ */
+
+
+#endif // C4_YML_STD_STRING_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/std/string.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/std/vector.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/vector.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_STD_VECTOR_HPP_
+#define _C4_YML_STD_VECTOR_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/std/vector.hpp
+//#include <c4/std/vector.hpp>
+#if !defined(C4_STD_VECTOR_HPP_) && !defined(_C4_STD_VECTOR_HPP_)
+#error "amalgamate: file c4/std/vector.hpp must have been included at this point"
+#endif /* C4_STD_VECTOR_HPP_ */
+
+//included above:
+//#include <vector>
+
+namespace c4 {
+namespace yml {
+
+// vector is a sequence-like type, and it requires child nodes
+// in the data tree hierarchy (a SEQ node in ryml parlance).
+// So it should be serialized via write()/read().
+
+template<class V, class Alloc>
+void write(c4::yml::NodeRef *n, std::vector<V, Alloc> const& vec)
+{
+    *n |= c4::yml::SEQ;
+    for(auto const& v : vec)
+    {
+        n->append_child() << v;
+    }
+}
+
+template<class V, class Alloc>
+bool read(c4::yml::NodeRef const& n, std::vector<V, Alloc> *vec)
+{
+    vec->resize(n.num_children());
+    size_t pos = 0;
+    for(auto const ch : n)
+    {
+        ch >> (*vec)[pos++];
+    }
+    return true;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif // _C4_YML_STD_VECTOR_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/std/vector.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/std/std.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/std.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_STD_STD_HPP_
+#define _C4_YML_STD_STD_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/string.hpp
+//#include "c4/yml/std/string.hpp"
+#if !defined(C4_YML_STD_STRING_HPP_) && !defined(_C4_YML_STD_STRING_HPP_)
+#error "amalgamate: file c4/yml/std/string.hpp must have been included at this point"
+#endif /* C4_YML_STD_STRING_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/vector.hpp
+//#include "c4/yml/std/vector.hpp"
+#if !defined(C4_YML_STD_VECTOR_HPP_) && !defined(_C4_YML_STD_VECTOR_HPP_)
+#error "amalgamate: file c4/yml/std/vector.hpp must have been included at this point"
+#endif /* C4_YML_STD_VECTOR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/std/map.hpp
+//#include "c4/yml/std/map.hpp"
+#if !defined(C4_YML_STD_MAP_HPP_) && !defined(_C4_YML_STD_MAP_HPP_)
+#error "amalgamate: file c4/yml/std/map.hpp must have been included at this point"
+#endif /* C4_YML_STD_MAP_HPP_ */
+
+
+#endif // _C4_YML_STD_STD_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/std/std.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/common.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/common.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/common.hpp
+//#include "c4/yml/common.hpp"
+#if !defined(C4_YML_COMMON_HPP_) && !defined(_C4_YML_COMMON_HPP_)
+#error "amalgamate: file c4/yml/common.hpp must have been included at this point"
+#endif /* C4_YML_COMMON_HPP_ */
+
+
+#ifndef RYML_NO_DEFAULT_CALLBACKS
+//included above:
+//#   include <stdlib.h>
+//included above:
+//#   include <stdio.h>
+#endif // RYML_NO_DEFAULT_CALLBACKS
+
+namespace c4 {
+namespace yml {
+
+namespace {
+thread_local Callbacks s_default_callbacks;
+} // anon namespace
+
+#ifndef RYML_NO_DEFAULT_CALLBACKS
+void report_error_impl(const char* msg, size_t length, Location loc, FILE *f)
+{
+    if(!f)
+        f = stderr;
+    if(loc)
+    {
+        if(!loc.name.empty())
+        {
+            fwrite(loc.name.str, 1, loc.name.len, f);
+            fputc(':', f);
+        }
+        fprintf(f, "%zu:", loc.line);
+        if(loc.col)
+            fprintf(f, "%zu:", loc.col);
+        if(loc.offset)
+            fprintf(f, " (%zuB):", loc.offset);
+    }
+    fprintf(f, "%.*s\n", (int)length, msg);
+    fflush(f);
+}
+
+void error_impl(const char* msg, size_t length, Location loc, void * /*user_data*/)
+{
+    report_error_impl(msg, length, loc, nullptr);
+    ::abort();
+}
+
+void* allocate_impl(size_t length, void * /*hint*/, void * /*user_data*/)
+{
+    void *mem = ::malloc(length);
+    if(mem == nullptr)
+    {
+        const char msg[] = "could not allocate memory";
+        error_impl(msg, sizeof(msg)-1, {}, nullptr);
+    }
+    return mem;
+}
+
+void free_impl(void *mem, size_t /*length*/, void * /*user_data*/)
+{
+    ::free(mem);
+}
+#endif // RYML_NO_DEFAULT_CALLBACKS
+
+
+
+Callbacks::Callbacks()
+    :
+    m_user_data(nullptr),
+    #ifndef RYML_NO_DEFAULT_CALLBACKS
+    m_allocate(allocate_impl),
+    m_free(free_impl),
+    m_error(error_impl)
+    #else
+    m_allocate(nullptr),
+    m_free(nullptr),
+    m_error(nullptr)
+    #endif
+{
+}
+
+Callbacks::Callbacks(void *user_data, pfn_allocate alloc_, pfn_free free_, pfn_error error_)
+    :
+    m_user_data(user_data),
+    #ifndef RYML_NO_DEFAULT_CALLBACKS
+    m_allocate(alloc_ ? alloc_ : allocate_impl),
+    m_free(free_ ? free_ : free_impl),
+    m_error(error_ ? error_ : error_impl)
+    #else
+    m_allocate(alloc_),
+    m_free(free_),
+    m_error(error_)
+    #endif
+{
+    C4_CHECK(m_allocate);
+    C4_CHECK(m_free);
+    C4_CHECK(m_error);
+}
+
+
+void set_callbacks(Callbacks const& c)
+{
+    s_default_callbacks = c;
+}
+
+Callbacks const& get_callbacks()
+{
+    return s_default_callbacks;
+}
+
+void reset_callbacks()
+{
+    set_callbacks(Callbacks());
+}
+
+void error(const char *msg, size_t msg_len, Location loc)
+{
+    s_default_callbacks.m_error(msg, msg_len, loc, s_default_callbacks.m_user_data);
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/common.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/tree.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/parser_dbg.hpp
+//#include "c4/yml/detail/parser_dbg.hpp"
+#if !defined(C4_YML_DETAIL_PARSER_DBG_HPP_) && !defined(_C4_YML_DETAIL_PARSER_DBG_HPP_)
+#error "amalgamate: file c4/yml/detail/parser_dbg.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_PARSER_DBG_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/stack.hpp
+//#include "c4/yml/detail/stack.hpp"
+#if !defined(C4_YML_DETAIL_STACK_HPP_) && !defined(_C4_YML_DETAIL_STACK_HPP_)
+#error "amalgamate: file c4/yml/detail/stack.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_STACK_HPP_ */
+
+
+
+C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wtype-limits")
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4296/*expression is always 'boolean_value'*/)
+
+namespace c4 {
+namespace yml {
+
+
+csubstr normalize_tag(csubstr tag)
+{
+    YamlTag_e t = to_tag(tag);
+    if(t != TAG_NONE)
+        return from_tag(t);
+    if(tag.begins_with("!<"))
+        tag = tag.sub(1);
+    if(tag.begins_with("<!"))
+        return tag;
+    return tag;
+}
+
+csubstr normalize_tag_long(csubstr tag)
+{
+    YamlTag_e t = to_tag(tag);
+    if(t != TAG_NONE)
+        return from_tag_long(t);
+    if(tag.begins_with("!<"))
+        tag = tag.sub(1);
+    if(tag.begins_with("<!"))
+        return tag;
+    return tag;
+}
+
+YamlTag_e to_tag(csubstr tag)
+{
+    if(tag.begins_with("!<"))
+        tag = tag.sub(1);
+    if(tag.begins_with("!!"))
+        tag = tag.sub(2);
+    else if(tag.begins_with('!'))
+        return TAG_NONE;
+    else if(tag.begins_with("tag:yaml.org,2002:"))
+    {
+        RYML_ASSERT(csubstr("tag:yaml.org,2002:").len == 18);
+        tag = tag.sub(18);
+    }
+    else if(tag.begins_with("<tag:yaml.org,2002:"))
+    {
+        RYML_ASSERT(csubstr("<tag:yaml.org,2002:").len == 19);
+        tag = tag.sub(19);
+        if(!tag.len)
+            return TAG_NONE;
+        tag = tag.offs(0, 1);
+    }
+
+    if(tag == "map")
+        return TAG_MAP;
+    else if(tag == "omap")
+        return TAG_OMAP;
+    else if(tag == "pairs")
+        return TAG_PAIRS;
+    else if(tag == "set")
+        return TAG_SET;
+    else if(tag == "seq")
+        return TAG_SEQ;
+    else if(tag == "binary")
+        return TAG_BINARY;
+    else if(tag == "bool")
+        return TAG_BOOL;
+    else if(tag == "float")
+        return TAG_FLOAT;
+    else if(tag == "int")
+        return TAG_INT;
+    else if(tag == "merge")
+        return TAG_MERGE;
+    else if(tag == "null")
+        return TAG_NULL;
+    else if(tag == "str")
+        return TAG_STR;
+    else if(tag == "timestamp")
+        return TAG_TIMESTAMP;
+    else if(tag == "value")
+        return TAG_VALUE;
+
+    return TAG_NONE;
+}
+
+csubstr from_tag_long(YamlTag_e tag)
+{
+    switch(tag)
+    {
+    case TAG_MAP:
+        return {"<tag:yaml.org,2002:map>"};
+    case TAG_OMAP:
+        return {"<tag:yaml.org,2002:omap>"};
+    case TAG_PAIRS:
+        return {"<tag:yaml.org,2002:pairs>"};
+    case TAG_SET:
+        return {"<tag:yaml.org,2002:set>"};
+    case TAG_SEQ:
+        return {"<tag:yaml.org,2002:seq>"};
+    case TAG_BINARY:
+        return {"<tag:yaml.org,2002:binary>"};
+    case TAG_BOOL:
+        return {"<tag:yaml.org,2002:bool>"};
+    case TAG_FLOAT:
+        return {"<tag:yaml.org,2002:float>"};
+    case TAG_INT:
+        return {"<tag:yaml.org,2002:int>"};
+    case TAG_MERGE:
+        return {"<tag:yaml.org,2002:merge>"};
+    case TAG_NULL:
+        return {"<tag:yaml.org,2002:null>"};
+    case TAG_STR:
+        return {"<tag:yaml.org,2002:str>"};
+    case TAG_TIMESTAMP:
+        return {"<tag:yaml.org,2002:timestamp>"};
+    case TAG_VALUE:
+        return {"<tag:yaml.org,2002:value>"};
+    case TAG_YAML:
+        return {"<tag:yaml.org,2002:yaml>"};
+    case TAG_NONE:
+        return {""};
+    }
+    return {""};
+}
+
+csubstr from_tag(YamlTag_e tag)
+{
+    switch(tag)
+    {
+    case TAG_MAP:
+        return {"!!map"};
+    case TAG_OMAP:
+        return {"!!omap"};
+    case TAG_PAIRS:
+        return {"!!pairs"};
+    case TAG_SET:
+        return {"!!set"};
+    case TAG_SEQ:
+        return {"!!seq"};
+    case TAG_BINARY:
+        return {"!!binary"};
+    case TAG_BOOL:
+        return {"!!bool"};
+    case TAG_FLOAT:
+        return {"!!float"};
+    case TAG_INT:
+        return {"!!int"};
+    case TAG_MERGE:
+        return {"!!merge"};
+    case TAG_NULL:
+        return {"!!null"};
+    case TAG_STR:
+        return {"!!str"};
+    case TAG_TIMESTAMP:
+        return {"!!timestamp"};
+    case TAG_VALUE:
+        return {"!!value"};
+    case TAG_YAML:
+        return {"!!yaml"};
+    case TAG_NONE:
+        return {""};
+    }
+    return {""};
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+const char* NodeType::type_str(NodeType_e ty)
+{
+    switch(ty & _TYMASK)
+    {
+    case KEYVAL:
+        return "KEYVAL";
+    case KEY:
+        return "KEY";
+    case VAL:
+        return "VAL";
+    case MAP:
+        return "MAP";
+    case SEQ:
+        return "SEQ";
+    case KEYMAP:
+        return "KEYMAP";
+    case KEYSEQ:
+        return "KEYSEQ";
+    case DOCSEQ:
+        return "DOCSEQ";
+    case DOCMAP:
+        return "DOCMAP";
+    case DOCVAL:
+        return "DOCVAL";
+    case DOC:
+        return "DOC";
+    case STREAM:
+        return "STREAM";
+    case NOTYPE:
+        return "NOTYPE";
+    default:
+        if((ty & KEYVAL) == KEYVAL)
+            return "KEYVAL***";
+        if((ty & KEYMAP) == KEYMAP)
+            return "KEYMAP***";
+        if((ty & KEYSEQ) == KEYSEQ)
+            return "KEYSEQ***";
+        if((ty & DOCSEQ) == DOCSEQ)
+            return "DOCSEQ***";
+        if((ty & DOCMAP) == DOCMAP)
+            return "DOCMAP***";
+        if((ty & DOCVAL) == DOCVAL)
+            return "DOCVAL***";
+        if(ty & KEY)
+            return "KEY***";
+        if(ty & VAL)
+            return "VAL***";
+        if(ty & MAP)
+            return "MAP***";
+        if(ty & SEQ)
+            return "SEQ***";
+        if(ty & DOC)
+            return "DOC***";
+        return "(unk)";
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+NodeRef Tree::rootref()
+{
+    return NodeRef(this, root_id());
+}
+NodeRef const Tree::rootref() const
+{
+    return NodeRef(const_cast<Tree*>(this), root_id());
+}
+
+NodeRef Tree::ref(size_t id)
+{
+    _RYML_CB_ASSERT(m_callbacks, id != NONE && id >= 0 && id < m_size);
+    return NodeRef(this, id);
+}
+NodeRef const Tree::ref(size_t id) const
+{
+    _RYML_CB_ASSERT(m_callbacks, id != NONE && id >= 0 && id < m_size);
+    return NodeRef(const_cast<Tree*>(this), id);
+}
+
+NodeRef Tree::operator[] (csubstr key)
+{
+    return rootref()[key];
+}
+NodeRef const Tree::operator[] (csubstr key) const
+{
+    return rootref()[key];
+}
+
+NodeRef Tree::operator[] (size_t i)
+{
+    return rootref()[i];
+}
+NodeRef const Tree::operator[] (size_t i) const
+{
+    return rootref()[i];
+}
+
+NodeRef Tree::docref(size_t i)
+{
+    return ref(doc(i));
+}
+NodeRef const Tree::docref(size_t i) const
+{
+    return ref(doc(i));
+}
+
+
+//-----------------------------------------------------------------------------
+Tree::Tree(Callbacks const& cb)
+    : m_buf(nullptr)
+    , m_cap(0)
+    , m_size(0)
+    , m_free_head(NONE)
+    , m_free_tail(NONE)
+    , m_arena()
+    , m_arena_pos(0)
+    , m_callbacks(cb)
+{
+}
+
+Tree::Tree(size_t node_capacity, size_t arena_capacity, Callbacks const& cb)
+    : Tree(cb)
+{
+    reserve(node_capacity);
+    reserve_arena(arena_capacity);
+}
+
+Tree::~Tree()
+{
+    _free();
+}
+
+
+Tree::Tree(Tree const& that) noexcept : Tree(that.m_callbacks)
+{
+    _copy(that);
+}
+
+Tree& Tree::operator= (Tree const& that) noexcept
+{
+    _free();
+    m_callbacks = that.m_callbacks;
+    _copy(that);
+    return *this;
+}
+
+Tree::Tree(Tree && that) noexcept : Tree(that.m_callbacks)
+{
+    _move(that);
+}
+
+Tree& Tree::operator= (Tree && that) noexcept
+{
+    _free();
+    m_callbacks = that.m_callbacks;
+    _move(that);
+    return *this;
+}
+
+void Tree::_free()
+{
+    if(m_buf)
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_cap > 0);
+        _RYML_CB_FREE(m_callbacks, m_buf, NodeData, m_cap);
+    }
+    if(m_arena.str)
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_arena.len > 0);
+        _RYML_CB_FREE(m_callbacks, m_arena.str, char, m_arena.len);
+    }
+    _clear();
+}
+
+
+C4_SUPPRESS_WARNING_GCC_PUSH
+#if defined(__GNUC__) && __GNUC__>= 8
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wclass-memaccess") // error: ‘void* memset(void*, int, size_t)’ clearing an object of type ‘class c4::yml::Tree’ with no trivial copy-assignment; use assignment or value-initialization instead
+#endif
+
+void Tree::_clear()
+{
+    m_buf = nullptr;
+    m_cap = 0;
+    m_size = 0;
+    m_free_head = 0;
+    m_free_tail = 0;
+    m_arena = {};
+    m_arena_pos = 0;
+    for(size_t i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = {};
+}
+
+void Tree::_copy(Tree const& that)
+{
+    _RYML_CB_ASSERT(m_callbacks, m_buf == nullptr);
+    _RYML_CB_ASSERT(m_callbacks, m_arena.str == nullptr);
+    _RYML_CB_ASSERT(m_callbacks, m_arena.len == 0);
+    m_buf = _RYML_CB_ALLOC_HINT(m_callbacks, NodeData, that.m_cap, that.m_buf);
+    memcpy(m_buf, that.m_buf, that.m_cap * sizeof(NodeData));
+    m_cap = that.m_cap;
+    m_size = that.m_size;
+    m_free_head = that.m_free_head;
+    m_free_tail = that.m_free_tail;
+    m_arena_pos = that.m_arena_pos;
+    m_arena = that.m_arena;
+    if(that.m_arena.str)
+    {
+        _RYML_CB_ASSERT(m_callbacks, that.m_arena.len > 0);
+        substr arena;
+        arena.str = _RYML_CB_ALLOC_HINT(m_callbacks, char, that.m_arena.len, that.m_arena.str);
+        arena.len = that.m_arena.len;
+        _relocate(arena); // does a memcpy of the arena and updates nodes using the old arena
+        m_arena = arena;
+    }
+    for(size_t i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = that.m_tag_directives[i];
+}
+
+void Tree::_move(Tree & that)
+{
+    _RYML_CB_ASSERT(m_callbacks, m_buf == nullptr);
+    _RYML_CB_ASSERT(m_callbacks, m_arena.str == nullptr);
+    _RYML_CB_ASSERT(m_callbacks, m_arena.len == 0);
+    m_buf = that.m_buf;
+    m_cap = that.m_cap;
+    m_size = that.m_size;
+    m_free_head = that.m_free_head;
+    m_free_tail = that.m_free_tail;
+    m_arena = that.m_arena;
+    m_arena_pos = that.m_arena_pos;
+    for(size_t i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = that.m_tag_directives[i];
+    that._clear();
+}
+
+void Tree::_relocate(substr next_arena)
+{
+    _RYML_CB_ASSERT(m_callbacks, next_arena.not_empty());
+    _RYML_CB_ASSERT(m_callbacks, next_arena.len >= m_arena.len);
+    memcpy(next_arena.str, m_arena.str, m_arena_pos);
+    for(NodeData *C4_RESTRICT n = m_buf, *e = m_buf + m_cap; n != e; ++n)
+    {
+        if(in_arena(n->m_key.scalar))
+            n->m_key.scalar = _relocated(n->m_key.scalar, next_arena);
+        if(in_arena(n->m_key.tag))
+            n->m_key.tag = _relocated(n->m_key.tag, next_arena);
+        if(in_arena(n->m_key.anchor))
+            n->m_key.anchor = _relocated(n->m_key.anchor, next_arena);
+        if(in_arena(n->m_val.scalar))
+            n->m_val.scalar = _relocated(n->m_val.scalar, next_arena);
+        if(in_arena(n->m_val.tag))
+            n->m_val.tag = _relocated(n->m_val.tag, next_arena);
+        if(in_arena(n->m_val.anchor))
+            n->m_val.anchor = _relocated(n->m_val.anchor, next_arena);
+    }
+    for(TagDirective &C4_RESTRICT td : m_tag_directives)
+    {
+        if(in_arena(td.prefix))
+            td.prefix = _relocated(td.prefix, next_arena);
+        if(in_arena(td.handle))
+            td.handle = _relocated(td.handle, next_arena);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+void Tree::reserve(size_t cap)
+{
+    if(cap > m_cap)
+    {
+        NodeData *buf = _RYML_CB_ALLOC_HINT(m_callbacks, NodeData, cap, m_buf);
+        if(m_buf)
+        {
+            memcpy(buf, m_buf, m_cap * sizeof(NodeData));
+            _RYML_CB_FREE(m_callbacks, m_buf, NodeData, m_cap);
+        }
+        size_t first = m_cap, del = cap - m_cap;
+        m_cap = cap;
+        m_buf = buf;
+        _clear_range(first, del);
+        if(m_free_head != NONE)
+        {
+            _RYML_CB_ASSERT(m_callbacks, m_buf != nullptr);
+            _RYML_CB_ASSERT(m_callbacks, m_free_tail != NONE);
+            m_buf[m_free_tail].m_next_sibling = first;
+            m_buf[first].m_prev_sibling = m_free_tail;
+            m_free_tail = cap-1;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_callbacks, m_free_tail == NONE);
+            m_free_head = first;
+            m_free_tail = cap-1;
+        }
+        _RYML_CB_ASSERT(m_callbacks, m_free_head == NONE || (m_free_head >= 0 && m_free_head < cap));
+        _RYML_CB_ASSERT(m_callbacks, m_free_tail == NONE || (m_free_tail >= 0 && m_free_tail < cap));
+
+        if( ! m_size)
+            _claim_root();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+void Tree::clear()
+{
+    _clear_range(0, m_cap);
+    m_size = 0;
+    if(m_buf)
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_cap >= 0);
+        m_free_head = 0;
+        m_free_tail = m_cap-1;
+        _claim_root();
+    }
+    else
+    {
+        m_free_head = NONE;
+        m_free_tail = NONE;
+    }
+    for(size_t i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = {};
+}
+
+void Tree::_claim_root()
+{
+    size_t r = _claim();
+    _RYML_CB_ASSERT(m_callbacks, r == 0);
+    _set_hierarchy(r, NONE, NONE);
+}
+
+
+//-----------------------------------------------------------------------------
+void Tree::_clear_range(size_t first, size_t num)
+{
+    if(num == 0)
+        return; // prevent overflow when subtracting
+    _RYML_CB_ASSERT(m_callbacks, first >= 0 && first + num <= m_cap);
+    memset(m_buf + first, 0, num * sizeof(NodeData)); // TODO we should not need this
+    for(size_t i = first, e = first + num; i < e; ++i)
+    {
+        _clear(i);
+        NodeData *n = m_buf + i;
+        n->m_prev_sibling = i - 1;
+        n->m_next_sibling = i + 1;
+    }
+    m_buf[first + num - 1].m_next_sibling = NONE;
+}
+
+C4_SUPPRESS_WARNING_GCC_POP
+
+
+//-----------------------------------------------------------------------------
+void Tree::_release(size_t i)
+{
+    _RYML_CB_ASSERT(m_callbacks, i >= 0 && i < m_cap);
+
+    _rem_hierarchy(i);
+    _free_list_add(i);
+    _clear(i);
+
+    --m_size;
+}
+
+//-----------------------------------------------------------------------------
+// add to the front of the free list
+void Tree::_free_list_add(size_t i)
+{
+    _RYML_CB_ASSERT(m_callbacks, i >= 0 && i < m_cap);
+    NodeData &C4_RESTRICT w = m_buf[i];
+
+    w.m_parent = NONE;
+    w.m_next_sibling = m_free_head;
+    w.m_prev_sibling = NONE;
+    if(m_free_head != NONE)
+        m_buf[m_free_head].m_prev_sibling = i;
+    m_free_head = i;
+    if(m_free_tail == NONE)
+        m_free_tail = m_free_head;
+}
+
+void Tree::_free_list_rem(size_t i)
+{
+    if(m_free_head == i)
+        m_free_head = _p(i)->m_next_sibling;
+    _rem_hierarchy(i);
+}
+
+//-----------------------------------------------------------------------------
+size_t Tree::_claim()
+{
+    if(m_free_head == NONE || m_buf == nullptr)
+    {
+        size_t sz = 2 * m_cap;
+        sz = sz ? sz : 16;
+        reserve(sz);
+        _RYML_CB_ASSERT(m_callbacks, m_free_head != NONE);
+    }
+
+    _RYML_CB_ASSERT(m_callbacks, m_size < m_cap);
+    _RYML_CB_ASSERT(m_callbacks, m_free_head >= 0 && m_free_head < m_cap);
+
+    size_t ichild = m_free_head;
+    NodeData *child = m_buf + ichild;
+
+    ++m_size;
+    m_free_head = child->m_next_sibling;
+    if(m_free_head == NONE)
+    {
+        m_free_tail = NONE;
+        _RYML_CB_ASSERT(m_callbacks, m_size == m_cap);
+    }
+
+    _clear(ichild);
+
+    return ichild;
+}
+
+//-----------------------------------------------------------------------------
+
+C4_SUPPRESS_WARNING_GCC_PUSH
+C4_SUPPRESS_WARNING_CLANG_PUSH
+C4_SUPPRESS_WARNING_CLANG("-Wnull-dereference")
+#if defined(__GNUC__) && (__GNUC__ >= 6)
+C4_SUPPRESS_WARNING_GCC("-Wnull-dereference")
+#endif
+
+void Tree::_set_hierarchy(size_t ichild, size_t iparent, size_t iprev_sibling)
+{
+    _RYML_CB_ASSERT(m_callbacks, iparent == NONE || (iparent >= 0 && iparent < m_cap));
+    _RYML_CB_ASSERT(m_callbacks, iprev_sibling == NONE || (iprev_sibling >= 0 && iprev_sibling < m_cap));
+
+    NodeData *C4_RESTRICT child = get(ichild);
+
+    child->m_parent = iparent;
+    child->m_prev_sibling = NONE;
+    child->m_next_sibling = NONE;
+
+    if(iparent == NONE)
+    {
+        _RYML_CB_ASSERT(m_callbacks, ichild == 0);
+        _RYML_CB_ASSERT(m_callbacks, iprev_sibling == NONE);
+    }
+
+    if(iparent == NONE)
+        return;
+
+    size_t inext_sibling = iprev_sibling != NONE ? next_sibling(iprev_sibling) : first_child(iparent);
+    NodeData *C4_RESTRICT parent = get(iparent);
+    NodeData *C4_RESTRICT psib   = get(iprev_sibling);
+    NodeData *C4_RESTRICT nsib   = get(inext_sibling);
+
+    if(psib)
+    {
+        _RYML_CB_ASSERT(m_callbacks, next_sibling(iprev_sibling) == id(nsib));
+        child->m_prev_sibling = id(psib);
+        psib->m_next_sibling = id(child);
+        _RYML_CB_ASSERT(m_callbacks, psib->m_prev_sibling != psib->m_next_sibling || psib->m_prev_sibling == NONE);
+    }
+
+    if(nsib)
+    {
+        _RYML_CB_ASSERT(m_callbacks, prev_sibling(inext_sibling) == id(psib));
+        child->m_next_sibling = id(nsib);
+        nsib->m_prev_sibling = id(child);
+        _RYML_CB_ASSERT(m_callbacks, nsib->m_prev_sibling != nsib->m_next_sibling || nsib->m_prev_sibling == NONE);
+    }
+
+    if(parent->m_first_child == NONE)
+    {
+        _RYML_CB_ASSERT(m_callbacks, parent->m_last_child == NONE);
+        parent->m_first_child = id(child);
+        parent->m_last_child = id(child);
+    }
+    else
+    {
+        if(child->m_next_sibling == parent->m_first_child)
+            parent->m_first_child = id(child);
+
+        if(child->m_prev_sibling == parent->m_last_child)
+            parent->m_last_child = id(child);
+    }
+}
+
+C4_SUPPRESS_WARNING_GCC_POP
+C4_SUPPRESS_WARNING_CLANG_POP
+
+
+//-----------------------------------------------------------------------------
+void Tree::_rem_hierarchy(size_t i)
+{
+    _RYML_CB_ASSERT(m_callbacks, i >= 0 && i < m_cap);
+
+    NodeData &C4_RESTRICT w = m_buf[i];
+
+    // remove from the parent
+    if(w.m_parent != NONE)
+    {
+        NodeData &C4_RESTRICT p = m_buf[w.m_parent];
+        if(p.m_first_child == i)
+        {
+            p.m_first_child = w.m_next_sibling;
+        }
+        if(p.m_last_child == i)
+        {
+            p.m_last_child = w.m_prev_sibling;
+        }
+    }
+
+    // remove from the used list
+    if(w.m_prev_sibling != NONE)
+    {
+        NodeData *C4_RESTRICT prev = get(w.m_prev_sibling);
+        prev->m_next_sibling = w.m_next_sibling;
+    }
+    if(w.m_next_sibling != NONE)
+    {
+        NodeData *C4_RESTRICT next = get(w.m_next_sibling);
+        next->m_prev_sibling = w.m_prev_sibling;
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Tree::reorder()
+{
+    size_t r = root_id();
+    _do_reorder(&r, 0);
+}
+
+//-----------------------------------------------------------------------------
+size_t Tree::_do_reorder(size_t *node, size_t count)
+{
+    // swap this node if it's not in place
+    if(*node != count)
+    {
+        _swap(*node, count);
+        *node = count;
+    }
+    ++count; // bump the count from this node
+
+    // now descend in the hierarchy
+    for(size_t i = first_child(*node); i != NONE; i = next_sibling(i))
+    {
+        // this child may have been relocated to a different index,
+        // so get an updated version
+        count = _do_reorder(&i, count);
+    }
+    return count;
+}
+
+//-----------------------------------------------------------------------------
+void Tree::_swap(size_t n_, size_t m_)
+{
+    _RYML_CB_ASSERT(m_callbacks, (parent(n_) != NONE) || type(n_) == NOTYPE);
+    _RYML_CB_ASSERT(m_callbacks, (parent(m_) != NONE) || type(m_) == NOTYPE);
+    NodeType tn = type(n_);
+    NodeType tm = type(m_);
+    if(tn != NOTYPE && tm != NOTYPE)
+    {
+        _swap_props(n_, m_);
+        _swap_hierarchy(n_, m_);
+    }
+    else if(tn == NOTYPE && tm != NOTYPE)
+    {
+        _copy_props(n_, m_);
+        _free_list_rem(n_);
+        _copy_hierarchy(n_, m_);
+        _clear(m_);
+        _free_list_add(m_);
+    }
+    else if(tn != NOTYPE && tm == NOTYPE)
+    {
+        _copy_props(m_, n_);
+        _free_list_rem(m_);
+        _copy_hierarchy(m_, n_);
+        _clear(n_);
+        _free_list_add(n_);
+    }
+    else
+    {
+        C4_NEVER_REACH();
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Tree::_swap_hierarchy(size_t ia, size_t ib)
+{
+    if(ia == ib) return;
+
+    for(size_t i = first_child(ia); i != NONE; i = next_sibling(i))
+    {
+        if(i == ib || i == ia)
+            continue;
+        _p(i)->m_parent = ib;
+    }
+
+    for(size_t i = first_child(ib); i != NONE; i = next_sibling(i))
+    {
+        if(i == ib || i == ia)
+            continue;
+        _p(i)->m_parent = ia;
+    }
+
+    auto & C4_RESTRICT a  = *_p(ia);
+    auto & C4_RESTRICT b  = *_p(ib);
+    auto & C4_RESTRICT pa = *_p(a.m_parent);
+    auto & C4_RESTRICT pb = *_p(b.m_parent);
+
+    if(&pa == &pb)
+    {
+        if((pa.m_first_child == ib && pa.m_last_child == ia)
+            ||
+           (pa.m_first_child == ia && pa.m_last_child == ib))
+        {
+            std::swap(pa.m_first_child, pa.m_last_child);
+        }
+        else
+        {
+            bool changed = false;
+            if(pa.m_first_child == ia)
+            {
+                pa.m_first_child = ib;
+                changed = true;
+            }
+            if(pa.m_last_child  == ia)
+            {
+                pa.m_last_child = ib;
+                changed = true;
+            }
+            if(pb.m_first_child == ib && !changed)
+            {
+                pb.m_first_child = ia;
+            }
+            if(pb.m_last_child  == ib && !changed)
+            {
+                pb.m_last_child  = ia;
+            }
+        }
+    }
+    else
+    {
+        if(pa.m_first_child == ia)
+            pa.m_first_child = ib;
+        if(pa.m_last_child  == ia)
+            pa.m_last_child  = ib;
+        if(pb.m_first_child == ib)
+            pb.m_first_child = ia;
+        if(pb.m_last_child  == ib)
+            pb.m_last_child  = ia;
+    }
+    std::swap(a.m_first_child , b.m_first_child);
+    std::swap(a.m_last_child  , b.m_last_child);
+
+    if(a.m_prev_sibling != ib && b.m_prev_sibling != ia &&
+       a.m_next_sibling != ib && b.m_next_sibling != ia)
+    {
+        if(a.m_prev_sibling != NONE && a.m_prev_sibling != ib)
+            _p(a.m_prev_sibling)->m_next_sibling = ib;
+        if(a.m_next_sibling != NONE && a.m_next_sibling != ib)
+            _p(a.m_next_sibling)->m_prev_sibling = ib;
+        if(b.m_prev_sibling != NONE && b.m_prev_sibling != ia)
+            _p(b.m_prev_sibling)->m_next_sibling = ia;
+        if(b.m_next_sibling != NONE && b.m_next_sibling != ia)
+            _p(b.m_next_sibling)->m_prev_sibling = ia;
+        std::swap(a.m_prev_sibling, b.m_prev_sibling);
+        std::swap(a.m_next_sibling, b.m_next_sibling);
+    }
+    else
+    {
+        if(a.m_next_sibling == ib) // n will go after m
+        {
+            _RYML_CB_ASSERT(m_callbacks, b.m_prev_sibling == ia);
+            if(a.m_prev_sibling != NONE)
+            {
+                _RYML_CB_ASSERT(m_callbacks, a.m_prev_sibling != ib);
+                _p(a.m_prev_sibling)->m_next_sibling = ib;
+            }
+            if(b.m_next_sibling != NONE)
+            {
+                _RYML_CB_ASSERT(m_callbacks, b.m_next_sibling != ia);
+                _p(b.m_next_sibling)->m_prev_sibling = ia;
+            }
+            size_t ns = b.m_next_sibling;
+            b.m_prev_sibling = a.m_prev_sibling;
+            b.m_next_sibling = ia;
+            a.m_prev_sibling = ib;
+            a.m_next_sibling = ns;
+        }
+        else if(a.m_prev_sibling == ib) // m will go after n
+        {
+            _RYML_CB_ASSERT(m_callbacks, b.m_next_sibling == ia);
+            if(b.m_prev_sibling != NONE)
+            {
+                _RYML_CB_ASSERT(m_callbacks, b.m_prev_sibling != ia);
+                _p(b.m_prev_sibling)->m_next_sibling = ia;
+            }
+            if(a.m_next_sibling != NONE)
+            {
+                _RYML_CB_ASSERT(m_callbacks, a.m_next_sibling != ib);
+                _p(a.m_next_sibling)->m_prev_sibling = ib;
+            }
+            size_t ns = b.m_prev_sibling;
+            a.m_prev_sibling = b.m_prev_sibling;
+            a.m_next_sibling = ib;
+            b.m_prev_sibling = ia;
+            b.m_next_sibling = ns;
+        }
+        else
+        {
+            C4_NEVER_REACH();
+        }
+    }
+    _RYML_CB_ASSERT(m_callbacks, a.m_next_sibling != ia);
+    _RYML_CB_ASSERT(m_callbacks, a.m_prev_sibling != ia);
+    _RYML_CB_ASSERT(m_callbacks, b.m_next_sibling != ib);
+    _RYML_CB_ASSERT(m_callbacks, b.m_prev_sibling != ib);
+
+    if(a.m_parent != ib && b.m_parent != ia)
+    {
+        std::swap(a.m_parent, b.m_parent);
+    }
+    else
+    {
+        if(a.m_parent == ib && b.m_parent != ia)
+        {
+            a.m_parent = b.m_parent;
+            b.m_parent = ia;
+        }
+        else if(a.m_parent != ib && b.m_parent == ia)
+        {
+            b.m_parent = a.m_parent;
+            a.m_parent = ib;
+        }
+        else
+        {
+            C4_NEVER_REACH();
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Tree::_copy_hierarchy(size_t dst_, size_t src_)
+{
+    auto const& C4_RESTRICT src = *_p(src_);
+    auto      & C4_RESTRICT dst = *_p(dst_);
+    auto      & C4_RESTRICT prt = *_p(src.m_parent);
+    for(size_t i = src.m_first_child; i != NONE; i = next_sibling(i))
+    {
+        _p(i)->m_parent = dst_;
+    }
+    if(src.m_prev_sibling != NONE)
+    {
+        _p(src.m_prev_sibling)->m_next_sibling = dst_;
+    }
+    if(src.m_next_sibling != NONE)
+    {
+        _p(src.m_next_sibling)->m_prev_sibling = dst_;
+    }
+    if(prt.m_first_child == src_)
+    {
+        prt.m_first_child = dst_;
+    }
+    if(prt.m_last_child  == src_)
+    {
+        prt.m_last_child  = dst_;
+    }
+    dst.m_parent       = src.m_parent;
+    dst.m_first_child  = src.m_first_child;
+    dst.m_last_child   = src.m_last_child;
+    dst.m_prev_sibling = src.m_prev_sibling;
+    dst.m_next_sibling = src.m_next_sibling;
+}
+
+//-----------------------------------------------------------------------------
+void Tree::_swap_props(size_t n_, size_t m_)
+{
+    NodeData &C4_RESTRICT n = *_p(n_);
+    NodeData &C4_RESTRICT m = *_p(m_);
+    std::swap(n.m_type, m.m_type);
+    std::swap(n.m_key, m.m_key);
+    std::swap(n.m_val, m.m_val);
+}
+
+//-----------------------------------------------------------------------------
+void Tree::move(size_t node, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks,  ! is_root(node));
+    _RYML_CB_ASSERT(m_callbacks, has_sibling(node, after) && has_sibling(after, node));
+
+    _rem_hierarchy(node);
+    _set_hierarchy(node, parent(node), after);
+}
+
+//-----------------------------------------------------------------------------
+
+void Tree::move(size_t node, size_t new_parent, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks,  ! is_root(node));
+
+    _rem_hierarchy(node);
+    _set_hierarchy(node, new_parent, after);
+}
+
+size_t Tree::move(Tree *src, size_t node, size_t new_parent, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != NONE);
+
+    size_t dup = duplicate(src, node, new_parent, after);
+    src->remove(node);
+    return dup;
+}
+
+void Tree::set_root_as_stream()
+{
+    size_t root = root_id();
+    if(is_stream(root))
+        return;
+    // don't use _add_flags() because it's checked and will fail
+    if(!has_children(root))
+    {
+        if(is_val(root))
+        {
+            _p(root)->m_type.add(SEQ);
+            size_t next_doc = append_child(root);
+            _copy_props_wo_key(next_doc, root);
+            _p(next_doc)->m_type.add(DOC);
+            _p(next_doc)->m_type.rem(SEQ);
+        }
+        _p(root)->m_type = STREAM;
+        return;
+    }
+    _RYML_CB_ASSERT(m_callbacks, !has_key(root));
+    size_t next_doc = append_child(root);
+    _copy_props_wo_key(next_doc, root);
+    _add_flags(next_doc, DOC);
+    for(size_t prev = NONE, ch = first_child(root), next = next_sibling(ch); ch != NONE; )
+    {
+        if(ch == next_doc)
+            break;
+        move(ch, next_doc, prev);
+        prev = ch;
+        ch = next;
+        next = next_sibling(next);
+    }
+    _p(root)->m_type = STREAM;
+}
+
+
+//-----------------------------------------------------------------------------
+void Tree::remove_children(size_t node)
+{
+    _RYML_CB_ASSERT(m_callbacks, get(node) != nullptr);
+    size_t ich = get(node)->m_first_child;
+    while(ich != NONE)
+    {
+        remove_children(ich);
+        _RYML_CB_ASSERT(m_callbacks, get(ich) != nullptr);
+        size_t next = get(ich)->m_next_sibling;
+        _release(ich);
+        if(ich == get(node)->m_last_child)
+            break;
+        ich = next;
+    }
+}
+
+bool Tree::change_type(size_t node, NodeType type)
+{
+    _RYML_CB_ASSERT(m_callbacks, type.is_val() || type.is_map() || type.is_seq());
+    _RYML_CB_ASSERT(m_callbacks, type.is_val() + type.is_map() + type.is_seq() == 1);
+    _RYML_CB_ASSERT(m_callbacks, type.has_key() == has_key(node) || (has_key(node) && !type.has_key()));
+    NodeData *d = _p(node);
+    if(type.is_map() && is_map(node))
+        return false;
+    else if(type.is_seq() && is_seq(node))
+        return false;
+    else if(type.is_val() && is_val(node))
+        return false;
+    d->m_type = (d->m_type & (~(MAP|SEQ|VAL))) | type;
+    remove_children(node);
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+size_t Tree::duplicate(size_t node, size_t parent, size_t after)
+{
+    return duplicate(this, node, parent, after);
+}
+
+size_t Tree::duplicate(Tree const* src, size_t node, size_t parent, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, src != nullptr);
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks,  ! src->is_root(node));
+
+    size_t copy = _claim();
+
+    _copy_props(copy, src, node);
+    _set_hierarchy(copy, parent, after);
+    duplicate_children(src, node, copy, NONE);
+
+    return copy;
+}
+
+//-----------------------------------------------------------------------------
+size_t Tree::duplicate_children(size_t node, size_t parent, size_t after)
+{
+    return duplicate_children(this, node, parent, after);
+}
+
+size_t Tree::duplicate_children(Tree const* src, size_t node, size_t parent, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, src != nullptr);
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks, after == NONE || has_child(parent, after));
+
+    size_t prev = after;
+    for(size_t i = src->first_child(node); i != NONE; i = src->next_sibling(i))
+    {
+        prev = duplicate(src, i, parent, prev);
+    }
+
+    return prev;
+}
+
+//-----------------------------------------------------------------------------
+void Tree::duplicate_contents(size_t node, size_t where)
+{
+    duplicate_contents(this, node, where);
+}
+
+void Tree::duplicate_contents(Tree const *src, size_t node, size_t where)
+{
+    _RYML_CB_ASSERT(m_callbacks, src != nullptr);
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, where != NONE);
+    _copy_props_wo_key(where, src, node);
+    duplicate_children(src, node, where, last_child(where));
+}
+
+//-----------------------------------------------------------------------------
+size_t Tree::duplicate_children_no_rep(size_t node, size_t parent, size_t after)
+{
+    return duplicate_children_no_rep(this, node, parent, after);
+}
+
+size_t Tree::duplicate_children_no_rep(Tree const *src, size_t node, size_t parent, size_t after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks, after == NONE || has_child(parent, after));
+
+    // don't loop using pointers as there may be a relocation
+
+    // find the position where "after" is
+    size_t after_pos = NONE;
+    if(after != NONE)
+    {
+        for(size_t i = first_child(parent), icount = 0; i != NONE; ++icount, i = next_sibling(i))
+        {
+            if(i == after)
+            {
+                after_pos = icount;
+                break;
+            }
+        }
+        _RYML_CB_ASSERT(m_callbacks, after_pos != NONE);
+    }
+
+    // for each child to be duplicated...
+    size_t prev = after;
+    for(size_t i = src->first_child(node), icount = 0; i != NONE; ++icount, i = src->next_sibling(i))
+    {
+        if(is_seq(parent))
+        {
+            prev = duplicate(i, parent, prev);
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_callbacks, is_map(parent));
+            // does the parent already have a node with key equal to that of the current duplicate?
+            size_t rep = NONE, rep_pos = NONE;
+            for(size_t j = first_child(parent), jcount = 0; j != NONE; ++jcount, j = next_sibling(j))
+            {
+                if(key(j) == key(i))
+                {
+                    rep = j;
+                    rep_pos = jcount;
+                    break;
+                }
+            }
+            if(rep == NONE) // there is no repetition; just duplicate
+            {
+                prev = duplicate(src, i, parent, prev);
+            }
+            else  // yes, there is a repetition
+            {
+                if(after_pos != NONE && rep_pos < after_pos)
+                {
+                    // rep is located before the node which will be inserted,
+                    // and will be overridden by the duplicate. So replace it.
+                    remove(rep);
+                    prev = duplicate(src, i, parent, prev);
+                }
+                else if(after_pos == NONE || rep_pos >= after_pos)
+                {
+                    // rep is located after the node which will be inserted
+                    // and overrides it. So move the rep into this node's place.
+                    if(rep != prev)
+                    {
+                        move(rep, prev);
+                        prev = rep;
+                    }
+                }
+            } // there's a repetition
+        }
+    }
+
+    return prev;
+}
+
+
+//-----------------------------------------------------------------------------
+
+void Tree::merge_with(Tree const *src, size_t src_node, size_t dst_node)
+{
+    _RYML_CB_ASSERT(m_callbacks, src != nullptr);
+    if(src_node == NONE)
+        src_node = src->root_id();
+    if(dst_node == NONE)
+        dst_node = root_id();
+    _RYML_CB_ASSERT(m_callbacks, src->has_val(src_node) || src->is_seq(src_node) || src->is_map(src_node));
+
+    if(src->has_val(src_node))
+    {
+        if( ! has_val(dst_node))
+        {
+            if(has_children(dst_node))
+                remove_children(dst_node);
+        }
+        if(src->is_keyval(src_node))
+            _copy_props(dst_node, src, src_node);
+        else if(src->is_val(src_node))
+            _copy_props_wo_key(dst_node, src, src_node);
+        else
+            C4_NEVER_REACH();
+    }
+    else if(src->is_seq(src_node))
+    {
+        if( ! is_seq(dst_node))
+        {
+            if(has_children(dst_node))
+                remove_children(dst_node);
+            _clear_type(dst_node);
+            if(src->has_key(src_node))
+                to_seq(dst_node, src->key(src_node));
+            else
+                to_seq(dst_node);
+        }
+        for(size_t sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
+        {
+            size_t dch = append_child(dst_node);
+            _copy_props_wo_key(dch, src, sch);
+            merge_with(src, sch, dch);
+        }
+    }
+    else if(src->is_map(src_node))
+    {
+        if( ! is_map(dst_node))
+        {
+            if(has_children(dst_node))
+                remove_children(dst_node);
+            _clear_type(dst_node);
+            if(src->has_key(src_node))
+                to_map(dst_node, src->key(src_node));
+            else
+                to_map(dst_node);
+        }
+        for(size_t sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
+        {
+            size_t dch = find_child(dst_node, src->key(sch));
+            if(dch == NONE)
+            {
+                dch = append_child(dst_node);
+                _copy_props(dch, src, sch);
+            }
+            merge_with(src, sch, dch);
+        }
+    }
+    else
+    {
+        C4_NEVER_REACH();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+namespace detail {
+/** @todo make this part of the public API, refactoring as appropriate
+ * to be able to use the same resolver to handle multiple trees (one
+ * at a time) */
+struct ReferenceResolver
+{
+    struct refdata
+    {
+        NodeType type;
+        size_t node;
+        size_t prev_anchor;
+        size_t target;
+        size_t parent_ref;
+        size_t parent_ref_sibling;
+    };
+
+    Tree *t;
+    /** from the specs: "an alias node refers to the most recent
+     * node in the serialization having the specified anchor". So
+     * we need to start looking upward from ref nodes.
+     *
+     * @see http://yaml.org/spec/1.2/spec.html#id2765878 */
+    stack<refdata> refs;
+
+    ReferenceResolver(Tree *t_) : t(t_), refs(t_->callbacks())
+    {
+        resolve();
+    }
+
+    void store_anchors_and_refs()
+    {
+        // minimize (re-)allocations by counting first
+        size_t num_anchors_and_refs = count_anchors_and_refs(t->root_id());
+        if(!num_anchors_and_refs)
+            return;
+        refs.reserve(num_anchors_and_refs);
+
+        // now descend through the hierarchy
+        _store_anchors_and_refs(t->root_id());
+
+        // finally connect the reference list
+        size_t prev_anchor = npos;
+        size_t count = 0;
+        for(auto &rd : refs)
+        {
+            rd.prev_anchor = prev_anchor;
+            if(rd.type.is_anchor())
+                prev_anchor = count;
+            ++count;
+        }
+    }
+
+    size_t count_anchors_and_refs(size_t n)
+    {
+        size_t c = 0;
+        c += t->has_key_anchor(n);
+        c += t->has_val_anchor(n);
+        c += t->is_key_ref(n);
+        c += t->is_val_ref(n);
+        for(size_t ch = t->first_child(n); ch != NONE; ch = t->next_sibling(ch))
+            c += count_anchors_and_refs(ch);
+        return c;
+    }
+
+    void _store_anchors_and_refs(size_t n)
+    {
+        if(t->is_key_ref(n) || t->is_val_ref(n) || (t->has_key(n) && t->key(n) == "<<"))
+        {
+            if(t->is_seq(n))
+            {
+                // for merging multiple inheritance targets
+                //   <<: [ *CENTER, *BIG ]
+                for(size_t ich = t->first_child(n); ich != NONE; ich = t->next_sibling(ich))
+                {
+                    RYML_ASSERT(t->num_children(ich) == 0);
+                    refs.push({VALREF, ich, npos, npos, n, t->next_sibling(n)});
+                }
+                return;
+            }
+            if(t->is_key_ref(n) && t->key(n) != "<<") // insert key refs BEFORE inserting val refs
+            {
+                RYML_CHECK((!t->has_key(n)) || t->key(n).ends_with(t->key_ref(n)));
+                refs.push({KEYREF, n, npos, npos, NONE, NONE});
+            }
+            if(t->is_val_ref(n))
+            {
+                RYML_CHECK((!t->has_val(n)) || t->val(n).ends_with(t->val_ref(n)));
+                refs.push({VALREF, n, npos, npos, NONE, NONE});
+            }
+        }
+        if(t->has_key_anchor(n))
+        {
+            RYML_CHECK(t->has_key(n));
+            refs.push({KEYANCH, n, npos, npos, NONE, NONE});
+        }
+        if(t->has_val_anchor(n))
+        {
+            RYML_CHECK(t->has_val(n) || t->is_container(n));
+            refs.push({VALANCH, n, npos, npos, NONE, NONE});
+        }
+        for(size_t ch = t->first_child(n); ch != NONE; ch = t->next_sibling(ch))
+        {
+            _store_anchors_and_refs(ch);
+        }
+    }
+
+    size_t lookup_(refdata *C4_RESTRICT ra)
+    {
+        RYML_ASSERT(ra->type.is_key_ref() || ra->type.is_val_ref());
+        RYML_ASSERT(ra->type.is_key_ref() != ra->type.is_val_ref());
+        csubstr refname;
+        if(ra->type.is_val_ref())
+        {
+            refname = t->val_ref(ra->node);
+        }
+        else
+        {
+            RYML_ASSERT(ra->type.is_key_ref());
+            refname = t->key_ref(ra->node);
+        }
+        while(ra->prev_anchor != npos)
+        {
+            ra = &refs[ra->prev_anchor];
+            if(t->has_anchor(ra->node, refname))
+                return ra->node;
+        }
+
+        #ifndef RYML_ERRMSG_SIZE
+          #define RYML_ERRMSG_SIZE 1024
+        #endif
+
+        char errmsg[RYML_ERRMSG_SIZE];
+        snprintf(errmsg, RYML_ERRMSG_SIZE, "anchor does not exist: '%.*s'",
+                 static_cast<int>(refname.size()), refname.data());
+        c4::yml::error(errmsg);
+        return NONE;
+    }
+
+    void resolve()
+    {
+        store_anchors_and_refs();
+        if(refs.empty())
+            return;
+
+        /* from the specs: "an alias node refers to the most recent
+         * node in the serialization having the specified anchor". So
+         * we need to start looking upward from ref nodes.
+         *
+         * @see http://yaml.org/spec/1.2/spec.html#id2765878 */
+        for(size_t i = 0, e = refs.size(); i < e; ++i)
+        {
+            auto &C4_RESTRICT rd = refs.top(i);
+            if( ! rd.type.is_ref())
+                continue;
+            rd.target = lookup_(&rd);
+        }
+    }
+
+}; // ReferenceResolver
+} // namespace detail
+
+void Tree::resolve()
+{
+    if(m_size == 0)
+        return;
+
+    detail::ReferenceResolver rr(this);
+
+    // insert the resolved references
+    size_t prev_parent_ref = NONE;
+    size_t prev_parent_ref_after = NONE;
+    for(auto const& C4_RESTRICT rd : rr.refs)
+    {
+        if( ! rd.type.is_ref())
+            continue;
+        if(rd.parent_ref != NONE)
+        {
+            _RYML_CB_ASSERT(m_callbacks, is_seq(rd.parent_ref));
+            size_t after, p = parent(rd.parent_ref);
+            if(prev_parent_ref != rd.parent_ref)
+            {
+                after = rd.parent_ref;//prev_sibling(rd.parent_ref_sibling);
+                prev_parent_ref_after = after;
+            }
+            else
+            {
+                after = prev_parent_ref_after;
+            }
+            prev_parent_ref = rd.parent_ref;
+            prev_parent_ref_after = duplicate_children_no_rep(rd.target, p, after);
+            remove(rd.node);
+        }
+        else
+        {
+            if(has_key(rd.node) && is_key_ref(rd.node) && key(rd.node) == "<<")
+            {
+                _RYML_CB_ASSERT(m_callbacks, is_keyval(rd.node));
+                size_t p = parent(rd.node);
+                size_t after = prev_sibling(rd.node);
+                duplicate_children_no_rep(rd.target, p, after);
+                remove(rd.node);
+            }
+            else if(rd.type.is_key_ref())
+            {
+                _RYML_CB_ASSERT(m_callbacks, is_key_ref(rd.node));
+                _RYML_CB_ASSERT(m_callbacks, has_key_anchor(rd.target) || has_val_anchor(rd.target));
+                if(has_val_anchor(rd.target) && val_anchor(rd.target) == key_ref(rd.node))
+                {
+                    _RYML_CB_CHECK(m_callbacks, !is_container(rd.target));
+                    _RYML_CB_CHECK(m_callbacks, has_val(rd.target));
+                    _p(rd.node)->m_key.scalar = val(rd.target);
+                    _add_flags(rd.node, KEY);
+                }
+                else
+                {
+                    _RYML_CB_CHECK(m_callbacks, key_anchor(rd.target) == key_ref(rd.node));
+                    _p(rd.node)->m_key.scalar = key(rd.target);
+                    _add_flags(rd.node, VAL);
+                }
+            }
+            else
+            {
+                _RYML_CB_ASSERT(m_callbacks, rd.type.is_val_ref());
+                if(has_key_anchor(rd.target) && key_anchor(rd.target) == val_ref(rd.node))
+                {
+                    _RYML_CB_CHECK(m_callbacks, !is_container(rd.target));
+                    _RYML_CB_CHECK(m_callbacks, has_val(rd.target));
+                    _p(rd.node)->m_val.scalar = key(rd.target);
+                    _add_flags(rd.node, VAL);
+                }
+                else
+                {
+                    duplicate_contents(rd.target, rd.node);
+                }
+            }
+        }
+    }
+
+    // clear anchors and refs
+    for(auto const& C4_RESTRICT ar : rr.refs)
+    {
+        rem_anchor_ref(ar.node);
+        if(ar.parent_ref != NONE)
+            if(type(ar.parent_ref) != NOTYPE)
+                remove(ar.parent_ref);
+    }
+
+}
+
+//-----------------------------------------------------------------------------
+
+size_t Tree::num_children(size_t node) const
+{
+    size_t count = 0;
+    for(size_t i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        ++count;
+    }
+    return count;
+}
+
+size_t Tree::child(size_t node, size_t pos) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    size_t count = 0;
+    for(size_t i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        if(count++ == pos)
+            return i;
+    }
+    return NONE;
+}
+
+size_t Tree::child_pos(size_t node, size_t ch) const
+{
+    size_t count = 0;
+    for(size_t i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        if(i == ch)
+            return count;
+        ++count;
+    }
+    return npos;
+}
+
+#if defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma GCC diagnostic ignored "-Wnull-dereference"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   if __GNUC__ >= 6
+#       pragma GCC diagnostic ignored "-Wnull-dereference"
+#   endif
+#endif
+
+size_t Tree::find_child(size_t node, csubstr const& name) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, is_map(node));
+    if(get(node)->m_first_child == NONE)
+    {
+        _RYML_CB_ASSERT(m_callbacks, _p(node)->m_last_child == NONE);
+        return NONE;
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_callbacks, _p(node)->m_last_child != NONE);
+    }
+    for(size_t i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        if(_p(i)->m_key.scalar == name)
+        {
+            return i;
+        }
+    }
+    return NONE;
+}
+
+#if defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+void Tree::to_val(size_t node, csubstr val, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || ! parent_is_map(node));
+    _set_flags(node, VAL|more_flags);
+    _p(node)->m_key.clear();
+    _p(node)->m_val = val;
+}
+
+void Tree::to_keyval(size_t node, csubstr key, csubstr val, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || parent_is_map(node));
+    _set_flags(node, KEYVAL|more_flags);
+    _p(node)->m_key = key;
+    _p(node)->m_val = val;
+}
+
+void Tree::to_map(size_t node, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || ! parent_is_map(node)); // parent must not have children with keys
+    _set_flags(node, MAP|more_flags);
+    _p(node)->m_key.clear();
+    _p(node)->m_val.clear();
+}
+
+void Tree::to_map(size_t node, csubstr key, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || parent_is_map(node));
+    _set_flags(node, KEY|MAP|more_flags);
+    _p(node)->m_key = key;
+    _p(node)->m_val.clear();
+}
+
+void Tree::to_seq(size_t node, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || parent_is_seq(node));
+    _set_flags(node, SEQ|more_flags);
+    _p(node)->m_key.clear();
+    _p(node)->m_val.clear();
+}
+
+void Tree::to_seq(size_t node, csubstr key, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _RYML_CB_ASSERT(m_callbacks, parent(node) == NONE || parent_is_map(node));
+    _set_flags(node, KEY|SEQ|more_flags);
+    _p(node)->m_key = key;
+    _p(node)->m_val.clear();
+}
+
+void Tree::to_doc(size_t node, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _set_flags(node, DOC|more_flags);
+    _p(node)->m_key.clear();
+    _p(node)->m_val.clear();
+}
+
+void Tree::to_stream(size_t node, type_bits more_flags)
+{
+    _RYML_CB_ASSERT(m_callbacks,  ! has_children(node));
+    _set_flags(node, STREAM|more_flags);
+    _p(node)->m_key.clear();
+    _p(node)->m_val.clear();
+}
+
+
+//-----------------------------------------------------------------------------
+size_t Tree::num_tag_directives() const
+{
+    // this assumes we have a very small number of tag directives
+    for(size_t i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        if(m_tag_directives[i].handle.empty())
+            return i;
+    return RYML_MAX_TAG_DIRECTIVES;
+}
+
+void Tree::clear_tag_directives()
+{
+    for(TagDirective &td : m_tag_directives)
+        td = {};
+}
+
+size_t Tree::add_tag_directive(TagDirective const& td)
+{
+    _RYML_CB_CHECK(m_callbacks, !td.handle.empty());
+    _RYML_CB_CHECK(m_callbacks, !td.prefix.empty());
+    _RYML_CB_ASSERT(m_callbacks, td.handle.begins_with('!'));
+    _RYML_CB_ASSERT(m_callbacks, td.handle.ends_with('!'));
+    // https://yaml.org/spec/1.2.2/#rule-ns-word-char
+    _RYML_CB_ASSERT(m_callbacks, td.handle == '!' || td.handle == "!!" || td.handle.trim('!').first_not_of("01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-") == npos);
+    size_t pos = num_tag_directives();
+    _RYML_CB_CHECK(m_callbacks, pos < RYML_MAX_TAG_DIRECTIVES);
+    m_tag_directives[pos] = td;
+    return pos;
+}
+
+size_t Tree::resolve_tag(substr output, csubstr tag, size_t node_id) const
+{
+    // lookup from the end. We want to find the first directive that
+    // matches the tag and has a target node id leq than the given
+    // node_id.
+    for(size_t i = RYML_MAX_TAG_DIRECTIVES-1; i != (size_t)-1; --i)
+    {
+        auto const& td = m_tag_directives[i];
+        if(td.handle.empty())
+            continue;
+        if(tag.begins_with(td.handle) && td.next_node_id <= node_id)
+        {
+            _RYML_CB_ASSERT(m_callbacks, tag.len >= td.handle.len);
+            csubstr rest = tag.sub(td.handle.len);
+            size_t len = 1u + td.prefix.len + rest.len + 1u;
+            size_t numpc = rest.count('%');
+            if(numpc == 0)
+            {
+                if(len <= output.len)
+                {
+                    output.str[0] = '<';
+                    memcpy(1u + output.str, td.prefix.str, td.prefix.len);
+                    memcpy(1u + output.str + td.prefix.len, rest.str, rest.len);
+                    output.str[1u + td.prefix.len + rest.len] = '>';
+                }
+            }
+            else
+            {
+                // need to decode URI % sequences
+                size_t pos = rest.find('%');
+                _RYML_CB_ASSERT(m_callbacks, pos != npos);
+                do {
+                    size_t next = rest.first_not_of("0123456789abcdefABCDEF", pos+1);
+                    if(next == npos)
+                        next = rest.len;
+                    _RYML_CB_CHECK(m_callbacks, pos+1 < next);
+                    _RYML_CB_CHECK(m_callbacks, pos+1 + 2 <= next);
+                    size_t delta = next - (pos+1);
+                    len -= delta;
+                    pos = rest.find('%', pos+1);
+                } while(pos != npos);
+                if(len <= output.len)
+                {
+                    size_t prev = 0, wpos = 0;
+                    auto appendstr = [&](csubstr s) { memcpy(output.str + wpos, s.str, s.len); wpos += s.len; };
+                    auto appendchar = [&](char c) { output.str[wpos++] = c; };
+                    appendchar('<');
+                    appendstr(td.prefix);
+                    pos = rest.find('%');
+                    _RYML_CB_ASSERT(m_callbacks, pos != npos);
+                    do {
+                        size_t next = rest.first_not_of("0123456789abcdefABCDEF", pos+1);
+                        if(next == npos)
+                            next = rest.len;
+                        _RYML_CB_CHECK(m_callbacks, pos+1 < next);
+                        _RYML_CB_CHECK(m_callbacks, pos+1 + 2 <= next);
+                        uint8_t val;
+                        if(C4_UNLIKELY(!read_hex(rest.range(pos+1, next), &val) || val > 127))
+                            _RYML_CB_ERR(m_callbacks, "invalid URI character");
+                        appendstr(rest.range(prev, pos));
+                        appendchar((char)val);
+                        prev = next;
+                        pos = rest.find('%', pos+1);
+                    } while(pos != npos);
+                    _RYML_CB_ASSERT(m_callbacks, pos == npos);
+                    _RYML_CB_ASSERT(m_callbacks, prev > 0);
+                    _RYML_CB_ASSERT(m_callbacks, rest.len >= prev);
+                    appendstr(rest.sub(prev));
+                    appendchar('>');
+                    _RYML_CB_ASSERT(m_callbacks, wpos == len);
+                }
+            }
+            return len;
+        }
+    }
+    return 0; // return 0 to signal that the tag is local and cannot be resolved
+}
+
+namespace {
+csubstr _transform_tag(Tree *t, csubstr tag, size_t node)
+{
+    size_t required_size = t->resolve_tag(substr{}, tag, node);
+    if(!required_size)
+        return tag;
+    const char *prev_arena = t->arena().str;
+    substr buf = t->alloc_arena(required_size);
+    _RYML_CB_ASSERT(t->m_callbacks, t->arena().str == prev_arena);
+    size_t actual_size = t->resolve_tag(buf, tag, node);
+    _RYML_CB_ASSERT(t->m_callbacks, actual_size <= required_size);
+    return buf.first(actual_size);
+}
+void _resolve_tags(Tree *t, size_t node)
+{
+    for(size_t child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+    {
+        if(t->has_key(child) && t->has_key_tag(child))
+            t->set_key_tag(child, _transform_tag(t, t->key_tag(child), child));
+        if(t->has_val(child) && t->has_val_tag(child))
+            t->set_val_tag(child, _transform_tag(t, t->val_tag(child), child));
+        _resolve_tags(t, child);
+    }
+}
+size_t _count_resolved_tags_size(Tree const* t, size_t node)
+{
+    size_t sz = 0;
+    for(size_t child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+    {
+        if(t->has_key(child) && t->has_key_tag(child))
+            sz += t->resolve_tag(substr{}, t->key_tag(child), child);
+        if(t->has_val(child) && t->has_val_tag(child))
+            sz += t->resolve_tag(substr{}, t->val_tag(child), child);
+        sz += _count_resolved_tags_size(t, child);
+    }
+    return sz;
+}
+} // namespace
+
+void Tree::resolve_tags()
+{
+    if(empty())
+        return;
+    if(num_tag_directives() == 0)
+        return;
+    size_t needed_size = _count_resolved_tags_size(this, root_id());
+    if(needed_size)
+        reserve_arena(arena_pos() + needed_size);
+    _resolve_tags(this, root_id());
+}
+
+
+//-----------------------------------------------------------------------------
+
+csubstr Tree::lookup_result::resolved() const
+{
+    csubstr p = path.first(path_pos);
+    if(p.ends_with('.'))
+        p = p.first(p.len-1);
+    return p;
+}
+
+csubstr Tree::lookup_result::unresolved() const
+{
+    return path.sub(path_pos);
+}
+
+void Tree::_advance(lookup_result *r, size_t more) const
+{
+    r->path_pos += more;
+    if(r->path.sub(r->path_pos).begins_with('.'))
+        ++r->path_pos;
+}
+
+Tree::lookup_result Tree::lookup_path(csubstr path, size_t start) const
+{
+    if(start == NONE)
+        start = root_id();
+    lookup_result r(path, start);
+    if(path.empty())
+        return r;
+    _lookup_path(&r);
+    if(r.target == NONE && r.closest == start)
+        r.closest = NONE;
+    return r;
+}
+
+size_t Tree::lookup_path_or_modify(csubstr default_value, csubstr path, size_t start)
+{
+    size_t target = _lookup_path_or_create(path, start);
+    if(parent_is_map(target))
+        to_keyval(target, key(target), default_value);
+    else
+        to_val(target, default_value);
+    return target;
+}
+
+size_t Tree::lookup_path_or_modify(Tree const *src, size_t src_node, csubstr path, size_t start)
+{
+    size_t target = _lookup_path_or_create(path, start);
+    merge_with(src, src_node, target);
+    return target;
+}
+
+size_t Tree::_lookup_path_or_create(csubstr path, size_t start)
+{
+    if(start == NONE)
+        start = root_id();
+    lookup_result r(path, start);
+    _lookup_path(&r);
+    if(r.target != NONE)
+    {
+        C4_ASSERT(r.unresolved().empty());
+        return r.target;
+    }
+    _lookup_path_modify(&r);
+    return r.target;
+}
+
+void Tree::_lookup_path(lookup_result *r) const
+{
+    C4_ASSERT( ! r->unresolved().empty());
+    _lookup_path_token parent{"", type(r->closest)};
+    size_t node;
+    do
+    {
+        node = _next_node(r, &parent);
+        if(node != NONE)
+            r->closest = node;
+        if(r->unresolved().empty())
+        {
+            r->target = node;
+            return;
+        }
+    } while(node != NONE);
+}
+
+void Tree::_lookup_path_modify(lookup_result *r)
+{
+    C4_ASSERT( ! r->unresolved().empty());
+    _lookup_path_token parent{"", type(r->closest)};
+    size_t node;
+    do
+    {
+        node = _next_node_modify(r, &parent);
+        if(node != NONE)
+            r->closest = node;
+        if(r->unresolved().empty())
+        {
+            r->target = node;
+            return;
+        }
+    } while(node != NONE);
+}
+
+size_t Tree::_next_node(lookup_result * r, _lookup_path_token *parent) const
+{
+    _lookup_path_token token = _next_token(r, *parent);
+    if( ! token)
+        return NONE;
+
+    size_t node = NONE;
+    csubstr prev = token.value;
+    if(token.type == MAP || token.type == SEQ)
+    {
+        _RYML_CB_ASSERT(m_callbacks, !token.value.begins_with('['));
+        //_RYML_CB_ASSERT(m_callbacks, is_container(r->closest) || r->closest == NONE);
+        _RYML_CB_ASSERT(m_callbacks, is_map(r->closest));
+        node = find_child(r->closest, token.value);
+    }
+    else if(token.type == KEYVAL)
+    {
+        _RYML_CB_ASSERT(m_callbacks, r->unresolved().empty());
+        if(is_map(r->closest))
+            node = find_child(r->closest, token.value);
+    }
+    else if(token.type == KEY)
+    {
+        _RYML_CB_ASSERT(m_callbacks, token.value.begins_with('[') && token.value.ends_with(']'));
+        token.value = token.value.offs(1, 1).trim(' ');
+        size_t idx = 0;
+        _RYML_CB_CHECK(m_callbacks, from_chars(token.value, &idx));
+        node = child(r->closest, idx);
+    }
+    else
+    {
+        C4_NEVER_REACH();
+    }
+
+    if(node != NONE)
+    {
+        *parent = token;
+    }
+    else
+    {
+        csubstr p = r->path.sub(r->path_pos > 0 ? r->path_pos - 1 : r->path_pos);
+        r->path_pos -= prev.len;
+        if(p.begins_with('.'))
+            r->path_pos -= 1u;
+    }
+
+    return node;
+}
+
+size_t Tree::_next_node_modify(lookup_result * r, _lookup_path_token *parent)
+{
+    _lookup_path_token token = _next_token(r, *parent);
+    if( ! token)
+        return NONE;
+
+    size_t node = NONE;
+    if(token.type == MAP || token.type == SEQ)
+    {
+        _RYML_CB_ASSERT(m_callbacks, !token.value.begins_with('['));
+        //_RYML_CB_ASSERT(m_callbacks, is_container(r->closest) || r->closest == NONE);
+        if( ! is_container(r->closest))
+        {
+            if(has_key(r->closest))
+                to_map(r->closest, key(r->closest));
+            else
+                to_map(r->closest);
+        }
+        else
+        {
+            if(is_map(r->closest))
+                node = find_child(r->closest, token.value);
+            else
+            {
+                size_t pos = NONE;
+                _RYML_CB_CHECK(m_callbacks, c4::atox(token.value, &pos));
+                _RYML_CB_ASSERT(m_callbacks, pos != NONE);
+                node = child(r->closest, pos);
+            }
+        }
+        if(node == NONE)
+        {
+            _RYML_CB_ASSERT(m_callbacks, is_map(r->closest));
+            node = append_child(r->closest);
+            NodeData *n = _p(node);
+            n->m_key.scalar = token.value;
+            n->m_type.add(KEY);
+        }
+    }
+    else if(token.type == KEYVAL)
+    {
+        _RYML_CB_ASSERT(m_callbacks, r->unresolved().empty());
+        if(is_map(r->closest))
+        {
+            node = find_child(r->closest, token.value);
+            if(node == NONE)
+                node = append_child(r->closest);
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_callbacks, !is_seq(r->closest));
+            _add_flags(r->closest, MAP);
+            node = append_child(r->closest);
+        }
+        NodeData *n = _p(node);
+        n->m_key.scalar = token.value;
+        n->m_val.scalar = "";
+        n->m_type.add(KEYVAL);
+    }
+    else if(token.type == KEY)
+    {
+        _RYML_CB_ASSERT(m_callbacks, token.value.begins_with('[') && token.value.ends_with(']'));
+        token.value = token.value.offs(1, 1).trim(' ');
+        size_t idx;
+        if( ! from_chars(token.value, &idx))
+             return NONE;
+        if( ! is_container(r->closest))
+        {
+            if(has_key(r->closest))
+            {
+                csubstr k = key(r->closest);
+                _clear_type(r->closest);
+                to_seq(r->closest, k);
+            }
+            else
+            {
+                _clear_type(r->closest);
+                to_seq(r->closest);
+            }
+        }
+        _RYML_CB_ASSERT(m_callbacks, is_container(r->closest));
+        node = child(r->closest, idx);
+        if(node == NONE)
+        {
+            _RYML_CB_ASSERT(m_callbacks, num_children(r->closest) <= idx);
+            for(size_t i = num_children(r->closest); i <= idx; ++i)
+            {
+                node = append_child(r->closest);
+                if(i < idx)
+                {
+                    if(is_map(r->closest))
+                        to_keyval(node, /*"~"*/{}, /*"~"*/{});
+                    else if(is_seq(r->closest))
+                        to_val(node, /*"~"*/{});
+                }
+            }
+        }
+    }
+    else
+    {
+        C4_NEVER_REACH();
+    }
+
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    *parent = token;
+    return node;
+}
+
+/** types of tokens:
+ * - seeing "map."  ---> "map"/MAP
+ * - finishing "scalar" ---> "scalar"/KEYVAL
+ * - seeing "seq[n]" ---> "seq"/SEQ (--> "[n]"/KEY)
+ * - seeing "[n]" ---> "[n]"/KEY
+ */
+Tree::_lookup_path_token Tree::_next_token(lookup_result *r, _lookup_path_token const& parent) const
+{
+    csubstr unres = r->unresolved();
+    if(unres.empty())
+        return {};
+
+    // is it an indexation like [0], [1], etc?
+    if(unres.begins_with('['))
+    {
+        size_t pos = unres.find(']');
+        if(pos == csubstr::npos)
+            return {};
+        csubstr idx = unres.first(pos + 1);
+        _advance(r, pos + 1);
+        return {idx, KEY};
+    }
+
+    // no. so it must be a name
+    size_t pos = unres.first_of(".[");
+    if(pos == csubstr::npos)
+    {
+        _advance(r, unres.len);
+        NodeType t;
+        if(( ! parent) || parent.type.is_seq())
+            return {unres, VAL};
+        return {unres, KEYVAL};
+    }
+
+    // it's either a map or a seq
+    _RYML_CB_ASSERT(m_callbacks, unres[pos] == '.' || unres[pos] == '[');
+    if(unres[pos] == '.')
+    {
+        _RYML_CB_ASSERT(m_callbacks, pos != 0);
+        _advance(r, pos + 1);
+        return {unres.first(pos), MAP};
+    }
+
+    _RYML_CB_ASSERT(m_callbacks, unres[pos] == '[');
+    _advance(r, pos);
+    return {unres.first(pos), SEQ};
+}
+
+
+} // namespace ryml
+} // namespace c4
+
+
+C4_SUPPRESS_WARNING_GCC_POP
+C4_SUPPRESS_WARNING_MSVC_POP
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/tree.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/parse.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse.hpp
+//#include "c4/yml/parse.hpp"
+#if !defined(C4_YML_PARSE_HPP_) && !defined(_C4_YML_PARSE_HPP_)
+#error "amalgamate: file c4/yml/parse.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/error.hpp
+//#include "c4/error.hpp"
+#if !defined(C4_ERROR_HPP_) && !defined(_C4_ERROR_HPP_)
+#error "amalgamate: file c4/error.hpp must have been included at this point"
+#endif /* C4_ERROR_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/utf.hpp
+//#include "c4/utf.hpp"
+#if !defined(C4_UTF_HPP_) && !defined(_C4_UTF_HPP_)
+#error "amalgamate: file c4/utf.hpp must have been included at this point"
+#endif /* C4_UTF_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/dump.hpp
+//#include <c4/dump.hpp>
+#if !defined(C4_DUMP_HPP_) && !defined(_C4_DUMP_HPP_)
+#error "amalgamate: file c4/dump.hpp must have been included at this point"
+#endif /* C4_DUMP_HPP_ */
+
+
+//included above:
+//#include <ctype.h>
+//included above:
+//#include <stdarg.h>
+//included above:
+//#include <stdio.h>
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/parser_dbg.hpp
+//#include "c4/yml/detail/parser_dbg.hpp"
+#if !defined(C4_YML_DETAIL_PARSER_DBG_HPP_) && !defined(_C4_YML_DETAIL_PARSER_DBG_HPP_)
+#error "amalgamate: file c4/yml/detail/parser_dbg.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_PARSER_DBG_HPP_ */
+
+#ifdef RYML_DBG
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/print.hpp
+//#include "c4/yml/detail/print.hpp"
+#if !defined(C4_YML_DETAIL_PRINT_HPP_) && !defined(_C4_YML_DETAIL_PRINT_HPP_)
+#error "amalgamate: file c4/yml/detail/print.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_PRINT_HPP_ */
+
+#endif
+
+#ifndef RYML_ERRMSG_SIZE
+    #define RYML_ERRMSG_SIZE 1024
+#endif
+
+//#define RYML_WITH_TAB_TOKENS
+#ifdef RYML_WITH_TAB_TOKENS
+#define _RYML_WITH_TAB_TOKENS(...) __VA_ARGS__
+#define _RYML_WITH_OR_WITHOUT_TAB_TOKENS(with, without) with
+#else
+#define _RYML_WITH_TAB_TOKENS(...)
+#define _RYML_WITH_OR_WITHOUT_TAB_TOKENS(with, without) without
+#endif
+
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4296/*expression is always 'boolean_value'*/)
+#elif defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wtype-limits" // to remove a warning on an assertion that a size_t >= 0. Later on, this size_t will turn into a template argument, and then it can become < 0.
+#   pragma clang diagnostic ignored "-Wformat-nonliteral"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wtype-limits" // to remove a warning on an assertion that a size_t >= 0. Later on, this size_t will turn into a template argument, and then it can become < 0.
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#   if __GNUC__ >= 7
+#       pragma GCC diagnostic ignored "-Wduplicated-branches"
+#   endif
+#endif
+
+namespace c4 {
+namespace yml {
+
+namespace {
+
+template<class DumpFn, class ...Args>
+void _parse_dump(DumpFn dumpfn, c4::csubstr fmt, Args&& ...args)
+{
+    char writebuf[256];
+    auto results = c4::format_dump_resume(dumpfn, writebuf, fmt, std::forward<Args>(args)...);
+    // resume writing if the results failed to fit the buffer
+    if(C4_UNLIKELY(results.bufsize > sizeof(writebuf))) // bufsize will be that of the largest element serialized. Eg int(1), will require 1 byte.
+    {
+        results = format_dump_resume(dumpfn, results, writebuf, fmt, std::forward<Args>(args)...);
+        if(C4_UNLIKELY(results.bufsize > sizeof(writebuf)))
+        {
+            results = format_dump_resume(dumpfn, results, writebuf, fmt, std::forward<Args>(args)...);
+        }
+    }
+}
+
+bool _is_scalar_next__runk(csubstr s)
+{
+    return !(s.begins_with(": ") || s.begins_with_any("#,:{}[]%&") || s.begins_with("? ") || s == "-" || s.begins_with("- "));
+}
+
+bool _is_scalar_next__rseq_rval(csubstr s)
+{
+    return !(s.begins_with_any("[{!&") || s.begins_with("? ") || s.begins_with("- ") || s == "-");
+}
+
+bool _is_scalar_next__rmap(csubstr s)
+{
+    return !(s.begins_with(": ") || s.begins_with_any("#,!&") || s.begins_with("? ") _RYML_WITH_TAB_TOKENS(|| s.begins_with(":\t")));
+}
+
+bool _is_scalar_next__rmap_val(csubstr s)
+{
+    return !(s.begins_with("- ") || s.begins_with_any("{[") || s == "-");
+}
+
+bool _is_doc_sep(csubstr s)
+{
+    constexpr const csubstr dashes = "---";
+    constexpr const csubstr ellipsis = "...";
+    constexpr const csubstr whitesp = " \t";
+    if(s.begins_with(dashes))
+        return s == dashes || s.sub(3).begins_with_any(whitesp);
+    else if(s.begins_with(ellipsis))
+        return s == ellipsis || s.sub(3).begins_with_any(whitesp);
+    return false;
+}
+
+/** @p i is set to the first non whitespace character after the line
+ * @return the number of empty lines after the initial position */
+size_t count_following_newlines(csubstr r, size_t *C4_RESTRICT i, size_t indentation)
+{
+    RYML_ASSERT(r[*i] == '\n');
+    size_t numnl_following = 0;
+    ++(*i);
+    for( ; *i < r.len; ++(*i))
+    {
+        if(r.str[*i] == '\n')
+        {
+            ++numnl_following;
+            if(indentation) // skip the indentation after the newline
+            {
+                size_t stop = *i + indentation;
+                for( ; *i < r.len; ++(*i))
+                {
+                    if(r.str[*i] != ' ' && r.str[*i] != '\r')
+                        break;
+                    RYML_ASSERT(*i < stop);
+                }
+                C4_UNUSED(stop);
+            }
+        }
+        else if(r.str[*i] == ' ' || r.str[*i] == '\t' || r.str[*i] == '\r')  // skip leading whitespace
+            ;
+        else
+            break;
+    }
+    return numnl_following;
+}
+
+} // anon namespace
+
+
+//-----------------------------------------------------------------------------
+
+Parser::~Parser()
+{
+    _free();
+    _clr();
+}
+
+Parser::Parser(Callbacks const& cb)
+    : m_file()
+    , m_buf()
+    , m_root_id(NONE)
+    , m_tree()
+    , m_stack(cb)
+    , m_state()
+    , m_key_tag_indentation(0)
+    , m_key_tag2_indentation(0)
+    , m_key_tag()
+    , m_key_tag2()
+    , m_val_tag_indentation(0)
+    , m_val_tag()
+    , m_key_anchor_was_before(false)
+    , m_key_anchor_indentation(0)
+    , m_key_anchor()
+    , m_val_anchor_indentation(0)
+    , m_val_anchor()
+    , m_filter_arena()
+    , m_newline_offsets()
+    , m_newline_offsets_size(0)
+    , m_newline_offsets_capacity(0)
+    , m_newline_offsets_buf()
+{
+    m_stack.push(State{});
+    m_state = &m_stack.top();
+}
+
+Parser::Parser(Parser &&that)
+    : m_file(that.m_file)
+    , m_buf(that.m_buf)
+    , m_root_id(that.m_root_id)
+    , m_tree(that.m_tree)
+    , m_stack(std::move(that.m_stack))
+    , m_state(&m_stack.top())
+    , m_key_tag_indentation(that.m_key_tag_indentation)
+    , m_key_tag2_indentation(that.m_key_tag2_indentation)
+    , m_key_tag(that.m_key_tag)
+    , m_key_tag2(that.m_key_tag2)
+    , m_val_tag_indentation(that.m_val_tag_indentation)
+    , m_val_tag(that.m_val_tag)
+    , m_key_anchor_was_before(that.m_key_anchor_was_before)
+    , m_key_anchor_indentation(that.m_key_anchor_indentation)
+    , m_key_anchor(that.m_key_anchor)
+    , m_val_anchor_indentation(that.m_val_anchor_indentation)
+    , m_val_anchor(that.m_val_anchor)
+    , m_filter_arena(that.m_filter_arena)
+    , m_newline_offsets(that.m_newline_offsets)
+    , m_newline_offsets_size(that.m_newline_offsets_size)
+    , m_newline_offsets_capacity(that.m_newline_offsets_capacity)
+    , m_newline_offsets_buf(that.m_newline_offsets_buf)
+{
+    that._clr();
+}
+
+Parser::Parser(Parser const& that)
+    : m_file(that.m_file)
+    , m_buf(that.m_buf)
+    , m_root_id(that.m_root_id)
+    , m_tree(that.m_tree)
+    , m_stack(that.m_stack)
+    , m_state(&m_stack.top())
+    , m_key_tag_indentation(that.m_key_tag_indentation)
+    , m_key_tag2_indentation(that.m_key_tag2_indentation)
+    , m_key_tag(that.m_key_tag)
+    , m_key_tag2(that.m_key_tag2)
+    , m_val_tag_indentation(that.m_val_tag_indentation)
+    , m_val_tag(that.m_val_tag)
+    , m_key_anchor_was_before(that.m_key_anchor_was_before)
+    , m_key_anchor_indentation(that.m_key_anchor_indentation)
+    , m_key_anchor(that.m_key_anchor)
+    , m_val_anchor_indentation(that.m_val_anchor_indentation)
+    , m_val_anchor(that.m_val_anchor)
+    , m_filter_arena()
+    , m_newline_offsets()
+    , m_newline_offsets_size()
+    , m_newline_offsets_capacity()
+    , m_newline_offsets_buf()
+{
+    if(that.m_newline_offsets_capacity)
+    {
+        _resize_locations(that.m_newline_offsets_capacity);
+        _RYML_CB_CHECK(m_stack.m_callbacks, m_newline_offsets_capacity == that.m_newline_offsets_capacity);
+        memcpy(m_newline_offsets, that.m_newline_offsets, that.m_newline_offsets_size * sizeof(size_t));
+        m_newline_offsets_size = that.m_newline_offsets_size;
+    }
+    if(that.m_filter_arena.len)
+    {
+        _resize_filter_arena(that.m_filter_arena.len);
+    }
+}
+
+Parser& Parser::operator=(Parser &&that)
+{
+    _free();
+    m_file = (that.m_file);
+    m_buf = (that.m_buf);
+    m_root_id = (that.m_root_id);
+    m_tree = (that.m_tree);
+    m_stack = std::move(that.m_stack);
+    m_state = (&m_stack.top());
+    m_key_tag_indentation = (that.m_key_tag_indentation);
+    m_key_tag2_indentation = (that.m_key_tag2_indentation);
+    m_key_tag = (that.m_key_tag);
+    m_key_tag2 = (that.m_key_tag2);
+    m_val_tag_indentation = (that.m_val_tag_indentation);
+    m_val_tag = (that.m_val_tag);
+    m_key_anchor_was_before = (that.m_key_anchor_was_before);
+    m_key_anchor_indentation = (that.m_key_anchor_indentation);
+    m_key_anchor = (that.m_key_anchor);
+    m_val_anchor_indentation = (that.m_val_anchor_indentation);
+    m_val_anchor = (that.m_val_anchor);
+    m_filter_arena = that.m_filter_arena;
+    m_newline_offsets = (that.m_newline_offsets);
+    m_newline_offsets_size = (that.m_newline_offsets_size);
+    m_newline_offsets_capacity = (that.m_newline_offsets_capacity);
+    m_newline_offsets_buf = (that.m_newline_offsets_buf);
+    that._clr();
+    return *this;
+}
+
+Parser& Parser::operator=(Parser const& that)
+{
+    _free();
+    m_file = (that.m_file);
+    m_buf = (that.m_buf);
+    m_root_id = (that.m_root_id);
+    m_tree = (that.m_tree);
+    m_stack = that.m_stack;
+    m_state = &m_stack.top();
+    m_key_tag_indentation = (that.m_key_tag_indentation);
+    m_key_tag2_indentation = (that.m_key_tag2_indentation);
+    m_key_tag = (that.m_key_tag);
+    m_key_tag2 = (that.m_key_tag2);
+    m_val_tag_indentation = (that.m_val_tag_indentation);
+    m_val_tag = (that.m_val_tag);
+    m_key_anchor_was_before = (that.m_key_anchor_was_before);
+    m_key_anchor_indentation = (that.m_key_anchor_indentation);
+    m_key_anchor = (that.m_key_anchor);
+    m_val_anchor_indentation = (that.m_val_anchor_indentation);
+    m_val_anchor = (that.m_val_anchor);
+    if(that.m_filter_arena.len > 0)
+        _resize_filter_arena(that.m_filter_arena.len);
+    if(that.m_newline_offsets_capacity > m_newline_offsets_capacity)
+        _resize_locations(that.m_newline_offsets_capacity);
+    _RYML_CB_CHECK(m_stack.m_callbacks, m_newline_offsets_capacity >= that.m_newline_offsets_capacity);
+    _RYML_CB_CHECK(m_stack.m_callbacks, m_newline_offsets_capacity >= that.m_newline_offsets_size);
+    memcpy(m_newline_offsets, that.m_newline_offsets, that.m_newline_offsets_size * sizeof(size_t));
+    m_newline_offsets_size = that.m_newline_offsets_size;
+    m_newline_offsets_buf = that.m_newline_offsets_buf;
+    return *this;
+}
+
+void Parser::_clr()
+{
+    m_file = {};
+    m_buf = {};
+    m_root_id = {};
+    m_tree = {};
+    m_stack.clear();
+    m_state = {};
+    m_key_tag_indentation = {};
+    m_key_tag2_indentation = {};
+    m_key_tag = {};
+    m_key_tag2 = {};
+    m_val_tag_indentation = {};
+    m_val_tag = {};
+    m_key_anchor_was_before = {};
+    m_key_anchor_indentation = {};
+    m_key_anchor = {};
+    m_val_anchor_indentation = {};
+    m_val_anchor = {};
+    m_filter_arena = {};
+    m_newline_offsets = {};
+    m_newline_offsets_size = {};
+    m_newline_offsets_capacity = {};
+    m_newline_offsets_buf = {};
+}
+
+void Parser::_free()
+{
+    if(m_newline_offsets)
+    {
+        _RYML_CB_FREE(m_stack.m_callbacks, m_newline_offsets, size_t, m_newline_offsets_capacity);
+        m_newline_offsets = nullptr;
+        m_newline_offsets_size = 0u;
+        m_newline_offsets_capacity = 0u;
+        m_newline_offsets_buf = 0u;
+    }
+    if(m_filter_arena.len)
+    {
+        _RYML_CB_FREE(m_stack.m_callbacks, m_filter_arena.str, char, m_filter_arena.len);
+        m_filter_arena = {};
+    }
+    m_stack._free();
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_reset()
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_stack.size() == 1);
+    m_stack.clear();
+    m_stack.push({});
+    m_state = &m_stack.top();
+    m_state->reset(m_file.str, m_root_id);
+
+    m_key_tag_indentation = 0;
+    m_key_tag2_indentation = 0;
+    m_key_tag.clear();
+    m_key_tag2.clear();
+    m_val_tag_indentation = 0;
+    m_val_tag.clear();
+    m_key_anchor_was_before = false;
+    m_key_anchor_indentation = 0;
+    m_key_anchor.clear();
+    m_val_anchor_indentation = 0;
+    m_val_anchor.clear();
+
+    _mark_locations_dirty();
+}
+
+//-----------------------------------------------------------------------------
+template<class DumpFn>
+void Parser::_fmt_msg(DumpFn &&dumpfn) const
+{
+    auto const& lc = m_state->line_contents;
+    csubstr contents = lc.stripped;
+    if(contents.len)
+    {
+        // print the yaml src line
+        size_t offs = 3u + to_chars(substr{}, m_state->pos.line) + to_chars(substr{}, m_state->pos.col);
+        if(m_file.len)
+        {
+            _parse_dump(dumpfn, "{}:", m_file);
+            offs += m_file.len + 1;
+        }
+        _parse_dump(dumpfn, "{}:{}: ", m_state->pos.line, m_state->pos.col);
+        csubstr maybe_full_content = (contents.len < 80u ? contents : contents.first(80u));
+        csubstr maybe_ellipsis = (contents.len < 80u ? csubstr{} : csubstr("..."));
+        _parse_dump(dumpfn, "{}{}  (size={})\n", maybe_full_content, maybe_ellipsis, contents.len);
+        // highlight the remaining portion of the previous line
+        size_t firstcol = (size_t)(lc.rem.begin() - lc.full.begin());
+        size_t lastcol = firstcol + lc.rem.len;
+        for(size_t i = 0; i < offs + firstcol; ++i)
+            dumpfn(" ");
+        dumpfn("^");
+        for(size_t i = 1, e = (lc.rem.len < 80u ? lc.rem.len : 80u); i < e; ++i)
+            dumpfn("~");
+        _parse_dump(dumpfn, "{}  (cols {}-{})\n", maybe_ellipsis, firstcol+1, lastcol+1);
+    }
+    else
+    {
+        dumpfn("\n");
+    }
+
+#ifdef RYML_DBG
+    // next line: print the state flags
+    {
+        char flagbuf_[64];
+        _parse_dump(dumpfn, "top state: {}\n", _prfl(flagbuf_, m_state->flags));
+    }
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+template<class ...Args>
+void Parser::_err(csubstr fmt, Args const& C4_RESTRICT ...args) const
+{
+    char errmsg[RYML_ERRMSG_SIZE];
+    detail::_SubstrWriter writer(errmsg);
+    auto dumpfn = [&writer](csubstr s){ writer.append(s); };
+    _parse_dump(dumpfn, fmt, args...);
+    writer.append('\n');
+    _fmt_msg(dumpfn);
+    size_t len = writer.pos < RYML_ERRMSG_SIZE ? writer.pos : RYML_ERRMSG_SIZE;
+    m_tree->m_callbacks.m_error(errmsg, len, m_state->pos, m_tree->m_callbacks.m_user_data);
+}
+
+//-----------------------------------------------------------------------------
+#ifdef RYML_DBG
+template<class ...Args>
+void Parser::_dbg(csubstr fmt, Args const& C4_RESTRICT ...args) const
+{
+    auto dumpfn = [](csubstr s){ fwrite(s.str, 1, s.len, stdout); };
+    _parse_dump(dumpfn, fmt, args...);
+    dumpfn("\n");
+    _fmt_msg(dumpfn);
+}
+#endif
+
+//-----------------------------------------------------------------------------
+bool Parser::_finished_file() const
+{
+    bool ret = m_state->pos.offset >= m_buf.len;
+    if(ret)
+    {
+        _c4dbgp("finished file!!!");
+    }
+    return ret;
+}
+
+//-----------------------------------------------------------------------------
+bool Parser::_finished_line() const
+{
+    return m_state->line_contents.rem.empty();
+}
+
+//-----------------------------------------------------------------------------
+void Parser::parse_in_place(csubstr file, substr buf, Tree *t, size_t node_id)
+{
+    m_file = file;
+    m_buf = buf;
+    m_root_id = node_id;
+    m_tree = t;
+    _reset();
+    while( ! _finished_file())
+    {
+        _scan_line();
+        while( ! _finished_line())
+            _handle_line();
+        if(_finished_file())
+            break; // it may have finished because of multiline blocks
+        _line_ended();
+    }
+    _handle_finished_file();
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_handle_finished_file()
+{
+    _end_stream();
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_handle_line()
+{
+    _c4dbgq("\n-----------");
+    _c4dbgt("handling line={}, offset={}B", m_state->pos.line, m_state->pos.offset);
+    _RYML_CB_ASSERT(m_stack.m_callbacks,  ! m_state->line_contents.rem.empty());
+    if(has_any(RSEQ))
+    {
+        if(has_any(FLOW))
+        {
+            if(_handle_seq_flow())
+                return;
+        }
+        else
+        {
+            if(_handle_seq_blck())
+                return;
+        }
+    }
+    else if(has_any(RMAP))
+    {
+        if(has_any(FLOW))
+        {
+            if(_handle_map_flow())
+                return;
+        }
+        else
+        {
+            if(_handle_map_blck())
+                return;
+        }
+    }
+    else if(has_any(RUNK))
+    {
+        if(_handle_unk())
+            return;
+    }
+
+    if(_handle_top())
+        return;
+}
+
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_unk()
+{
+    _c4dbgp("handle_unk");
+
+    csubstr rem = m_state->line_contents.rem;
+    const bool start_as_child = (node(m_state) == nullptr);
+
+    if(C4_UNLIKELY(has_any(NDOC)))
+    {
+        if(rem == "---" || rem.begins_with("--- "))
+        {
+            _start_new_doc(rem);
+            return true;
+        }
+        auto trimmed = rem.triml(' ');
+        if(trimmed == "---" || trimmed.begins_with("--- "))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, rem.len >= trimmed.len);
+            _line_progressed(rem.len - trimmed.len);
+            _start_new_doc(trimmed);
+            _save_indentation();
+            return true;
+        }
+        else if(trimmed.begins_with("..."))
+        {
+            _end_stream();
+        }
+        else if(trimmed.first_of("#%") == csubstr::npos) // neither a doc nor a tag
+        {
+            _c4dbgpf("starting implicit doc to accomodate unexpected tokens: '{}'", rem);
+            size_t indref = m_state->indref;
+            _push_level();
+            _start_doc();
+            _set_indentation(indref);
+        }
+        _RYML_CB_ASSERT(m_stack.m_callbacks, !trimmed.empty());
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT|RSEQ|RMAP));
+    if(m_state->indref > 0)
+    {
+        csubstr ws = rem.left_of(rem.first_not_of(' '));
+        if(m_state->indref <= ws.len)
+        {
+            _c4dbgpf("skipping base indentation of {}", m_state->indref);
+            _line_progressed(m_state->indref);
+            rem = rem.sub(m_state->indref);
+        }
+    }
+
+    if(rem.begins_with("- ") _RYML_WITH_TAB_TOKENS( || rem.begins_with("-\t")))
+    {
+        _c4dbgpf("it's a seq (as_child={})", start_as_child);
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level();
+        _start_seq(start_as_child);
+        _save_indentation();
+        _line_progressed(2);
+        return true;
+    }
+    else if(rem == '-')
+    {
+        _c4dbgpf("it's a seq (as_child={})", start_as_child);
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level();
+        _start_seq(start_as_child);
+        _save_indentation();
+        _line_progressed(1);
+        return true;
+    }
+    else if(rem.begins_with('['))
+    {
+        _c4dbgpf("it's a seq, flow (as_child={})", start_as_child);
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level(/*explicit flow*/true);
+        _start_seq(start_as_child);
+        add_flags(FLOW);
+        _line_progressed(1);
+        return true;
+    }
+    else if(rem.begins_with('{'))
+    {
+        _c4dbgpf("it's a map, flow (as_child={})", start_as_child);
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level(/*explicit flow*/true);
+        _start_map(start_as_child);
+        addrem_flags(FLOW|RKEY, RVAL);
+        _line_progressed(1);
+        return true;
+    }
+    else if(rem.begins_with("? "))
+    {
+        _c4dbgpf("it's a map (as_child={}) + this key is complex", start_as_child);
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level();
+        _start_map(start_as_child);
+        addrem_flags(RKEY|QMRK, RVAL);
+        _save_indentation();
+        _line_progressed(2);
+        return true;
+    }
+    else if(rem.begins_with(": ") && !has_all(SSCL))
+    {
+        _c4dbgp("it's a map with an empty key");
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level();
+        _start_map(start_as_child);
+        _store_scalar_null(rem.str);
+        addrem_flags(RVAL, RKEY);
+        _save_indentation();
+        _line_progressed(2);
+        return true;
+    }
+    else if(rem == ':' && !has_all(SSCL))
+    {
+        _c4dbgp("it's a map with an empty key");
+        _move_key_anchor_to_val_anchor();
+        _move_key_tag_to_val_tag();
+        _push_level();
+        _start_map(start_as_child);
+        _store_scalar_null(rem.str);
+        addrem_flags(RVAL, RKEY);
+        _save_indentation();
+        _line_progressed(1);
+        return true;
+    }
+    else if(_handle_types())
+    {
+        return true;
+    }
+    else if(!rem.begins_with('*') && _handle_key_anchors_and_refs())
+    {
+        return true;
+    }
+    else if(has_all(SSCL))
+    {
+        _c4dbgpf("there's a stored scalar: '{}'", m_state->scalar);
+
+        csubstr saved_scalar;
+        bool is_quoted;
+        if(_scan_scalar(&saved_scalar, &is_quoted))
+        {
+            rem = m_state->line_contents.rem;
+            _c4dbgpf("... and there's also a scalar next! '{}'", saved_scalar);
+            if(rem.begins_with_any(" \t"))
+            {
+                size_t n = rem.first_not_of(" \t");
+                _c4dbgpf("skipping {} spaces/tabs", n);
+                rem = rem.sub(n);
+                _line_progressed(n);
+            }
+        }
+
+        _c4dbgpf("rem='{}'", rem);
+
+        if(rem.begins_with(", "))
+        {
+            _c4dbgpf("got a ',' -- it's a seq (as_child={})", start_as_child);
+            _start_seq(start_as_child);
+            add_flags(FLOW);
+            _append_val(_consume_scalar());
+            _line_progressed(2);
+        }
+        else if(rem.begins_with(','))
+        {
+            _c4dbgpf("got a ',' -- it's a seq (as_child={})", start_as_child);
+            _start_seq(start_as_child);
+            add_flags(FLOW);
+            _append_val(_consume_scalar());
+            _line_progressed(1);
+        }
+        else if(rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+        {
+            _c4dbgpf("got a ': ' -- it's a map (as_child={})", start_as_child);
+            _start_map_unk(start_as_child); // wait for the val scalar to append the key-val pair
+            _line_progressed(2);
+        }
+        else if(rem == ":" || rem.begins_with(":\"") || rem.begins_with(":'"))
+        {
+            if(rem == ":") { _c4dbgpf("got a ':' -- it's a map (as_child={})", start_as_child); }
+            else { _c4dbgpf("got a '{}' -- it's a map (as_child={})", rem.first(2), start_as_child); }
+            _start_map_unk(start_as_child); // wait for the val scalar to append the key-val pair
+            _line_progressed(1); // advance only 1
+        }
+        else if(rem.begins_with('}'))
+        {
+            if(!has_all(RMAP|FLOW))
+            {
+                _c4err("invalid token: not reading a map");
+            }
+            if(!has_all(SSCL))
+            {
+                _c4err("no scalar stored");
+            }
+            _append_key_val(saved_scalar);
+            _stop_map();
+            _line_progressed(1);
+        }
+        else if(rem.begins_with("..."))
+        {
+            _c4dbgp("got stream end '...'");
+            _end_stream();
+            _line_progressed(3);
+        }
+        else if(rem.begins_with('#'))
+        {
+            _c4dbgpf("it's a comment: '{}'", rem);
+            _scan_comment();
+            return true;
+        }
+        else if(_handle_key_anchors_and_refs())
+        {
+            return true;
+        }
+        else if(rem.begins_with(" ") || rem.begins_with("\t"))
+        {
+            size_t n = rem.first_not_of(" \t");
+            if(n == npos)
+                n = rem.len;
+            _c4dbgpf("has {} spaces/tabs, skip...", n);
+            _line_progressed(n);
+            return true;
+        }
+        else if(rem.empty())
+        {
+            // nothing to do
+        }
+        else if(rem == "---" || rem.begins_with("--- "))
+        {
+            _c4dbgp("caught ---: starting doc");
+            _start_new_doc(rem);
+            return true;
+        }
+        else if(rem.begins_with('%'))
+        {
+            _c4dbgp("caught a directive: ignoring...");
+            _line_progressed(rem.len);
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+
+        if( ! saved_scalar.empty())
+        {
+            _store_scalar(saved_scalar, is_quoted);
+        }
+
+        return true;
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks,  ! has_any(SSCL));
+        csubstr scalar;
+        size_t indentation = m_state->line_contents.indentation; // save
+        bool is_quoted;
+        if(_scan_scalar(&scalar, &is_quoted))
+        {
+            _c4dbgpf("got a {} scalar", is_quoted ? "quoted" : "");
+            rem = m_state->line_contents.rem;
+            {
+                size_t first = rem.first_not_of(" \t");
+                if(first && first != npos)
+                {
+                    _c4dbgpf("skip {} whitespace characters", first);
+                   _line_progressed(first);
+                   rem = rem.sub(first);
+                }
+            }
+            _store_scalar(scalar, is_quoted);
+            if(rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+            {
+                _c4dbgpf("got a ': ' next -- it's a map (as_child={})", start_as_child);
+                _push_level();
+                _start_map(start_as_child); // wait for the val scalar to append the key-val pair
+                _set_indentation(indentation);
+                _line_progressed(2); // call this AFTER saving the indentation
+            }
+            else if(rem == ":")
+            {
+                _c4dbgpf("got a ':' next -- it's a map (as_child={})", start_as_child);
+                _push_level();
+                _start_map(start_as_child); // wait for the val scalar to append the key-val pair
+                _set_indentation(indentation);
+                _line_progressed(1); // call this AFTER saving the indentation
+            }
+            else
+            {
+                // we still don't know whether it's a seq or a map
+                // so just store the scalar
+            }
+            return true;
+        }
+        else if(rem.begins_with_any(" \t"))
+        {
+            csubstr ws = rem.left_of(rem.first_not_of(" \t"));
+            rem = rem.right_of(ws);
+            if(has_all(RTOP) && rem.begins_with("---"))
+            {
+                _c4dbgp("there's a doc starting, and it's indented");
+                _set_indentation(ws.len);
+            }
+            _c4dbgpf("skipping {} spaces/tabs", ws.len);
+            _line_progressed(ws.len);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+C4_ALWAYS_INLINE void Parser::_skipchars(char c)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.rem.begins_with(c));
+    size_t pos = m_state->line_contents.rem.first_not_of(c);
+    if(pos == npos)
+        pos = m_state->line_contents.rem.len; // maybe the line is just whitespace
+    _c4dbgpf("skip {} '{}'", pos, c);
+    _line_progressed(pos);
+}
+
+template<size_t N>
+C4_ALWAYS_INLINE void Parser::_skipchars(const char (&chars)[N])
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.rem.begins_with_any(chars));
+    size_t pos = m_state->line_contents.rem.first_not_of(chars);
+    if(pos == npos)
+        pos = m_state->line_contents.rem.len; // maybe the line is just whitespace
+    _c4dbgpf("skip {} characters", pos);
+    _line_progressed(pos);
+}
+
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_seq_flow()
+{
+    _c4dbgpf("handle_seq_flow: node_id={} level={}", m_state->node_id, m_state->level);
+    csubstr rem = m_state->line_contents.rem;
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RSEQ|FLOW));
+
+    if(rem.begins_with(' '))
+    {
+        // with explicit flow, indentation does not matter
+        _c4dbgp("starts with spaces");
+        _skipchars(' ');
+        return true;
+    }
+    _RYML_WITH_TAB_TOKENS(else if(rem.begins_with('\t'))
+    {
+        _c4dbgp("starts with tabs");
+        _skipchars('\t');
+        return true;
+    })
+    else if(rem.begins_with('#'))
+    {
+        _c4dbgp("it's a comment");
+        rem = _scan_comment(); // also progresses the line
+        return true;
+    }
+    else if(rem.begins_with(']'))
+    {
+        _c4dbgp("end the sequence");
+        _pop_level();
+        _line_progressed(1);
+        if(has_all(RSEQIMAP))
+        {
+            _stop_seqimap();
+            _pop_level();
+        }
+        return true;
+    }
+
+    if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT));
+        bool is_quoted;
+        if(_scan_scalar(&rem, &is_quoted))
+        {
+            _c4dbgp("it's a scalar");
+            addrem_flags(RNXT, RVAL);
+            _append_val(rem, is_quoted);
+            return true;
+        }
+        else if(rem.begins_with('['))
+        {
+            _c4dbgp("val is a child seq");
+            addrem_flags(RNXT, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _start_seq();
+            add_flags(FLOW);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('{'))
+        {
+            _c4dbgp("val is a child map");
+            addrem_flags(RNXT, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _start_map();
+            addrem_flags(FLOW|RKEY, RVAL);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem == ':')
+        {
+            _c4dbgpf("found ':' -- there's an implicit map in the seq node[{}]", m_state->node_id);
+            _start_seqimap();
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+        {
+            _c4dbgpf("found ': ' -- there's an implicit map in the seq node[{}]", m_state->node_id);
+            _start_seqimap();
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with("? "))
+        {
+            _c4dbgpf("found '? ' -- there's an implicit map in the seq node[{}]", m_state->node_id);
+            _start_seqimap();
+            _line_progressed(2);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_any(SSCL) && m_state->scalar == "");
+            addrem_flags(QMRK|RKEY, RVAL|SSCL);
+            return true;
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_val_anchors_and_refs())
+        {
+            return true;
+        }
+        else if(rem.begins_with(", "))
+        {
+            _c4dbgp("found ',' -- the value was null");
+            _append_val_null(rem.str - 1);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with(','))
+        {
+            _c4dbgp("found ',' -- the value was null");
+            _append_val_null(rem.str - 1);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('\t'))
+        {
+            _skipchars('\t');
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+        if(rem.begins_with(", "))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(FLOW));
+            _c4dbgp("seq: expect next val");
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with(','))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(FLOW));
+            _c4dbgp("seq: expect next val");
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem == ':')
+        {
+            _c4dbgpf("found ':' -- there's an implicit map in the seq node[{}]", m_state->node_id);
+            _start_seqimap();
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+        {
+            _c4dbgpf("found ': ' -- there's an implicit map in the seq node[{}]", m_state->node_id);
+            _start_seqimap();
+            _line_progressed(2);
+            return true;
+        }
+        else
+        {
+            _c4err("was expecting a comma");
+        }
+    }
+    else
+    {
+        _c4err("internal error");
+    }
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_seq_blck()
+{
+    _c4dbgpf("handle_seq_impl: node_id={} level={}", m_state->node_id, m_state->level);
+    csubstr rem = m_state->line_contents.rem;
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RSEQ));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(FLOW));
+
+    if(rem.begins_with('#'))
+    {
+        _c4dbgp("it's a comment");
+        rem = _scan_comment();
+        return true;
+    }
+
+    if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+
+        if(_handle_indentation())
+            return true;
+
+        if(rem.begins_with("- ") _RYML_WITH_TAB_TOKENS( || rem.begins_with("-\t")))
+        {
+            _c4dbgp("expect another val");
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem == '-')
+        {
+            _c4dbgp("expect another val");
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with_any(" \t"))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks,  ! _at_line_begin());
+            _skipchars(" \t");
+            return true;
+        }
+        else if(rem.begins_with("..."))
+        {
+            _c4dbgp("got stream end '...'");
+            _end_stream();
+            _line_progressed(3);
+            return true;
+        }
+        else if(rem.begins_with("---"))
+        {
+            _c4dbgp("got document start '---'");
+            _start_new_doc(rem);
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        // there can be empty values
+        if(_handle_indentation())
+            return true;
+
+        csubstr s;
+        bool is_quoted;
+        if(_scan_scalar(&s, &is_quoted)) // this also progresses the line
+        {
+            _c4dbgpf("it's a{} scalar", is_quoted ? " quoted" : "");
+
+            rem = m_state->line_contents.rem;
+            if(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(rem.begins_with_any(" \t"), rem.begins_with(' ')))
+            {
+                _c4dbgp("skipping whitespace...");
+                size_t skip = rem.first_not_of(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+                if(skip == csubstr::npos)
+                    skip = rem.len; // maybe the line is just whitespace
+                _line_progressed(skip);
+                rem = rem.sub(skip);
+            }
+
+            _c4dbgpf("rem=[{}]~~~{}~~~", rem.len, rem);
+            if(!rem.begins_with('#') && (rem.ends_with(':') || rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t"))))
+            {
+                _c4dbgp("actually, the scalar is the first key of a map, and it opens a new scope");
+                if(m_key_anchor.empty())
+                    _move_val_anchor_to_key_anchor();
+                if(m_key_tag.empty())
+                    _move_val_tag_to_key_tag();
+                addrem_flags(RNXT, RVAL); // before _push_level! This prepares the current level for popping by setting it to RNXT
+                _push_level();
+                _start_map();
+                _store_scalar(s, is_quoted);
+                if( ! _maybe_set_indentation_from_anchor_or_tag())
+                {
+                    _c4dbgpf("set indentation from scalar: {}", m_state->scalar_col);
+                    _set_indentation(m_state->scalar_col); // this is the column where the scalar starts
+                }
+                _move_key_tag2_to_key_tag();
+                addrem_flags(RVAL, RKEY);
+                _line_progressed(1);
+            }
+            else
+            {
+                _c4dbgp("appending val to current seq");
+                _append_val(s, is_quoted);
+                addrem_flags(RNXT, RVAL);
+            }
+            return true;
+        }
+        else if(rem.begins_with("- ") _RYML_WITH_TAB_TOKENS( || rem.begins_with("-\t")))
+        {
+            if(_rval_dash_start_or_continue_seq())
+                _line_progressed(2);
+            return true;
+        }
+        else if(rem == '-')
+        {
+            if(_rval_dash_start_or_continue_seq())
+                _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('['))
+        {
+            _c4dbgp("val is a child seq, flow");
+            addrem_flags(RNXT, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _start_seq();
+            add_flags(FLOW);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('{'))
+        {
+            _c4dbgp("val is a child map, flow");
+            addrem_flags(RNXT, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _start_map();
+            addrem_flags(FLOW|RKEY, RVAL);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with("? "))
+        {
+            _c4dbgp("val is a child map + this key is complex");
+            addrem_flags(RNXT, RVAL); // before _push_level!
+            _push_level();
+            _start_map();
+            addrem_flags(QMRK|RKEY, RVAL);
+            _save_indentation();
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with(' '))
+        {
+            csubstr spc = rem.left_of(rem.first_not_of(' '));
+            if(_at_line_begin())
+            {
+                _c4dbgpf("skipping value indentation: {} spaces", spc.len);
+                _line_progressed(spc.len);
+                return true;
+            }
+            else
+            {
+                _c4dbgpf("skipping {} spaces", spc.len);
+                _line_progressed(spc.len);
+                return true;
+            }
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_val_anchors_and_refs())
+        {
+            return true;
+        }
+        /* pathological case:
+         * - &key : val
+         * - &key :
+         * - : val
+         */
+        else if((!has_all(SSCL)) &&
+                (rem.begins_with(": ") || rem.left_of(rem.find("#")).trimr("\t") == ":"))
+        {
+            if(!m_val_anchor.empty() || !m_val_tag.empty())
+            {
+                _c4dbgp("val is a child map + this key is empty, with anchors or tags");
+                addrem_flags(RNXT, RVAL); // before _push_level!
+                _move_val_tag_to_key_tag();
+                _move_val_anchor_to_key_anchor();
+                _push_level();
+                _start_map();
+                _store_scalar_null(rem.str);
+                addrem_flags(RVAL, RKEY);
+                RYML_CHECK(_maybe_set_indentation_from_anchor_or_tag()); // one of them must exist
+                _line_progressed(rem.begins_with(": ") ? 2u : 1u);
+                return true;
+            }
+            else
+            {
+                _c4dbgp("val is a child map + this key is empty, no anchors or tags");
+                addrem_flags(RNXT, RVAL); // before _push_level!
+                size_t ind = m_state->indref;
+                _push_level();
+                _start_map();
+                _store_scalar_null(rem.str);
+                addrem_flags(RVAL, RKEY);
+                _c4dbgpf("set indentation from map anchor: {}", ind + 2);
+                _set_indentation(ind + 2); // this is the column where the map starts
+                _line_progressed(rem.begins_with(": ") ? 2u : 1u);
+                return true;
+            }
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+
+bool Parser::_rval_dash_start_or_continue_seq()
+{
+    size_t ind = m_state->line_contents.current_col();
+    _RYML_CB_ASSERT(m_stack.m_callbacks, ind >= m_state->indref);
+    size_t delta_ind = ind - m_state->indref;
+    if( ! delta_ind)
+    {
+        _c4dbgp("prev val was empty");
+        addrem_flags(RNXT, RVAL);
+        _append_val_null(&m_state->line_contents.full[ind]);
+        return false;
+    }
+    _c4dbgp("val is a nested seq, indented");
+    addrem_flags(RNXT, RVAL); // before _push_level!
+    _push_level();
+    _start_seq();
+    _save_indentation();
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_map_flow()
+{
+    // explicit flow, ie, inside {}, separated by commas
+    _c4dbgpf("handle_map_flow: node_id={}  level={}", m_state->node_id, m_state->level);
+    csubstr rem = m_state->line_contents.rem;
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RMAP|FLOW));
+
+    if(rem.begins_with(' '))
+    {
+        // with explicit flow, indentation does not matter
+        _c4dbgp("starts with spaces");
+        _skipchars(' ');
+        return true;
+    }
+    _RYML_WITH_TAB_TOKENS(else if(rem.begins_with('\t'))
+    {
+        // with explicit flow, indentation does not matter
+        _c4dbgp("starts with tabs");
+        _skipchars('\t');
+        return true;
+    })
+    else if(rem.begins_with('#'))
+    {
+        _c4dbgp("it's a comment");
+        rem = _scan_comment(); // also progresses the line
+        return true;
+    }
+    else if(rem.begins_with('}'))
+    {
+        _c4dbgp("end the map");
+        if(has_all(SSCL))
+        {
+            _c4dbgp("the last val was null");
+            _append_key_val_null(rem.str - 1);
+            rem_flags(RVAL);
+        }
+        _pop_level();
+        _line_progressed(1);
+        if(has_all(RSEQIMAP))
+        {
+            _c4dbgp("stopping implicitly nested 1x map");
+            _stop_seqimap();
+            _pop_level();
+        }
+        return true;
+    }
+
+    if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RSEQIMAP));
+
+        if(rem.begins_with(", "))
+        {
+            _c4dbgp("seq: expect next keyval");
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with(','))
+        {
+            _c4dbgp("seq: expect next keyval");
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(1);
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RKEY))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+
+        bool is_quoted;
+        if(has_none(SSCL) && _scan_scalar(&rem, &is_quoted))
+        {
+            _c4dbgp("it's a scalar");
+            _store_scalar(rem, is_quoted);
+            rem = m_state->line_contents.rem;
+            csubstr trimmed = rem.triml(" \t");
+            if(trimmed.len && (trimmed.begins_with(": ") || trimmed.begins_with_any(":,}") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t"))))
+            {
+                _RYML_CB_ASSERT(m_stack.m_callbacks, trimmed.str >= rem.str);
+                size_t num = static_cast<size_t>(trimmed.str - rem.str);
+                _c4dbgpf("trimming {} whitespace after the scalar: '{}' --> '{}'", num, rem, rem.sub(num));
+                rem = rem.sub(num);
+                _line_progressed(num);
+            }
+        }
+
+        if(rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+        {
+            _c4dbgp("wait for val");
+            addrem_flags(RVAL, RKEY|QMRK);
+            _line_progressed(2);
+            if(!has_all(SSCL))
+            {
+                _c4dbgp("no key was found, defaulting to empty key ''");
+                _store_scalar_null(rem.str);
+            }
+            return true;
+        }
+        else if(rem == ':')
+        {
+            _c4dbgp("wait for val");
+            addrem_flags(RVAL, RKEY|QMRK);
+            _line_progressed(1);
+            if(!has_all(SSCL))
+            {
+                _c4dbgp("no key was found, defaulting to empty key ''");
+                _store_scalar_null(rem.str);
+            }
+            return true;
+        }
+        else if(rem.begins_with('?'))
+        {
+            _c4dbgp("complex key");
+            add_flags(QMRK);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with(','))
+        {
+            _c4dbgp("prev scalar was a key with null value");
+            _append_key_val_null(rem.str - 1);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('}'))
+        {
+            _c4dbgp("map terminates after a key...");
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(SSCL));
+            _c4dbgp("the last val was null");
+            _append_key_val_null(rem.str - 1);
+            rem_flags(RVAL);
+            if(has_all(RSEQIMAP))
+            {
+                _c4dbgp("stopping implicitly nested 1x map");
+                _stop_seqimap();
+                _pop_level();
+            }
+            _pop_level();
+            _line_progressed(1);
+            return true;
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_key_anchors_and_refs())
+        {
+            return true;
+        }
+        else if(rem == "")
+        {
+            return true;
+        }
+        else
+        {
+            size_t pos = rem.first_not_of(" \t");
+            if(pos == csubstr::npos)
+               pos = 0;
+            rem = rem.sub(pos);
+            if(rem.begins_with(':'))
+            {
+                _c4dbgp("wait for val");
+                addrem_flags(RVAL, RKEY|QMRK);
+                _line_progressed(pos + 1);
+                if(!has_all(SSCL))
+                {
+                    _c4dbgp("no key was found, defaulting to empty key ''");
+                    _store_scalar_null(rem.str);
+                }
+                return true;
+            }
+            else if(rem.begins_with('#'))
+            {
+                _c4dbgp("it's a comment");
+                _line_progressed(pos);
+                rem = _scan_comment(); // also progresses the line
+                return true;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(SSCL));
+        bool is_quoted;
+        if(_scan_scalar(&rem, &is_quoted))
+        {
+            _c4dbgp("it's a scalar");
+            addrem_flags(RNXT, RVAL|RKEY);
+            _append_key_val(rem, is_quoted);
+            if(has_all(RSEQIMAP))
+            {
+                _c4dbgp("stopping implicitly nested 1x map");
+                _stop_seqimap();
+                _pop_level();
+            }
+            return true;
+        }
+        else if(rem.begins_with('['))
+        {
+            _c4dbgp("val is a child seq");
+            addrem_flags(RNXT, RVAL|RKEY); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _move_scalar_from_top();
+            _start_seq();
+            add_flags(FLOW);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('{'))
+        {
+            _c4dbgp("val is a child map");
+            addrem_flags(RNXT, RVAL|RKEY); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _move_scalar_from_top();
+            _start_map();
+            addrem_flags(FLOW|RKEY, RNXT|RVAL);
+            _line_progressed(1);
+            return true;
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_val_anchors_and_refs())
+        {
+            return true;
+        }
+        else if(rem.begins_with(','))
+        {
+            _c4dbgp("appending empty val");
+            _append_key_val_null(rem.str - 1);
+            addrem_flags(RKEY, RVAL);
+            _line_progressed(1);
+            if(has_any(RSEQIMAP))
+            {
+                _c4dbgp("stopping implicitly nested 1x map");
+                _stop_seqimap();
+                _pop_level();
+            }
+            return true;
+        }
+        else if(has_any(RSEQIMAP) && rem.begins_with(']'))
+        {
+            _c4dbgp("stopping implicitly nested 1x map");
+            if(has_any(SSCL))
+            {
+                _append_key_val_null(rem.str - 1);
+            }
+            _stop_seqimap();
+            _pop_level();
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else
+    {
+        _c4err("internal error");
+    }
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_map_blck()
+{
+    _c4dbgpf("handle_map_impl: node_id={}  level={}", m_state->node_id, m_state->level);
+    csubstr rem = m_state->line_contents.rem;
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RMAP));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(FLOW));
+
+    if(rem.begins_with('#'))
+    {
+        _c4dbgp("it's a comment");
+        rem = _scan_comment();
+        return true;
+    }
+
+    if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+        // actually, we don't need RNXT in indent-based maps.
+        addrem_flags(RKEY, RNXT);
+    }
+
+    if(_handle_indentation())
+        return true;
+
+    if(has_any(RKEY))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RVAL));
+
+        _c4dbgp("read scalar?");
+        bool is_quoted;
+        if(_scan_scalar(&rem, &is_quoted)) // this also progresses the line
+        {
+            _c4dbgpf("it's a{} scalar", is_quoted ? " quoted" : "");
+            if(has_all(QMRK|SSCL))
+            {
+                _c4dbgpf("current key is QMRK; SSCL is set. so take store scalar='{}' as key and add an empty val", m_state->scalar);
+                _append_key_val_null(rem.str - 1);
+            }
+            _store_scalar(rem, is_quoted);
+            if(has_all(QMRK|RSET))
+            {
+                _c4dbgp("it's a complex key, so use null value '~'");
+                _append_key_val_null(rem.str);
+            }
+            rem = m_state->line_contents.rem;
+
+            if(rem.begins_with(':'))
+            {
+                _c4dbgp("wait for val");
+                addrem_flags(RVAL, RKEY|QMRK);
+                _line_progressed(1);
+                rem = m_state->line_contents.rem;
+                if(rem.begins_with_any(" \t"))
+                {
+                    _RYML_CB_ASSERT(m_stack.m_callbacks,  ! _at_line_begin());
+                    rem = rem.left_of(rem.first_not_of(" \t"));
+                    _c4dbgpf("skip {} spaces/tabs", rem.len);
+                    _line_progressed(rem.len);
+                }
+            }
+            return true;
+        }
+        else if(rem.begins_with_any(" \t"))
+        {
+            size_t pos = rem.first_not_of(" \t");
+            if(pos == npos)
+                pos = rem.len;
+            _c4dbgpf("skip {} spaces/tabs", pos);
+            _line_progressed(pos);
+            return true;
+        }
+        else if(rem == '?' || rem.begins_with("? "))
+        {
+            _c4dbgp("it's a complex key");
+            _line_progressed(rem.begins_with("? ") ? 2u : 1u);
+            if(has_any(SSCL))
+                _append_key_val_null(rem.str - 1);
+            add_flags(QMRK);
+            return true;
+        }
+        else if(has_all(QMRK) && rem.begins_with(':'))
+        {
+            _c4dbgp("complex key finished");
+            if(!has_any(SSCL))
+                _store_scalar_null(rem.str);
+            addrem_flags(RVAL, RKEY|QMRK);
+            _line_progressed(1);
+            rem = m_state->line_contents.rem;
+            if(rem.begins_with(' '))
+            {
+                _RYML_CB_ASSERT(m_stack.m_callbacks,  ! _at_line_begin());
+                _skipchars(' ');
+            }
+            return true;
+        }
+        else if(rem == ':' || rem.begins_with(": ") _RYML_WITH_TAB_TOKENS( || rem.begins_with(":\t")))
+        {
+            _c4dbgp("key finished");
+            if(!has_all(SSCL))
+            {
+                _c4dbgp("key was empty...");
+                _store_scalar_null(rem.str);
+                rem_flags(QMRK);
+            }
+            addrem_flags(RVAL, RKEY);
+            _line_progressed(rem == ':' ? 1 : 2);
+            return true;
+        }
+        else if(rem.begins_with("..."))
+        {
+            _c4dbgp("end current document");
+            _end_stream();
+            _line_progressed(3);
+            return true;
+        }
+        else if(rem.begins_with("---"))
+        {
+            _c4dbgp("start new document '---'");
+            _start_new_doc(rem);
+            return true;
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_key_anchors_and_refs())
+        {
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RKEY));
+
+        csubstr s;
+        bool is_quoted;
+        if(_scan_scalar(&s, &is_quoted)) // this also progresses the line
+        {
+            _c4dbgpf("it's a{} scalar", is_quoted ? " quoted" : "");
+
+            rem = m_state->line_contents.rem;
+
+            if(rem.begins_with(": "))
+            {
+                _c4dbgp("actually, the scalar is the first key of a map");
+                addrem_flags(RKEY, RVAL); // before _push_level! This prepares the current level for popping by setting it to RNXT
+                _push_level();
+                _move_scalar_from_top();
+                _move_val_anchor_to_key_anchor();
+                _start_map();
+                _save_indentation(m_state->scalar_col);
+                addrem_flags(RVAL, RKEY);
+                _line_progressed(2);
+            }
+            else if(rem.begins_with(':'))
+            {
+                _c4dbgp("actually, the scalar is the first key of a map, and it opens a new scope");
+                addrem_flags(RKEY, RVAL); // before _push_level! This prepares the current level for popping by setting it to RNXT
+                _push_level();
+                _move_scalar_from_top();
+                _move_val_anchor_to_key_anchor();
+                _start_map();
+                _save_indentation(/*behind*/s.len);
+                addrem_flags(RVAL, RKEY);
+                _line_progressed(1);
+            }
+            else
+            {
+                _c4dbgp("appending keyval to current map");
+                _append_key_val(s, is_quoted);
+                addrem_flags(RKEY, RVAL);
+            }
+            return true;
+        }
+        else if(rem.begins_with("- ") _RYML_WITH_TAB_TOKENS( || rem.begins_with("-\t")))
+        {
+            _c4dbgp("val is a nested seq, indented");
+            addrem_flags(RKEY, RVAL); // before _push_level!
+            _push_level();
+            _move_scalar_from_top();
+            _start_seq();
+            _save_indentation();
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem == '-')
+        {
+            _c4dbgp("maybe a seq. start unknown, indented");
+            _start_unk();
+            _save_indentation();
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('['))
+        {
+            _c4dbgp("val is a child seq, flow");
+            addrem_flags(RKEY, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _move_scalar_from_top();
+            _start_seq();
+            add_flags(FLOW);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with('{'))
+        {
+            _c4dbgp("val is a child map, flow");
+            addrem_flags(RKEY, RVAL); // before _push_level!
+            _push_level(/*explicit flow*/true);
+            _move_scalar_from_top();
+            _start_map();
+            addrem_flags(FLOW|RKEY, RVAL);
+            _line_progressed(1);
+            return true;
+        }
+        else if(rem.begins_with(' '))
+        {
+            csubstr spc = rem.left_of(rem.first_not_of(' '));
+            if(_at_line_begin())
+            {
+                _c4dbgpf("skipping value indentation: {} spaces", spc.len);
+                _line_progressed(spc.len);
+                return true;
+            }
+            else
+            {
+                _c4dbgpf("skipping {} spaces", spc.len);
+                _line_progressed(spc.len);
+                return true;
+            }
+        }
+        else if(_handle_types())
+        {
+            return true;
+        }
+        else if(_handle_val_anchors_and_refs())
+        {
+            return true;
+        }
+        else if(rem.begins_with("--- ") || rem == "---" || rem.begins_with("---\t"))
+        {
+            _start_new_doc(rem);
+            return true;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else
+    {
+        _c4err("internal error");
+    }
+
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+bool Parser::_handle_top()
+{
+    _c4dbgp("handle_top");
+    csubstr rem = m_state->line_contents.rem;
+
+    if(rem.begins_with('#'))
+    {
+        _c4dbgp("a comment line");
+        _scan_comment();
+        return true;
+    }
+
+    csubstr trimmed = rem.triml(' ');
+
+    if(trimmed.begins_with('%'))
+    {
+        _handle_directive(trimmed);
+        _line_progressed(rem.len);
+        return true;
+    }
+    else if(trimmed.begins_with("--- ") || trimmed == "---" || trimmed.begins_with("---\t"))
+    {
+        _start_new_doc(rem);
+        if(trimmed.len < rem.len)
+        {
+            _line_progressed(rem.len - trimmed.len);
+            _save_indentation();
+        }
+        return true;
+    }
+    else if(trimmed.begins_with("..."))
+    {
+        _c4dbgp("end current document");
+        _end_stream();
+        if(trimmed.len < rem.len)
+        {
+            _line_progressed(rem.len - trimmed.len);
+        }
+        _line_progressed(3);
+        return true;
+    }
+    else
+    {
+        _c4err("parse error");
+    }
+
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+
+bool Parser::_handle_key_anchors_and_refs()
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, !has_any(RVAL));
+    const csubstr rem = m_state->line_contents.rem;
+    if(rem.begins_with('&'))
+    {
+        _c4dbgp("found a key anchor!!!");
+        if(has_all(QMRK|SSCL))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_any(RKEY));
+            _c4dbgp("there is a stored key, so this anchor is for the next element");
+            _append_key_val_null(rem.str - 1);
+            rem_flags(QMRK);
+            return true;
+        }
+        csubstr anchor = rem.left_of(rem.first_of(' '));
+        _line_progressed(anchor.len);
+        anchor = anchor.sub(1); // skip the first character
+        _move_key_anchor_to_val_anchor();
+        _c4dbgpf("key anchor value: '{}'", anchor);
+        m_key_anchor = anchor;
+        m_key_anchor_indentation = m_state->line_contents.current_col(rem);
+        return true;
+    }
+    else if(C4_UNLIKELY(rem.begins_with('*')))
+    {
+        _c4err("not implemented - this should have been catched elsewhere");
+        C4_NEVER_REACH();
+        return false;
+    }
+    return false;
+}
+
+bool Parser::_handle_val_anchors_and_refs()
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, !has_any(RKEY));
+    const csubstr rem = m_state->line_contents.rem;
+    if(rem.begins_with('&'))
+    {
+        csubstr anchor = rem.left_of(rem.first_of(' '));
+        _line_progressed(anchor.len);
+        anchor = anchor.sub(1); // skip the first character
+        _c4dbgpf("val: found an anchor: '{}', indentation={}!!!", anchor, m_state->line_contents.current_col(rem));
+        if(m_val_anchor.empty())
+        {
+            _c4dbgpf("save val anchor: '{}'", anchor);
+            m_val_anchor = anchor;
+            m_val_anchor_indentation = m_state->line_contents.current_col(rem);
+        }
+        else
+        {
+            _c4dbgpf("there is a pending val anchor '{}'", m_val_anchor);
+            if(m_tree->is_seq(m_state->node_id))
+            {
+                if(m_tree->has_children(m_state->node_id))
+                {
+                    _c4dbgpf("current node={} is a seq, has {} children", m_state->node_id, m_tree->num_children(m_state->node_id));
+                    _c4dbgpf("... so take the new one as a key anchor '{}'", anchor);
+                    m_key_anchor = anchor;
+                    m_key_anchor_indentation = m_state->line_contents.current_col(rem);
+                }
+                else
+                {
+                    _c4dbgpf("current node={} is a seq, has no children", m_state->node_id);
+                    if(m_tree->has_val_anchor(m_state->node_id))
+                    {
+                        _c4dbgpf("... node={} already has val anchor: '{}'", m_state->node_id, m_tree->val_anchor(m_state->node_id));
+                        _c4dbgpf("... so take the new one as a key anchor '{}'", anchor);
+                        m_key_anchor = anchor;
+                        m_key_anchor_indentation = m_state->line_contents.current_col(rem);
+                    }
+                    else
+                    {
+                        _c4dbgpf("... so set pending val anchor: '{}' on current node {}", m_val_anchor, m_state->node_id);
+                        m_tree->set_val_anchor(m_state->node_id, m_val_anchor);
+                        m_val_anchor = anchor;
+                        m_val_anchor_indentation = m_state->line_contents.current_col(rem);
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    else if(C4_UNLIKELY(rem.begins_with('*')))
+    {
+        _c4err("not implemented - this should have been catched elsewhere");
+        C4_NEVER_REACH();
+        return false;
+    }
+    return false;
+}
+
+void Parser::_move_key_anchor_to_val_anchor()
+{
+    if(m_key_anchor.empty())
+        return;
+    _c4dbgpf("move current key anchor to val slot: key='{}' -> val='{}'", m_key_anchor, m_val_anchor);
+    if(!m_val_anchor.empty())
+        _c4err("triple-pending anchor");
+    m_val_anchor = m_key_anchor;
+    m_val_anchor_indentation = m_key_anchor_indentation;
+    m_key_anchor = {};
+    m_key_anchor_indentation = {};
+}
+
+void Parser::_move_val_anchor_to_key_anchor()
+{
+    if(m_val_anchor.empty())
+        return;
+    if(!_token_is_from_this_line(m_val_anchor))
+        return;
+    _c4dbgpf("move current val anchor to key slot: key='{}' <- val='{}'", m_key_anchor, m_val_anchor);
+    if(!m_key_anchor.empty())
+        _c4err("triple-pending anchor");
+    m_key_anchor = m_val_anchor;
+    m_key_anchor_indentation = m_val_anchor_indentation;
+    m_val_anchor = {};
+    m_val_anchor_indentation = {};
+}
+
+void Parser::_move_key_tag_to_val_tag()
+{
+    if(m_key_tag.empty())
+        return;
+    _c4dbgpf("move key tag to val tag: key='{}' -> val='{}'", m_key_tag, m_val_tag);
+    m_val_tag = m_key_tag;
+    m_val_tag_indentation = m_key_tag_indentation;
+    m_key_tag.clear();
+    m_key_tag_indentation = 0;
+}
+
+void Parser::_move_val_tag_to_key_tag()
+{
+    if(m_val_tag.empty())
+        return;
+    if(!_token_is_from_this_line(m_val_tag))
+        return;
+    _c4dbgpf("move val tag to key tag: key='{}' <- val='{}'", m_key_tag, m_val_tag);
+    m_key_tag = m_val_tag;
+    m_key_tag_indentation = m_val_tag_indentation;
+    m_val_tag.clear();
+    m_val_tag_indentation = 0;
+}
+
+void Parser::_move_key_tag2_to_key_tag()
+{
+    if(m_key_tag2.empty())
+        return;
+    _c4dbgpf("move key tag2 to key tag: key='{}' <- key2='{}'", m_key_tag, m_key_tag2);
+    m_key_tag = m_key_tag2;
+    m_key_tag_indentation = m_key_tag2_indentation;
+    m_key_tag2.clear();
+    m_key_tag2_indentation = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+
+bool Parser::_handle_types()
+{
+    csubstr rem = m_state->line_contents.rem.triml(' ');
+    csubstr t;
+
+    if(rem.begins_with("!!"))
+    {
+        _c4dbgp("begins with '!!'");
+        t = rem.left_of(rem.first_of(" ,"));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, t.len >= 2);
+        //t = t.sub(2);
+        if(t == "!!set")
+            add_flags(RSET);
+    }
+    else if(rem.begins_with("!<"))
+    {
+        _c4dbgp("begins with '!<'");
+        t = rem.left_of(rem.first_of('>'), true);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, t.len >= 2);
+        //t = t.sub(2, t.len-1);
+    }
+    else if(rem.begins_with("!h!"))
+    {
+        _c4dbgp("begins with '!h!'");
+        t = rem.left_of(rem.first_of(' '));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, t.len >= 3);
+        //t = t.sub(3);
+    }
+    else if(rem.begins_with('!'))
+    {
+        _c4dbgp("begins with '!'");
+        t = rem.left_of(rem.first_of(' '));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, t.len >= 1);
+        //t = t.sub(1);
+    }
+
+    if(t.empty())
+        return false;
+
+    if(has_all(QMRK|SSCL))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_any(RKEY));
+        _c4dbgp("there is a stored key, so this tag is for the next element");
+        _append_key_val_null(rem.str - 1);
+        rem_flags(QMRK);
+    }
+
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    const char *tag_beginning = rem.str;
+    #endif
+    size_t tag_indentation = m_state->line_contents.current_col(t);
+    _c4dbgpf("there was a tag: '{}', indentation={}", t, tag_indentation);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, t.end() > m_state->line_contents.rem.begin());
+    _line_progressed(static_cast<size_t>(t.end() - m_state->line_contents.rem.begin()));
+    {
+        size_t pos = m_state->line_contents.rem.first_not_of(" \t");
+        if(pos != csubstr::npos)
+            _line_progressed(pos);
+    }
+
+    if(has_all(RMAP|RKEY))
+    {
+        _c4dbgpf("saving map key tag '{}'", t);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_key_tag.empty());
+        m_key_tag = t;
+        m_key_tag_indentation = tag_indentation;
+    }
+    else if(has_all(RMAP|RVAL))
+    {
+        /* foo: !!str
+         * !!str : bar  */
+        rem = m_state->line_contents.rem;
+        rem = rem.left_of(rem.find("#"));
+        rem = rem.trimr(" \t");
+        _c4dbgpf("rem='{}'", rem);
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        if(rem == ':' || rem.begins_with(": "))
+        {
+            _c4dbgp("the last val was null, and this is a tag from a null key");
+            _append_key_val_null(tag_beginning - 1);
+            _store_scalar_null(rem.str - 1);
+            // do not change the flag to key, it is ~
+            _RYML_CB_ASSERT(m_stack.m_callbacks, rem.begin() > m_state->line_contents.rem.begin());
+            size_t token_len = rem == ':' ? 1 : 2;
+            _line_progressed(static_cast<size_t>(token_len + rem.begin() - m_state->line_contents.rem.begin()));
+        }
+        #endif
+        _c4dbgpf("saving map val tag '{}'", t);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_val_tag.empty());
+        m_val_tag = t;
+        m_val_tag_indentation = tag_indentation;
+    }
+    else if(has_all(RSEQ|RVAL) || has_all(RTOP|RUNK|NDOC))
+    {
+        if(m_val_tag.empty())
+        {
+            _c4dbgpf("saving seq/doc val tag '{}'", t);
+            m_val_tag = t;
+            m_val_tag_indentation = tag_indentation;
+        }
+        else
+        {
+            _c4dbgpf("saving seq/doc key tag '{}'", t);
+            m_key_tag = t;
+            m_key_tag_indentation = tag_indentation;
+        }
+    }
+    else if(has_all(RTOP|RUNK) || has_any(RUNK))
+    {
+        rem = m_state->line_contents.rem;
+        rem = rem.left_of(rem.find("#"));
+        rem = rem.trimr(" \t");
+        if(rem.empty())
+        {
+            _c4dbgpf("saving val tag '{}'", t);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_val_tag.empty());
+            m_val_tag = t;
+            m_val_tag_indentation = tag_indentation;
+        }
+        else
+        {
+            _c4dbgpf("saving key tag '{}'", t);
+            if(m_key_tag.empty())
+            {
+                m_key_tag = t;
+                m_key_tag_indentation = tag_indentation;
+            }
+            else
+            {
+                /* handle this case:
+                 * !!str foo: !!map
+                 *   !!int 1: !!float 20.0
+                 *   !!int 3: !!float 40.0
+                 *
+                 * (m_key_tag would be !!str and m_key_tag2 would be !!int)
+                 */
+                m_key_tag2 = t;
+                m_key_tag2_indentation = tag_indentation;
+            }
+        }
+    }
+    else
+    {
+        _c4err("internal error");
+    }
+
+    if(m_val_tag.not_empty())
+    {
+        YamlTag_e tag = to_tag(t);
+        if(tag == TAG_STR)
+        {
+            _c4dbgpf("tag '{}' is a str-type tag", t);
+            if(has_all(RTOP|RUNK|NDOC))
+            {
+                _c4dbgpf("docval. slurping the string. pos={}", m_state->pos.offset);
+                csubstr scalar = _slurp_doc_scalar();
+                _c4dbgpf("docval. after slurp: {}, at node {}: '{}'", m_state->pos.offset, m_state->node_id, scalar);
+                m_tree->to_val(m_state->node_id, scalar, DOC);
+                _c4dbgpf("docval. val tag {} -> {}", m_val_tag, normalize_tag(m_val_tag));
+                m_tree->set_val_tag(m_state->node_id, normalize_tag(m_val_tag));
+                m_val_tag.clear();
+                if(!m_val_anchor.empty())
+                {
+                    _c4dbgpf("setting val anchor[{}]='{}'", m_state->node_id, m_val_anchor);
+                    m_tree->set_val_anchor(m_state->node_id, m_val_anchor);
+                    m_val_anchor.clear();
+                }
+                _end_stream();
+            }
+        }
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_slurp_doc_scalar()
+{
+    csubstr s = m_state->line_contents.rem;
+    size_t pos = m_state->pos.offset;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.full.find("---") != csubstr::npos);
+    _c4dbgpf("slurp 0 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+    if(s.len == 0)
+    {
+        _line_ended();
+        _scan_line();
+        s = m_state->line_contents.rem;
+        pos = m_state->pos.offset;
+    }
+
+    size_t skipws = s.first_not_of(" \t");
+    _c4dbgpf("slurp 1 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+    if(skipws != npos)
+    {
+        _line_progressed(skipws);
+        s = m_state->line_contents.rem;
+        pos = m_state->pos.offset;
+        _c4dbgpf("slurp 2 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_val_anchor.empty());
+    _handle_val_anchors_and_refs();
+    if(!m_val_anchor.empty())
+    {
+        s = m_state->line_contents.rem;
+        skipws = s.first_not_of(" \t");
+        if(skipws != npos)
+        {
+            _line_progressed(skipws);
+        }
+        s = m_state->line_contents.rem;
+        pos = m_state->pos.offset;
+        _c4dbgpf("slurp 3 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+    }
+
+    if(s.begins_with('\''))
+    {
+        m_state->scalar_col = m_state->line_contents.current_col(s);
+        return _scan_squot_scalar();
+    }
+    else if(s.begins_with('"'))
+    {
+        m_state->scalar_col = m_state->line_contents.current_col(s);
+        return _scan_dquot_scalar();
+    }
+    else if(s.begins_with('|') || s.begins_with('>'))
+    {
+        return _scan_block();
+    }
+
+    _c4dbgpf("slurp 4 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+
+    m_state->scalar_col = m_state->line_contents.current_col(s);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.end() >= m_buf.begin() + pos);
+    _line_progressed(static_cast<size_t>(s.end() - (m_buf.begin() + pos)));
+
+    _c4dbgpf("slurp 5 '{}'. REM='{}'", s, m_buf.sub(m_state->pos.offset));
+
+    if(_at_line_end())
+    {
+        _c4dbgpf("at line end. curr='{}'", s);
+        s = _extend_scanned_scalar(s);
+    }
+
+    _c4dbgpf("scalar was '{}'", s);
+
+    return s;
+}
+
+//-----------------------------------------------------------------------------
+bool Parser::_scan_scalar(csubstr *C4_RESTRICT scalar, bool *C4_RESTRICT quoted)
+{
+    csubstr s = m_state->line_contents.rem;
+    if(s.len == 0)
+        return false;
+    s = s.trim(" \t");
+    if(s.len == 0)
+        return false;
+
+    if(s.begins_with('\''))
+    {
+        _c4dbgp("got a ': scanning single-quoted scalar");
+        m_state->scalar_col = m_state->line_contents.current_col(s);
+        *scalar = _scan_squot_scalar();
+        *quoted = true;
+        return true;
+    }
+    else if(s.begins_with('"'))
+    {
+        _c4dbgp("got a \": scanning double-quoted scalar");
+        m_state->scalar_col = m_state->line_contents.current_col(s);
+        *scalar = _scan_dquot_scalar();
+        *quoted = true;
+        return true;
+    }
+    else if(s.begins_with('|') || s.begins_with('>'))
+    {
+        *scalar = _scan_block();
+        *quoted = false;
+        return true;
+    }
+    else if(has_any(RTOP) && _is_doc_sep(s))
+    {
+        return false;
+    }
+    else if(has_any(RSEQ))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks,  ! has_all(RKEY));
+        if(has_all(RVAL))
+        {
+            _c4dbgp("RSEQ|RVAL");
+            if( ! _is_scalar_next__rseq_rval(s))
+                return false;
+            _RYML_WITH_TAB_TOKENS(else if(s.begins_with("-\t"))
+                return false;
+            )
+            if(s.ends_with(':'))
+            {
+                --s.len;
+            }
+            else
+            {
+                auto first = s.first_of_any(": " _RYML_WITH_TAB_TOKENS( , ":\t"), " #");
+                if(first)
+                    s.len = first.pos;
+            }
+            if(has_all(FLOW))
+            {
+                _c4dbgp("RSEQ|RVAL|EXPL");
+                s = s.left_of(s.first_of(",]"));
+            }
+            s = s.trimr(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+        }
+        else
+        {
+            _c4err("internal error");
+        }
+    }
+    else if(has_any(RMAP))
+    {
+        if( ! _is_scalar_next__rmap(s))
+            return false;
+        size_t colon_space = s.find(": ");
+        if(colon_space == npos)
+        {
+            _RYML_WITH_OR_WITHOUT_TAB_TOKENS(
+                // with tab tokens
+                colon_space = s.find(":\t");
+                if(colon_space == npos)
+                {
+                    _RYML_CB_ASSERT(m_stack.m_callbacks, s.len > 0);
+                    colon_space = s.find(':');
+                    if(colon_space != s.len-1)
+                        colon_space = npos;
+                }
+                ,
+                // without tab tokens
+                colon_space = s.find(':');
+                _RYML_CB_ASSERT(m_stack.m_callbacks, s.len > 0);
+                if(colon_space != s.len-1)
+                    colon_space = npos;
+            )
+        }
+
+        if(has_all(RKEY))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, !s.begins_with(' '));
+            if(has_any(QMRK))
+            {
+                _c4dbgp("RMAP|RKEY|CPLX");
+                _RYML_CB_ASSERT(m_stack.m_callbacks, has_any(RMAP));
+                if(s.begins_with("? ") || s == '?')
+                    return false;
+                s = s.left_of(colon_space);
+                s = s.left_of(s.first_of("#"));
+                if(has_any(FLOW))
+                    s = s.left_of(s.first_of(':'));
+                s = s.trimr(" \t");
+                if(s.begins_with("---"))
+                    return false;
+                else if(s.begins_with("..."))
+                    return false;
+            }
+            else
+            {
+                _c4dbgp("RMAP|RKEY");
+                _RYML_CB_CHECK(m_stack.m_callbacks, !s.begins_with('{'));
+                if(s.begins_with("? ") || s == '?')
+                    return false;
+                s = s.left_of(colon_space);
+                s = s.trimr(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+                if(has_any(FLOW))
+                {
+                    _c4dbgpf("RMAP|RKEY|EXPL: '{}'", s);
+                    s = s.left_of(s.first_of(",}"));
+                    if(s.ends_with(':'))
+                        s = s.offs(0, 1);
+                }
+                else if(s.begins_with("---"))
+                {
+                    return false;
+                }
+                else if(s.begins_with("..."))
+                {
+                    return false;
+                }
+            }
+        }
+        else if(has_all(RVAL))
+        {
+            _c4dbgp("RMAP|RVAL");
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(QMRK));
+            if( ! _is_scalar_next__rmap_val(s))
+                return false;
+            _RYML_WITH_TAB_TOKENS(else if(s.begins_with("-\t"))
+                return false;
+            )
+            s = s.left_of(s.find(" #")); // is there a comment?
+            s = s.left_of(s.find("\t#")); // is there a comment?
+            if(has_any(FLOW))
+            {
+                _c4dbgp("RMAP|RVAL|EXPL");
+                if(has_none(RSEQIMAP))
+                    s = s.left_of(s.first_of(",}"));
+                else
+                    s = s.left_of(s.first_of(",]"));
+            }
+            s = s.trim(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+            if(s.begins_with("---"))
+                return false;
+            else if(s.begins_with("..."))
+                return false;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_all(RUNK))
+    {
+        _c4dbgpf("RUNK '[{}]~~~{}~~~", s.len, s);
+        if( ! _is_scalar_next__runk(s))
+        {
+            _c4dbgp("RUNK: no scalar next");
+            return false;
+        }
+        s = s.left_of(s.find(" #"));
+        size_t pos = s.find(": ");
+        if(pos != npos)
+            s = s.left_of(pos);
+        else if(s.ends_with(':'))
+            s = s.left_of(s.len-1);
+        _RYML_WITH_TAB_TOKENS(
+        else if((pos = s.find(":\t")) != npos) // TABS
+            s = s.left_of(pos);
+        )
+        else
+            s = s.left_of(s.first_of(','));
+        s = s.trim(" \t");
+        _c4dbgpf("RUNK: scalar='{}'", s);
+    }
+    else
+    {
+        _c4err("not implemented");
+    }
+
+    if(s.empty())
+        return false;
+
+    m_state->scalar_col = m_state->line_contents.current_col(s);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.str >= m_state->line_contents.rem.str);
+    _line_progressed(static_cast<size_t>(s.str - m_state->line_contents.rem.str) + s.len);
+
+    if(_at_line_end() && s != '~')
+    {
+        _c4dbgpf("at line end. curr='{}'", s);
+        s = _extend_scanned_scalar(s);
+    }
+
+    _c4dbgpf("scalar was '{}'", s);
+
+    *scalar = s;
+    *quoted = false;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+
+csubstr Parser::_extend_scanned_scalar(csubstr s)
+{
+    if(has_all(RMAP|RKEY|QMRK))
+    {
+        size_t scalar_indentation = has_any(FLOW) ? 0 : m_state->scalar_col;
+        _c4dbgpf("extend_scalar: explicit key! indref={} scalar_indentation={} scalar_col={}", m_state->indref, scalar_indentation, m_state->scalar_col);
+        csubstr n = _scan_to_next_nonempty_line(scalar_indentation);
+        if(!n.empty())
+        {
+            substr full = _scan_complex_key(s, n).trimr(" \t\r\n");
+            if(full != s)
+                s = _filter_plain_scalar(full, scalar_indentation);
+        }
+    }
+    // deal with plain (unquoted) scalars that continue to the next line
+    else if(!s.begins_with_any("*")) // cannot be a plain scalar if it starts with * (that's an anchor reference)
+    {
+        _c4dbgpf("extend_scalar: line ended, scalar='{}'", s);
+        if(has_none(FLOW))
+        {
+            size_t scalar_indentation = m_state->indref + 1;
+            if(has_all(RUNK) && scalar_indentation == 1)
+                scalar_indentation = 0;
+            csubstr n = _scan_to_next_nonempty_line(scalar_indentation);
+            if(!n.empty())
+            {
+                _c4dbgpf("rscalar[IMPL]: state_indref={} state_indentation={} scalar_indentation={}", m_state->indref, m_state->line_contents.indentation, scalar_indentation);
+                _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.full.is_super(n));
+                substr full = _scan_plain_scalar_blck(s, n, scalar_indentation);
+                if(full.len >= s.len)
+                    s = _filter_plain_scalar(full, scalar_indentation);
+            }
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(FLOW));
+            csubstr n = _scan_to_next_nonempty_line(/*indentation*/0);
+            if(!n.empty())
+            {
+                _c4dbgp("rscalar[FLOW]");
+                substr full = _scan_plain_scalar_flow(s, n);
+                s = _filter_plain_scalar(full, /*indentation*/0);
+            }
+        }
+    }
+
+    return s;
+}
+
+
+//-----------------------------------------------------------------------------
+
+substr Parser::_scan_plain_scalar_flow(csubstr currscalar, csubstr peeked_line)
+{
+    static constexpr const csubstr chars = "[]{}?#,";
+    size_t pos = peeked_line.first_of(chars);
+    bool first = true;
+    while(pos != 0)
+    {
+        if(has_all(RMAP|RKEY) || has_any(RUNK))
+        {
+            csubstr tpkl = peeked_line.triml(' ').trimr("\r\n");
+            if(tpkl.begins_with(": ") || tpkl == ':')
+            {
+                _c4dbgpf("rscalar[EXPL]: map value starts on the peeked line: '{}'", peeked_line);
+                peeked_line = peeked_line.first(0);
+                break;
+            }
+            else
+            {
+                auto colon_pos = peeked_line.first_of_any(": ", ":");
+                if(colon_pos && colon_pos.pos < pos)
+                {
+                    peeked_line = peeked_line.first(colon_pos.pos);
+                    _c4dbgpf("rscalar[EXPL]: found colon at {}. peeked='{}'", colon_pos.pos, peeked_line);
+                    _RYML_CB_ASSERT(m_stack.m_callbacks, peeked_line.end() >= m_state->line_contents.rem.begin());
+                    _line_progressed(static_cast<size_t>(peeked_line.end() - m_state->line_contents.rem.begin()));
+                    break;
+                }
+            }
+        }
+        if(pos != npos)
+        {
+            _c4dbgpf("rscalar[EXPL]: found special character '{}' at {}, stopping: '{}'", peeked_line[pos], pos, peeked_line.left_of(pos).trimr("\r\n"));
+            peeked_line = peeked_line.left_of(pos);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, peeked_line.end() >= m_state->line_contents.rem.begin());
+            _line_progressed(static_cast<size_t>(peeked_line.end() - m_state->line_contents.rem.begin()));
+            break;
+        }
+        _c4dbgpf("rscalar[EXPL]: append another line, full: '{}'", peeked_line.trimr("\r\n"));
+        if(!first)
+        {
+            RYML_CHECK(_advance_to_peeked());
+        }
+        peeked_line = _scan_to_next_nonempty_line(/*indentation*/0);
+        if(peeked_line.empty())
+        {
+            _c4err("expected token or continuation");
+        }
+        pos = peeked_line.first_of(chars);
+        first = false;
+    }
+    substr full(m_buf.str + (currscalar.str - m_buf.str), m_buf.begin() + m_state->pos.offset);
+    full = full.trimr("\n\r ");
+    return full;
+}
+
+
+//-----------------------------------------------------------------------------
+
+substr Parser::_scan_plain_scalar_blck(csubstr currscalar, csubstr peeked_line, size_t indentation)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.is_super(currscalar));
+    // NOTE. there's a problem with _scan_to_next_nonempty_line(), as it counts newlines twice
+    // size_t offs = m_state->pos.offset;   // so we workaround by directly counting from the end of the given scalar
+    _RYML_CB_ASSERT(m_stack.m_callbacks, currscalar.end() >= m_buf.begin());
+    size_t offs = static_cast<size_t>(currscalar.end() - m_buf.begin());
+    _RYML_CB_ASSERT(m_stack.m_callbacks, peeked_line.begins_with(' ', indentation));
+    while(true)
+    {
+        _c4dbgpf("rscalar[IMPL]: continuing... ref_indentation={}", indentation);
+        if(peeked_line.begins_with("...") || peeked_line.begins_with("---"))
+        {
+            _c4dbgpf("rscalar[IMPL]: document termination next -- bail now '{}'", peeked_line.trimr("\r\n"));
+            break;
+        }
+        else if(( ! peeked_line.begins_with(' ', indentation))) // is the line deindented?
+        {
+            if(!peeked_line.trim(" \r\n\t").empty()) // is the line not blank?
+            {
+                _c4dbgpf("rscalar[IMPL]: deindented line, not blank -- bail now '{}'", peeked_line.trimr("\r\n"));
+                break;
+            }
+            _c4dbgpf("rscalar[IMPL]: line is blank and has less indentation: ref={} line={}: '{}'", indentation, peeked_line.first_not_of(' ') == csubstr::npos ? 0 : peeked_line.first_not_of(' '), peeked_line.trimr("\r\n"));
+            _c4dbgpf("rscalar[IMPL]: ... searching for a line starting at indentation {}", indentation);
+            csubstr next_peeked = _scan_to_next_nonempty_line(indentation);
+            if(next_peeked.empty())
+            {
+                _c4dbgp("rscalar[IMPL]: ... finished.");
+                break;
+            }
+            _c4dbgp("rscalar[IMPL]: ... continuing.");
+            peeked_line = next_peeked;
+        }
+
+        _c4dbgpf("rscalar[IMPL]: line contents: '{}'", peeked_line.right_of(indentation, true).trimr("\r\n"));
+        size_t token_pos;
+        if(peeked_line.find(": ") != npos)
+        {
+            _line_progressed(peeked_line.find(": "));
+            _c4err("': ' is not a valid token in plain flow (unquoted) scalars");
+        }
+        else if(peeked_line.ends_with(':'))
+        {
+            _line_progressed(peeked_line.find(':'));
+            _c4err("lines cannot end with ':' in plain flow (unquoted) scalars");
+        }
+        else if((token_pos = peeked_line.find(" #")) != npos)
+        {
+            _line_progressed(token_pos);
+            break;
+            //_c4err("' #' is not a valid token in plain flow (unquoted) scalars");
+        }
+
+        _c4dbgpf("rscalar[IMPL]: append another line: (len={})'{}'", peeked_line.len, peeked_line.trimr("\r\n"));
+        if(!_advance_to_peeked())
+        {
+            _c4dbgp("rscalar[IMPL]: file finishes after the scalar");
+            break;
+        }
+        peeked_line = m_state->line_contents.rem;
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.offset >= offs);
+    substr full(m_buf.str + (currscalar.str - m_buf.str),
+                currscalar.len + (m_state->pos.offset - offs));
+    full = full.trimr("\r\n ");
+    return full;
+}
+
+substr Parser::_scan_complex_key(csubstr currscalar, csubstr peeked_line)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.is_super(currscalar));
+    // NOTE. there's a problem with _scan_to_next_nonempty_line(), as it counts newlines twice
+    // size_t offs = m_state->pos.offset;   // so we workaround by directly counting from the end of the given scalar
+    _RYML_CB_ASSERT(m_stack.m_callbacks, currscalar.end() >= m_buf.begin());
+    size_t offs = static_cast<size_t>(currscalar.end() - m_buf.begin());
+    while(true)
+    {
+        _c4dbgp("rcplxkey: continuing...");
+        if(peeked_line.begins_with("...") || peeked_line.begins_with("---"))
+        {
+            _c4dbgpf("rcplxkey: document termination next -- bail now '{}'", peeked_line.trimr("\r\n"));
+            break;
+        }
+        else
+        {
+            size_t pos = peeked_line.first_of("?:[]{}");
+            if(pos == csubstr::npos)
+            {
+                pos = peeked_line.find("- ");
+            }
+            if(pos != csubstr::npos)
+            {
+                _c4dbgpf("rcplxkey: found special characters at pos={}: '{}'", pos, peeked_line.trimr("\r\n"));
+                _line_progressed(pos);
+                break;
+            }
+        }
+
+        _c4dbgpf("rcplxkey: no special chars found '{}'", peeked_line.trimr("\r\n"));
+        csubstr next_peeked = _scan_to_next_nonempty_line(0);
+        if(next_peeked.empty())
+        {
+            _c4dbgp("rcplxkey: empty ... finished.");
+            break;
+        }
+        _c4dbgp("rcplxkey: ... continuing.");
+        peeked_line = next_peeked;
+
+        _c4dbgpf("rcplxkey: line contents: '{}'", peeked_line.trimr("\r\n"));
+        size_t colpos;
+        if((colpos = peeked_line.find(": ")) != npos)
+        {
+            _c4dbgp("rcplxkey: found ': ', stopping.");
+            _line_progressed(colpos);
+            break;
+        }
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        else if((colpos = peeked_line.ends_with(':')))
+        {
+            _c4dbgp("rcplxkey: ends with ':', stopping.");
+            _line_progressed(colpos);
+            break;
+        }
+        #endif
+        _c4dbgpf("rcplxkey: append another line: (len={})'{}'", peeked_line.len, peeked_line.trimr("\r\n"));
+        if(!_advance_to_peeked())
+        {
+            _c4dbgp("rcplxkey: file finishes after the scalar");
+            break;
+        }
+        peeked_line = m_state->line_contents.rem;
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.offset >= offs);
+    substr full(m_buf.str + (currscalar.str - m_buf.str),
+                currscalar.len + (m_state->pos.offset - offs));
+    return full;
+}
+
+//! scans to the next non-blank line starting with the given indentation
+csubstr Parser::_scan_to_next_nonempty_line(size_t indentation)
+{
+    csubstr next_peeked;
+    while(true)
+    {
+        _c4dbgpf("rscalar: ... curr offset: {} indentation={}", m_state->pos.offset, indentation);
+        next_peeked = _peek_next_line(m_state->pos.offset);
+        csubstr next_peeked_triml = next_peeked.triml(' ');
+        _c4dbgpf("rscalar: ... next peeked line='{}'", next_peeked.trimr("\r\n"));
+        if(next_peeked_triml.begins_with('#'))
+        {
+            _c4dbgp("rscalar: ... first non-space character is #");
+            return {};
+        }
+        else if(next_peeked.begins_with(' ', indentation))
+        {
+            _c4dbgpf("rscalar: ... begins at same indentation {}, assuming continuation", indentation);
+            _advance_to_peeked();
+            return next_peeked;
+        }
+        else   // check for de-indentation
+        {
+            csubstr trimmed = next_peeked_triml.trimr("\t\r\n");
+            _c4dbgpf("rscalar: ... deindented! trimmed='{}'", trimmed);
+            if(!trimmed.empty())
+            {
+                _c4dbgp("rscalar: ... and not empty. bailing out.");
+                return {};
+            }
+        }
+        if(!_advance_to_peeked())
+        {
+            _c4dbgp("rscalar: file finished");
+            return {};
+        }
+    }
+    return {};
+}
+
+// returns false when the file finished
+bool Parser::_advance_to_peeked()
+{
+    _line_progressed(m_state->line_contents.rem.len);
+    _line_ended(); // advances to the peeked-at line, consuming all remaining (probably newline) characters on the current line
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.rem.first_of("\r\n") == csubstr::npos);
+    _c4dbgpf("advance to peeked: scan more... pos={} len={}", m_state->pos.offset, m_buf.len);
+    _scan_line();  // puts the peeked-at line in the buffer
+    if(_finished_file())
+    {
+        _c4dbgp("rscalar: finished file!");
+        return false;
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+
+C4_ALWAYS_INLINE size_t _extend_from_combined_newline(char nl, char following)
+{
+    return (nl == '\n' && following == '\r') || (nl == '\r' && following == '\n');
+}
+
+//! look for the next newline chars, and jump to the right of those
+csubstr from_next_line(csubstr rem)
+{
+    size_t nlpos = rem.first_of("\r\n");
+    if(nlpos == csubstr::npos)
+        return {};
+    const char nl = rem[nlpos];
+    rem = rem.right_of(nlpos);
+    if(rem.empty())
+        return {};
+    if(_extend_from_combined_newline(nl, rem.front()))
+        rem = rem.sub(1);
+    return rem;
+}
+
+csubstr Parser::_peek_next_line(size_t pos) const
+{
+    csubstr rem{}; // declare here because of the goto
+    size_t nlpos{}; // declare here because of the goto
+    pos = pos == npos ? m_state->pos.offset : pos;
+    if(pos >= m_buf.len)
+        goto next_is_empty;
+
+    // look for the next newline chars, and jump to the right of those
+    rem = from_next_line(m_buf.sub(pos));
+    if(rem.empty())
+        goto next_is_empty;
+
+    // now get everything up to and including the following newline chars
+    nlpos = rem.first_of("\r\n");
+    if((nlpos != csubstr::npos) && (nlpos + 1 < rem.len))
+        nlpos += _extend_from_combined_newline(rem[nlpos], rem[nlpos+1]);
+    rem = rem.left_of(nlpos, /*include_pos*/true);
+
+    _c4dbgpf("peek next line @ {}: (len={})'{}'", pos, rem.len, rem.trimr("\r\n"));
+    return rem;
+
+next_is_empty:
+    _c4dbgpf("peek next line @ {}: (len=0)''", pos);
+    return {};
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::LineContents::reset_with_next_line(csubstr buf, size_t offset)
+{
+    RYML_ASSERT(offset <= buf.len);
+    char const* C4_RESTRICT b = &buf[offset];
+    char const* C4_RESTRICT e = b;
+    // get the current line stripped of newline chars
+    while(e < buf.end() && (*e != '\n' && *e != '\r'))
+        ++e;
+    RYML_ASSERT(e >= b);
+    const csubstr stripped_ = buf.sub(offset, static_cast<size_t>(e - b));
+    // advance pos to include the first line ending
+    if(e != buf.end() && *e == '\r')
+        ++e;
+    if(e != buf.end() && *e == '\n')
+        ++e;
+    RYML_ASSERT(e >= b);
+    const csubstr full_ = buf.sub(offset, static_cast<size_t>(e - b));
+    reset(full_, stripped_);
+}
+
+void Parser::_scan_line()
+{
+    if(m_state->pos.offset >= m_buf.len)
+    {
+        m_state->line_contents.reset(m_buf.last(0), m_buf.last(0));
+        return;
+    }
+    m_state->line_contents.reset_with_next_line(m_buf, m_state->pos.offset);
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_line_progressed(size_t ahead)
+{
+    _c4dbgpf("line[{}] ({} cols) progressed by {}:  col {}-->{}   offset {}-->{}", m_state->pos.line, m_state->line_contents.full.len, ahead, m_state->pos.col, m_state->pos.col+ahead, m_state->pos.offset, m_state->pos.offset+ahead);
+    m_state->pos.offset += ahead;
+    m_state->pos.col += ahead;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.col <= m_state->line_contents.stripped.len+1);
+    m_state->line_contents.rem = m_state->line_contents.rem.sub(ahead);
+}
+
+void Parser::_line_ended()
+{
+    _c4dbgpf("line[{}] ({} cols) ended! offset {}-->{}", m_state->pos.line, m_state->line_contents.full.len, m_state->pos.offset, m_state->pos.offset+m_state->line_contents.full.len - m_state->line_contents.stripped.len);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.col == m_state->line_contents.stripped.len+1);
+    m_state->pos.offset += m_state->line_contents.full.len - m_state->line_contents.stripped.len;
+    ++m_state->pos.line;
+    m_state->pos.col = 1;
+}
+
+void Parser::_line_ended_undo()
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.col == 1u);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.line > 0u);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.offset >= m_state->line_contents.full.len - m_state->line_contents.stripped.len);
+    _c4dbgpf("line[{}] undo ended! line {}-->{}, offset {}-->{}", m_state->pos.line, m_state->pos.line, m_state->pos.line - 1, m_state->pos.offset, m_state->pos.offset - (m_state->line_contents.full.len - m_state->line_contents.stripped.len));
+    m_state->pos.offset -= m_state->line_contents.full.len - m_state->line_contents.stripped.len;
+    --m_state->pos.line;
+    m_state->pos.col = m_state->line_contents.stripped.len + 1u;
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_set_indentation(size_t indentation)
+{
+    m_state->indref = indentation;
+    _c4dbgpf("state[{}]: saving indentation: {}", m_state-m_stack.begin(), m_state->indref);
+}
+
+void Parser::_save_indentation(size_t behind)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->line_contents.rem.begin() >= m_state->line_contents.full.begin());
+    m_state->indref = static_cast<size_t>(m_state->line_contents.rem.begin() - m_state->line_contents.full.begin());
+    _RYML_CB_ASSERT(m_stack.m_callbacks, behind <= m_state->indref);
+    m_state->indref -= behind;
+    _c4dbgpf("state[{}]: saving indentation: {}", m_state-m_stack.begin(), m_state->indref);
+}
+
+bool Parser::_maybe_set_indentation_from_anchor_or_tag()
+{
+    if(m_key_anchor.not_empty())
+    {
+        _c4dbgpf("set indentation from key anchor: {}", m_key_anchor_indentation);
+        _set_indentation(m_key_anchor_indentation); // this is the column where the anchor starts
+        return true;
+    }
+    else if(m_key_tag.not_empty())
+    {
+        _c4dbgpf("set indentation from key tag: {}", m_key_tag_indentation);
+        _set_indentation(m_key_tag_indentation); // this is the column where the tag starts
+        return true;
+    }
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_write_key_anchor(size_t node_id)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->has_key(node_id));
+    if( ! m_key_anchor.empty())
+    {
+        _c4dbgpf("node={}: set key anchor to '{}'", node_id, m_key_anchor);
+        m_tree->set_key_anchor(node_id, m_key_anchor);
+        m_key_anchor.clear();
+        m_key_anchor_was_before = false;
+        m_key_anchor_indentation = 0;
+    }
+    else if( ! m_tree->is_key_quoted(node_id))
+    {
+        csubstr r = m_tree->key(node_id);
+        if(r.begins_with('*'))
+        {
+            _c4dbgpf("node={}: set key reference: '{}'", node_id, r);
+            m_tree->set_key_ref(node_id, r.sub(1));
+        }
+        else if(r == "<<")
+        {
+            m_tree->set_key_ref(node_id, r);
+            _c4dbgpf("node={}: it's an inheriting reference", node_id);
+            if(m_tree->is_seq(node_id))
+            {
+                _c4dbgpf("node={}: inheriting from seq of {}", node_id, m_tree->num_children(node_id));
+                for(size_t i = m_tree->first_child(node_id); i != NONE; i = m_tree->next_sibling(i))
+                {
+                    if( ! (m_tree->val(i).begins_with('*')))
+                        _c4err("malformed reference: '{}'", m_tree->val(i));
+                }
+            }
+            else if( ! m_tree->val(node_id).begins_with('*'))
+            {
+                 _c4err("malformed reference: '{}'", m_tree->val(node_id));
+            }
+            //m_tree->set_key_ref(node_id, r);
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_write_val_anchor(size_t node_id)
+{
+    if( ! m_val_anchor.empty())
+    {
+        _c4dbgpf("node={}: set val anchor to '{}'", node_id, m_val_anchor);
+        m_tree->set_val_anchor(node_id, m_val_anchor);
+        m_val_anchor.clear();
+    }
+    csubstr r = m_tree->has_val(node_id) ? m_tree->val(node_id) : "";
+    if(!m_tree->is_val_quoted(node_id) && r.begins_with('*'))
+    {
+        _c4dbgpf("node={}: set val reference: '{}'", node_id, r);
+        RYML_CHECK(!m_tree->has_val_anchor(node_id));
+        m_tree->set_val_ref(node_id, r.sub(1));
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_push_level(bool explicit_flow_chars)
+{
+    _c4dbgpf("pushing level! currnode={}  currlevel={} stacksize={} stackcap={}", m_state->node_id, m_state->level, m_stack.size(), m_stack.capacity());
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state == &m_stack.top());
+    if(node(m_state) == nullptr)
+    {
+        _c4dbgp("pushing level! actually no, current node is null");
+        //_RYML_CB_ASSERT(m_stack.m_callbacks,  ! explicit_flow_chars);
+        return;
+    }
+    flag_t st = RUNK;
+    if(explicit_flow_chars || has_all(FLOW))
+    {
+        st |= FLOW;
+    }
+    m_stack.push_top();
+    m_state = &m_stack.top();
+    set_flags(st);
+    m_state->node_id = (size_t)NONE;
+    m_state->indref = (size_t)NONE;
+    ++m_state->level;
+    _c4dbgpf("pushing level: now, currlevel={}", m_state->level);
+}
+
+void Parser::_pop_level()
+{
+    _c4dbgpf("popping level! currnode={} currlevel={}", m_state->node_id, m_state->level);
+    if(has_any(RMAP) || m_tree->is_map(m_state->node_id))
+    {
+        _stop_map();
+    }
+    if(has_any(RSEQ) || m_tree->is_seq(m_state->node_id))
+    {
+        _stop_seq();
+    }
+    if(m_tree->is_doc(m_state->node_id))
+    {
+        _stop_doc();
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_stack.size() > 1);
+    _prepare_pop();
+    m_stack.pop();
+    m_state = &m_stack.top();
+    /*if(has_any(RMAP))
+    {
+        _toggle_key_val();
+    }*/
+    if(m_state->line_contents.indentation == 0)
+    {
+        //_RYML_CB_ASSERT(m_stack.m_callbacks, has_none(RTOP));
+        add_flags(RTOP);
+    }
+    _c4dbgpf("popping level: now, currnode={} currlevel={}", m_state->node_id, m_state->level);
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_start_unk(bool /*as_child*/)
+{
+    _c4dbgp("start_unk");
+    _push_level();
+    _move_scalar_from_top();
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_start_doc(bool as_child)
+{
+    _c4dbgpf("start_doc (as child={})", as_child);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_stack.bottom()) == node(m_root_id));
+    size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, parent_id != NONE);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_root(parent_id));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_state) == nullptr || node(m_state) == node(m_root_id));
+    if(as_child)
+    {
+        _c4dbgpf("start_doc: parent={}", parent_id);
+        if( ! m_tree->is_stream(parent_id))
+        {
+            _c4dbgp("start_doc: rearranging with root as STREAM");
+            m_tree->set_root_as_stream();
+        }
+        m_state->node_id = m_tree->append_child(parent_id);
+        m_tree->to_doc(m_state->node_id);
+    }
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_seq(parent_id) || m_tree->empty(parent_id));
+        m_state->node_id = parent_id;
+        if( ! m_tree->is_doc(parent_id))
+        {
+            m_tree->to_doc(parent_id, DOC);
+        }
+    }
+    #endif
+    _c4dbgpf("start_doc: id={}", m_state->node_id);
+    add_flags(RUNK|RTOP|NDOC);
+    _handle_types();
+    rem_flags(NDOC);
+}
+
+void Parser::_stop_doc()
+{
+    size_t doc_node = m_state->node_id;
+    _c4dbgpf("stop_doc[{}]", doc_node);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_doc(doc_node));
+    if(!m_tree->is_seq(doc_node) && !m_tree->is_map(doc_node) && !m_tree->is_val(doc_node))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(SSCL));
+        _c4dbgpf("stop_doc[{}]: there was nothing; adding null val", doc_node);
+        m_tree->to_val(doc_node, {}, DOC);
+    }
+}
+
+void Parser::_end_stream()
+{
+    _c4dbgpf("end_stream, level={} node_id={}", m_state->level, m_state->node_id);
+    _RYML_CB_ASSERT(m_stack.m_callbacks,  ! m_stack.empty());
+    NodeData *added = nullptr;
+    if(has_any(SSCL))
+    {
+        if(m_tree->is_seq(m_state->node_id))
+        {
+            _c4dbgp("append val...");
+            added = _append_val(_consume_scalar());
+        }
+        else if(m_tree->is_map(m_state->node_id))
+        {
+            _c4dbgp("append null key val...");
+            added = _append_key_val_null(m_state->line_contents.rem.str);
+            #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+            if(has_any(RSEQIMAP))
+            {
+                _stop_seqimap();
+                _pop_level();
+            }
+            #endif
+        }
+        else if(m_tree->is_doc(m_state->node_id) || m_tree->type(m_state->node_id) == NOTYPE)
+        {
+            NodeType_e quoted = has_any(QSCL) ? VALQUO : NOTYPE; // do this before consuming the scalar
+            csubstr scalar = _consume_scalar();
+            _c4dbgpf("node[{}]: to docval '{}'{}", m_state->node_id, scalar, quoted == VALQUO ? ", quoted" : "");
+            m_tree->to_val(m_state->node_id, scalar, DOC|quoted);
+            added = m_tree->get(m_state->node_id);
+        }
+        else
+        {
+            _c4err("internal error");
+        }
+    }
+    else if(has_all(RSEQ|RVAL) && has_none(FLOW))
+    {
+        _c4dbgp("add last...");
+        added = _append_val_null(m_state->line_contents.rem.str);
+    }
+    else if(!m_val_tag.empty() && (m_tree->is_doc(m_state->node_id) || m_tree->type(m_state->node_id) == NOTYPE))
+    {
+        csubstr scalar = m_state->line_contents.rem.first(0);
+        _c4dbgpf("node[{}]: add null scalar as docval", m_state->node_id);
+        m_tree->to_val(m_state->node_id, scalar, DOC);
+        added = m_tree->get(m_state->node_id);
+    }
+
+    if(added)
+    {
+        size_t added_id = m_tree->id(added);
+        if(m_tree->is_seq(m_state->node_id) || m_tree->is_doc(m_state->node_id))
+        {
+            if(!m_key_anchor.empty())
+            {
+                _c4dbgpf("node[{}]: move key to val anchor: '{}'", added_id, m_key_anchor);
+                m_val_anchor = m_key_anchor;
+                m_key_anchor = {};
+            }
+            if(!m_key_tag.empty())
+            {
+                _c4dbgpf("node[{}]: move key to val tag: '{}'", added_id, m_key_tag);
+                m_val_tag = m_key_tag;
+                m_key_tag = {};
+            }
+        }
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        if(!m_key_anchor.empty())
+        {
+            _c4dbgpf("node[{}]: set key anchor='{}'", added_id, m_key_anchor);
+            m_tree->set_key_anchor(added_id, m_key_anchor);
+            m_key_anchor = {};
+        }
+        #endif
+        if(!m_val_anchor.empty())
+        {
+            _c4dbgpf("node[{}]: set val anchor='{}'", added_id, m_val_anchor);
+            m_tree->set_val_anchor(added_id, m_val_anchor);
+            m_val_anchor = {};
+        }
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        if(!m_key_tag.empty())
+        {
+            _c4dbgpf("node[{}]: set key tag='{}' -> '{}'", added_id, m_key_tag, normalize_tag(m_key_tag));
+            m_tree->set_key_tag(added_id, normalize_tag(m_key_tag));
+            m_key_tag = {};
+        }
+        #endif
+        if(!m_val_tag.empty())
+        {
+            _c4dbgpf("node[{}]: set val tag='{}' -> '{}'", added_id, m_val_tag, normalize_tag(m_val_tag));
+            m_tree->set_val_tag(added_id, normalize_tag(m_val_tag));
+            m_val_tag = {};
+        }
+    }
+
+    while(m_stack.size() > 1)
+    {
+        _c4dbgpf("popping level: {} (stack sz={})", m_state->level, m_stack.size());
+        _RYML_CB_ASSERT(m_stack.m_callbacks,  ! has_any(SSCL, &m_stack.top()));
+        if(has_all(RSEQ|FLOW))
+            _err("closing ] not found");
+        _pop_level();
+    }
+    add_flags(NDOC);
+}
+
+void Parser::_start_new_doc(csubstr rem)
+{
+    _c4dbgp("_start_new_doc");
+    _RYML_CB_ASSERT(m_stack.m_callbacks, rem.begins_with("---"));
+    C4_UNUSED(rem);
+
+    _end_stream();
+
+    size_t indref = m_state->indref;
+    _c4dbgpf("start a document, indentation={}", indref);
+    _line_progressed(3);
+    _push_level();
+    _start_doc();
+    _set_indentation(indref);
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_start_map(bool as_child)
+{
+    _c4dbgpf("start_map (as child={})", as_child);
+    addrem_flags(RMAP|RVAL, RKEY|RUNK);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_stack.bottom()) == node(m_root_id));
+    size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, parent_id != NONE);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_state) == nullptr || node(m_state) == node(m_root_id));
+    if(as_child)
+    {
+        m_state->node_id = m_tree->append_child(parent_id);
+        if(has_all(SSCL))
+        {
+            type_bits key_quoted = NOTYPE;
+            if(m_state->flags & QSCL) // before consuming the scalar
+                key_quoted |= KEYQUO;
+            csubstr key = _consume_scalar();
+            m_tree->to_map(m_state->node_id, key, key_quoted);
+            _c4dbgpf("start_map: id={} key='{}'", m_state->node_id, m_tree->key(m_state->node_id));
+            _write_key_anchor(m_state->node_id);
+            if( ! m_key_tag.empty())
+            {
+                _c4dbgpf("node[{}]: set key tag='{}' -> '{}'", m_state->node_id, m_key_tag, normalize_tag(m_key_tag));
+                m_tree->set_key_tag(m_state->node_id, normalize_tag(m_key_tag));
+                m_key_tag.clear();
+            }
+        }
+        else
+        {
+            m_tree->to_map(m_state->node_id);
+            _c4dbgpf("start_map: id={}", m_state->node_id);
+        }
+        m_tree->_p(m_state->node_id)->m_val.scalar.str = m_state->line_contents.rem.str;
+        _write_val_anchor(m_state->node_id);
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, parent_id != NONE);
+        m_state->node_id = parent_id;
+        _c4dbgpf("start_map: id={}", m_state->node_id);
+        type_bits as_doc = 0;
+        if(m_tree->is_doc(m_state->node_id))
+            as_doc |= DOC;
+        if(!m_tree->is_map(parent_id))
+        {
+            RYML_CHECK(!m_tree->has_children(parent_id));
+            m_tree->to_map(parent_id, as_doc);
+        }
+        else
+        {
+            m_tree->_add_flags(parent_id, as_doc);
+        }
+        _move_scalar_from_top();
+        if(m_key_anchor.not_empty())
+            m_key_anchor_was_before = true;
+        _write_val_anchor(parent_id);
+        if(m_stack.size() >= 2)
+        {
+            State const& parent_state = m_stack.top(1);
+            if(parent_state.flags & RSET)
+                add_flags(RSET);
+        }
+        m_tree->_p(parent_id)->m_val.scalar.str = m_state->line_contents.rem.str;
+    }
+    if( ! m_val_tag.empty())
+    {
+        _c4dbgpf("node[{}]: set val tag='{}' -> '{}'", m_state->node_id, m_val_tag, normalize_tag(m_val_tag));
+        m_tree->set_val_tag(m_state->node_id, normalize_tag(m_val_tag));
+        m_val_tag.clear();
+    }
+}
+
+void Parser::_start_map_unk(bool as_child)
+{
+    if(!m_key_anchor_was_before)
+    {
+        _c4dbgpf("stash key anchor before starting map... '{}'", m_key_anchor);
+        csubstr ka = m_key_anchor;
+        m_key_anchor = {};
+        _start_map(as_child);
+        m_key_anchor = ka;
+    }
+    else
+    {
+        _start_map(as_child);
+        m_key_anchor_was_before = false;
+    }
+    if(m_key_tag2.not_empty())
+    {
+        m_key_tag = m_key_tag2;
+        m_key_tag_indentation = m_key_tag2_indentation;
+        m_key_tag2.clear();
+        m_key_tag2_indentation = 0;
+    }
+}
+
+void Parser::_stop_map()
+{
+    _c4dbgpf("stop_map[{}]", m_state->node_id);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_map(m_state->node_id));
+    if(has_all(QMRK|RKEY) && !has_all(SSCL))
+    {
+        _c4dbgpf("stop_map[{}]: RKEY", m_state->node_id);
+        _store_scalar_null(m_state->line_contents.rem.str);
+        _append_key_val_null(m_state->line_contents.rem.str);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_start_seq(bool as_child)
+{
+    _c4dbgpf("start_seq (as child={})", as_child);
+    if(has_all(RTOP|RUNK))
+    {
+        _c4dbgpf("start_seq: moving key tag to val tag: '{}'", m_key_tag);
+        m_val_tag = m_key_tag;
+        m_key_tag.clear();
+    }
+    addrem_flags(RSEQ|RVAL, RUNK);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_stack.bottom()) == node(m_root_id));
+    size_t parent_id = m_stack.size() < 2 ? m_root_id : m_stack.top(1).node_id;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, parent_id != NONE);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_state) == nullptr || node(m_state) == node(m_root_id));
+    if(as_child)
+    {
+        m_state->node_id = m_tree->append_child(parent_id);
+        if(has_all(SSCL))
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_map(parent_id));
+            type_bits key_quoted = 0;
+            if(m_state->flags & QSCL) // before consuming the scalar
+                key_quoted |= KEYQUO;
+            csubstr key = _consume_scalar();
+            m_tree->to_seq(m_state->node_id, key, key_quoted);
+            _c4dbgpf("start_seq: id={} name='{}'", m_state->node_id, m_tree->key(m_state->node_id));
+            _write_key_anchor(m_state->node_id);
+            if( ! m_key_tag.empty())
+            {
+                _c4dbgpf("start_seq[{}]: set key tag='{}' -> '{}'", m_state->node_id, m_key_tag, normalize_tag(m_key_tag));
+                m_tree->set_key_tag(m_state->node_id, normalize_tag(m_key_tag));
+                m_key_tag.clear();
+            }
+        }
+        else
+        {
+            type_bits as_doc = 0;
+            _RYML_CB_ASSERT(m_stack.m_callbacks, !m_tree->is_doc(m_state->node_id));
+            m_tree->to_seq(m_state->node_id, as_doc);
+            _c4dbgpf("start_seq: id={}{}", m_state->node_id, as_doc ? " as doc" : "");
+        }
+        _write_val_anchor(m_state->node_id);
+        m_tree->_p(m_state->node_id)->m_val.scalar.str = m_state->line_contents.rem.str;
+    }
+    else
+    {
+        m_state->node_id = parent_id;
+        type_bits as_doc = 0;
+        if(m_tree->is_doc(m_state->node_id))
+            as_doc |= DOC;
+        if(!m_tree->is_seq(parent_id))
+        {
+            RYML_CHECK(!m_tree->has_children(parent_id));
+            m_tree->to_seq(parent_id, as_doc);
+        }
+        else
+        {
+            m_tree->_add_flags(parent_id, as_doc);
+        }
+        _move_scalar_from_top();
+        _c4dbgpf("start_seq: id={}{}", m_state->node_id, as_doc ? " as_doc" : "");
+        _write_val_anchor(parent_id);
+        m_tree->_p(parent_id)->m_val.scalar.str = m_state->line_contents.rem.str;
+    }
+    if( ! m_val_tag.empty())
+    {
+        _c4dbgpf("start_seq[{}]: set val tag='{}' -> '{}'", m_state->node_id, m_val_tag, normalize_tag(m_val_tag));
+        m_tree->set_val_tag(m_state->node_id, normalize_tag(m_val_tag));
+        m_val_tag.clear();
+    }
+}
+
+void Parser::_stop_seq()
+{
+    _c4dbgp("stop_seq");
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_seq(m_state->node_id));
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_start_seqimap()
+{
+    _c4dbgpf("start_seqimap at node={}. has_children={}", m_state->node_id, m_tree->has_children(m_state->node_id));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RSEQ|FLOW));
+    // create a map, and turn the last scalar of this sequence
+    // into the key of the map's first child. This scalar was
+    // understood to be a value in the sequence, but it is
+    // actually a key of a map, implicitly opened here.
+    // Eg [val, key: val]
+    //
+    // Yep, YAML is crazy.
+    if(m_tree->has_children(m_state->node_id) && m_tree->has_val(m_tree->last_child(m_state->node_id)))
+    {
+        size_t prev = m_tree->last_child(m_state->node_id);
+        NodeType ty = m_tree->_p(prev)->m_type; // don't use type() because it masks out the quotes
+        NodeScalar tmp = m_tree->valsc(prev);
+        _c4dbgpf("has children and last child={} has val. saving the scalars, val='{}' quoted={}", prev, tmp.scalar, ty.is_val_quoted());
+        m_tree->remove(prev);
+        _push_level();
+        _start_map();
+        _store_scalar(tmp.scalar, ty.is_val_quoted());
+        m_key_anchor = tmp.anchor;
+        m_key_tag = tmp.tag;
+    }
+    else
+    {
+        _c4dbgpf("node {} has no children yet, using empty key", m_state->node_id);
+        _push_level();
+        _start_map();
+        _store_scalar_null(m_state->line_contents.rem.str);
+    }
+    add_flags(RSEQIMAP|FLOW);
+}
+
+void Parser::_stop_seqimap()
+{
+    _c4dbgp("stop_seqimap");
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(RSEQIMAP));
+}
+
+
+//-----------------------------------------------------------------------------
+NodeData* Parser::_append_val(csubstr val, flag_t quoted)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks,  ! has_all(SSCL));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node(m_state) != nullptr);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_seq(m_state->node_id));
+    type_bits additional_flags = quoted ? VALQUO : NOTYPE;
+    _c4dbgpf("append val: '{}' to parent id={} (level={}){}", val, m_state->node_id, m_state->level, quoted ? " VALQUO!" : "");
+    size_t nid = m_tree->append_child(m_state->node_id);
+    m_tree->to_val(nid, val, additional_flags);
+
+    _c4dbgpf("append val: id={} val='{}'", nid, m_tree->get(nid)->m_val.scalar);
+    if( ! m_val_tag.empty())
+    {
+        _c4dbgpf("append val[{}]: set val tag='{}' -> '{}'", nid, m_val_tag, normalize_tag(m_val_tag));
+        m_tree->set_val_tag(nid, normalize_tag(m_val_tag));
+        m_val_tag.clear();
+    }
+    _write_val_anchor(nid);
+    return m_tree->get(nid);
+}
+
+NodeData* Parser::_append_key_val(csubstr val, flag_t val_quoted)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_map(m_state->node_id));
+    type_bits additional_flags = 0;
+    if(m_state->flags & QSCL)
+        additional_flags |= KEYQUO;
+    if(val_quoted)
+        additional_flags |= VALQUO;
+
+    csubstr key = _consume_scalar();
+    _c4dbgpf("append keyval: '{}' '{}' to parent id={} (level={}){}{}", key, val, m_state->node_id, m_state->level, (additional_flags & KEYQUO) ? " KEYQUO!" : "", (additional_flags & VALQUO) ? " VALQUO!" : "");
+    size_t nid = m_tree->append_child(m_state->node_id);
+    m_tree->to_keyval(nid, key, val, additional_flags);
+    _c4dbgpf("append keyval: id={} key='{}' val='{}'", nid, m_tree->key(nid), m_tree->val(nid));
+    if( ! m_key_tag.empty())
+    {
+        _c4dbgpf("append keyval[{}]: set key tag='{}' -> '{}'", nid, m_key_tag, normalize_tag(m_key_tag));
+        m_tree->set_key_tag(nid, normalize_tag(m_key_tag));
+        m_key_tag.clear();
+    }
+    if( ! m_val_tag.empty())
+    {
+        _c4dbgpf("append keyval[{}]: set val tag='{}' -> '{}'", nid, m_val_tag, normalize_tag(m_val_tag));
+        m_tree->set_val_tag(nid, normalize_tag(m_val_tag));
+        m_val_tag.clear();
+    }
+    _write_key_anchor(nid);
+    _write_val_anchor(nid);
+    rem_flags(QMRK);
+    return m_tree->get(nid);
+}
+
+
+//-----------------------------------------------------------------------------
+void Parser::_store_scalar(csubstr s, flag_t is_quoted)
+{
+    _c4dbgpf("state[{}]: storing scalar '{}' (flag: {}) (old scalar='{}')",
+             m_state-m_stack.begin(), s, m_state->flags & SSCL, m_state->scalar);
+    RYML_CHECK(has_none(SSCL));
+    add_flags(SSCL | (is_quoted * QSCL));
+    m_state->scalar = s;
+}
+
+csubstr Parser::_consume_scalar()
+{
+    _c4dbgpf("state[{}]: consuming scalar '{}' (flag: {}))", m_state-m_stack.begin(), m_state->scalar, m_state->flags & SSCL);
+    RYML_CHECK(m_state->flags & SSCL);
+    csubstr s = m_state->scalar;
+    rem_flags(SSCL | QSCL);
+    m_state->scalar.clear();
+    return s;
+}
+
+void Parser::_move_scalar_from_top()
+{
+    if(m_stack.size() < 2) return;
+    State &prev = m_stack.top(1);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state == &m_stack.top());
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state != &prev);
+    if(prev.flags & SSCL)
+    {
+        _c4dbgpf("moving scalar '{}' from state[{}] to state[{}] (overwriting '{}')", prev.scalar, &prev-m_stack.begin(), m_state-m_stack.begin(), m_state->scalar);
+        add_flags(prev.flags & (SSCL | QSCL));
+        m_state->scalar = prev.scalar;
+        rem_flags(SSCL | QSCL, &prev);
+        prev.scalar.clear();
+    }
+}
+
+//-----------------------------------------------------------------------------
+/** @todo this function is a monster and needs love. */
+bool Parser::_handle_indentation()
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(FLOW));
+    if( ! _at_line_begin())
+        return false;
+
+    size_t ind = m_state->line_contents.indentation;
+    csubstr rem = m_state->line_contents.rem;
+    /** @todo instead of trimming, we should use the indentation index from above */
+    csubstr remt = rem.triml(' ');
+
+    if(remt.empty() || remt.begins_with('#')) // this is a blank or comment line
+    {
+        _line_progressed(rem.size());
+        return true;
+    }
+
+    _c4dbgpf("indentation? ind={} indref={}", ind, m_state->indref);
+    if(ind == m_state->indref)
+    {
+        if(has_all(SSCL|RVAL) && ! rem.sub(ind).begins_with('-'))
+        {
+            if(has_all(RMAP))
+            {
+                _append_key_val_null(rem.str + ind - 1);
+                addrem_flags(RKEY, RVAL);
+            }
+            #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+            else if(has_all(RSEQ))
+            {
+                _append_val(_consume_scalar());
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4err("internal error");
+            }
+            #endif
+        }
+        else if(has_all(RSEQ|RNXT) && ! rem.sub(ind).begins_with('-'))
+        {
+            if(m_stack.size() > 2) // do not pop to root level
+            {
+                _c4dbgp("end the indentless seq");
+                _pop_level();
+                return true;
+            }
+        }
+        else
+        {
+            _c4dbgpf("same indentation ({}) -- nothing to see here", ind);
+        }
+        _line_progressed(ind);
+        return ind > 0;
+    }
+    else if(ind < m_state->indref)
+    {
+        _c4dbgpf("smaller indentation ({} < {})!!!", ind, m_state->indref);
+        if(has_all(RVAL))
+        {
+            _c4dbgp("there was an empty val -- appending");
+            if(has_all(RMAP))
+            {
+                _RYML_CB_ASSERT(m_stack.m_callbacks, has_all(SSCL));
+                _append_key_val_null(rem.sub(ind).str - 1);
+            }
+            else if(has_all(RSEQ))
+            {
+                _RYML_CB_ASSERT(m_stack.m_callbacks, has_none(SSCL));
+                _append_val_null(rem.sub(ind).str - 1);
+            }
+        }
+        // search the stack frame to jump to based on its indentation
+        State const* popto = nullptr;
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_stack.is_contiguous()); // this search relies on the stack being contiguous
+        for(State const* s = m_state-1; s >= m_stack.begin(); --s)
+        {
+            _c4dbgpf("searching for state with indentation {}. curr={} (level={},node={})", ind, s->indref, s->level, s->node_id);
+            if(s->indref == ind)
+            {
+                _c4dbgpf("gotit!!! level={} node={}", s->level, s->node_id);
+                popto = s;
+                // while it may be tempting to think we're done at this
+                // point, we must still determine whether we're jumping to a
+                // parent with the same indentation. Consider this case with
+                // an indentless sequence:
+                //
+                // product:
+                // - sku: BL394D
+                //   quantity: 4
+                //   description: Basketball
+                //   price: 450.00
+                // - sku: BL4438H
+                //   quantity: 1
+                //   description: Super Hoop
+                //   price: 2392.00  # jumping one level here would be wrong.
+                // tax: 1234.5       # we must jump two levels
+                if(popto > m_stack.begin())
+                {
+                    auto parent = popto - 1;
+                    if(parent->indref == popto->indref)
+                    {
+                        _c4dbgpf("the parent (level={},node={}) has the same indentation ({}). is this in an indentless sequence?", parent->level, parent->node_id, popto->indref);
+                        _c4dbgpf("isseq(popto)={} ismap(parent)={}", m_tree->is_seq(popto->node_id), m_tree->is_map(parent->node_id));
+                        if(m_tree->is_seq(popto->node_id) && m_tree->is_map(parent->node_id))
+                        {
+                            if( ! remt.begins_with('-'))
+                            {
+                                _c4dbgp("this is an indentless sequence");
+                                popto = parent;
+                            }
+                            else
+                            {
+                                _c4dbgp("not an indentless sequence");
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        if(!popto || popto >= m_state || popto->level >= m_state->level)
+        {
+            _c4err("parse error: incorrect indentation?");
+        }
+        _c4dbgpf("popping {} levels: from level {} to level {}", m_state->level-popto->level, m_state->level, popto->level);
+        while(m_state != popto)
+        {
+            _c4dbgpf("popping level {} (indentation={})", m_state->level, m_state->indref);
+            _pop_level();
+        }
+        _RYML_CB_ASSERT(m_stack.m_callbacks, ind == m_state->indref);
+        _line_progressed(ind);
+        return true;
+    }
+    else
+    {
+        _c4dbgpf("larger indentation ({} > {})!!!", ind, m_state->indref);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, ind > m_state->indref);
+        if(has_all(RMAP|RVAL))
+        {
+            if(_is_scalar_next__rmap_val(remt) && remt.first_of(":?") == npos)
+            {
+                _c4dbgpf("actually it seems a value: '{}'", remt);
+            }
+            else
+            {
+                addrem_flags(RKEY, RVAL);
+                _start_unk();
+                //_move_scalar_from_top();
+                _line_progressed(ind);
+                _save_indentation();
+                return true;
+            }
+        }
+        else if(has_all(RSEQ|RVAL))
+        {
+            // nothing to do here
+        }
+        else
+        {
+            _c4err("parse error - indentation should not increase at this point");
+        }
+    }
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_scan_comment()
+{
+    csubstr s = m_state->line_contents.rem;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.begins_with('#'));
+    _line_progressed(s.len);
+    // skip the # character
+    s = s.sub(1);
+    // skip leading whitespace
+    s = s.right_of(s.first_not_of(' '), /*include_pos*/true);
+    _c4dbgpf("comment was '{}'", s);
+    return s;
+}
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_scan_squot_scalar()
+{
+    // quoted scalars can spread over multiple lines!
+    // nice explanation here: http://yaml-multiline.info/
+
+    // a span to the end of the file
+    size_t b = m_state->pos.offset;
+    substr s = m_buf.sub(b);
+    if(s.begins_with(' '))
+    {
+        s = s.triml(' ');
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.sub(b).is_super(s));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.begin() >= m_buf.sub(b).begin());
+        _line_progressed((size_t)(s.begin() - m_buf.sub(b).begin()));
+    }
+    b = m_state->pos.offset; // take this into account
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.begins_with('\''));
+
+    // skip the opening quote
+    _line_progressed(1);
+    s = s.sub(1);
+
+    bool needs_filter = false;
+
+    size_t numlines = 1; // we already have one line
+    size_t pos = npos; // find the pos of the matching quote
+    while( ! _finished_file())
+    {
+        const csubstr line = m_state->line_contents.rem;
+        bool line_is_blank = true;
+        _c4dbgpf("scanning single quoted scalar @ line[{}]: ~~~{}~~~", m_state->pos.line, line);
+        for(size_t i = 0; i < line.len; ++i)
+        {
+            const char curr = line.str[i];
+            if(curr == '\'') // single quotes are escaped with two single quotes
+            {
+                const char next = i+1 < line.len ? line.str[i+1] : '~';
+                if(next != '\'') // so just look for the first quote
+                {                // without another after it
+                    pos = i;
+                    break;
+                }
+                else
+                {
+                    needs_filter = true; // needs filter to remove escaped quotes
+                    ++i; // skip the escaped quote
+                }
+            }
+            else if(curr != ' ')
+            {
+                line_is_blank = false;
+            }
+        }
+
+        // leading whitespace also needs filtering
+        needs_filter = needs_filter
+            || numlines > 1
+            || line_is_blank
+            || (_at_line_begin() && line.begins_with(' '))
+            || (m_state->line_contents.full.last_of('\r') != csubstr::npos);
+
+        if(pos == npos)
+        {
+            _line_progressed(line.len);
+            ++numlines;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, pos >= 0 && pos < m_buf.len);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf[m_state->pos.offset + pos] == '\'');
+            _line_progressed(pos + 1); // progress beyond the quote
+            pos = m_state->pos.offset - b - 1; // but we stop before it
+            break;
+        }
+
+        _line_ended();
+        _scan_line();
+    }
+
+    if(pos == npos)
+    {
+        _c4err("reached end of file while looking for closing quote");
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, pos > 0);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.end() >= m_buf.begin() && s.end() <= m_buf.end());
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.end() == m_buf.end() || *s.end() == '\'');
+        s = s.sub(0, pos-1);
+    }
+
+    if(needs_filter)
+    {
+        csubstr ret = _filter_squot_scalar(s);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, ret.len <= s.len || s.empty() || s.trim(' ').empty());
+        _c4dbgpf("final scalar: \"{}\"", ret);
+        return ret;
+    }
+
+    _c4dbgpf("final scalar: \"{}\"", s);
+
+    return s;
+}
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_scan_dquot_scalar()
+{
+    // quoted scalars can spread over multiple lines!
+    // nice explanation here: http://yaml-multiline.info/
+
+    // a span to the end of the file
+    size_t b = m_state->pos.offset;
+    substr s = m_buf.sub(b);
+    if(s.begins_with(' '))
+    {
+        s = s.triml(' ');
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.sub(b).is_super(s));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.begin() >= m_buf.sub(b).begin());
+        _line_progressed((size_t)(s.begin() - m_buf.sub(b).begin()));
+    }
+    b = m_state->pos.offset; // take this into account
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.begins_with('"'));
+
+    // skip the opening quote
+    _line_progressed(1);
+    s = s.sub(1);
+
+    bool needs_filter = false;
+
+    size_t numlines = 1; // we already have one line
+    size_t pos = npos; // find the pos of the matching quote
+    while( ! _finished_file())
+    {
+        const csubstr line = m_state->line_contents.rem;
+        bool line_is_blank = true;
+        _c4dbgpf("scanning double quoted scalar @ line[{}]:  line='{}'", m_state->pos.line, line);
+        for(size_t i = 0; i < line.len; ++i)
+        {
+            const char curr = line.str[i];
+            if(curr != ' ')
+                line_is_blank = false;
+            // every \ is an escape
+            if(curr == '\\')
+            {
+                const char next = i+1 < line.len ? line.str[i+1] : '~';
+                needs_filter = true;
+                if(next == '"' || next == '\\')
+                    ++i;
+            }
+            else if(curr == '"')
+            {
+                pos = i;
+                break;
+            }
+        }
+
+        // leading whitespace also needs filtering
+        needs_filter = needs_filter
+            || numlines > 1
+            || line_is_blank
+            || (_at_line_begin() && line.begins_with(' '))
+            || (m_state->line_contents.full.last_of('\r') != csubstr::npos);
+
+        if(pos == npos)
+        {
+            _line_progressed(line.len);
+            ++numlines;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, pos >= 0 && pos < m_buf.len);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf[m_state->pos.offset + pos] == '"');
+            _line_progressed(pos + 1); // progress beyond the quote
+            pos = m_state->pos.offset - b - 1; // but we stop before it
+            break;
+        }
+
+        _line_ended();
+        _scan_line();
+    }
+
+    if(pos == npos)
+    {
+        _c4err("reached end of file looking for closing quote");
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, pos > 0);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.end() == m_buf.end() || *s.end() == '"');
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.end() >= m_buf.begin() && s.end() <= m_buf.end());
+        s = s.sub(0, pos-1);
+    }
+
+    if(needs_filter)
+    {
+        csubstr ret = _filter_dquot_scalar(s);
+        _c4dbgpf("final scalar: [{}]\"{}\"", ret.len, ret);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, ret.len <= s.len || s.empty() || s.trim(' ').empty());
+        return ret;
+    }
+
+    _c4dbgpf("final scalar: \"{}\"", s);
+
+    return s;
+}
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_scan_block()
+{
+    // nice explanation here: http://yaml-multiline.info/
+    csubstr s = m_state->line_contents.rem;
+    csubstr trimmed = s.triml(' ');
+    if(trimmed.str > s.str)
+    {
+        _c4dbgp("skipping whitespace");
+        _RYML_CB_ASSERT(m_stack.m_callbacks, trimmed.str >= s.str);
+        _line_progressed(static_cast<size_t>(trimmed.str - s.str));
+        s = trimmed;
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.begins_with('|') || s.begins_with('>'));
+
+    _c4dbgpf("scanning block: specs=\"{}\"", s);
+
+    // parse the spec
+    BlockStyle_e newline = s.begins_with('>') ? BLOCK_FOLD : BLOCK_LITERAL;
+    BlockChomp_e chomp = CHOMP_CLIP; // default to clip unless + or - are used
+    size_t indentation = npos; // have to find out if no spec is given
+    csubstr digits;
+    if(s.len > 1)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, s.begins_with_any("|>"));
+        csubstr t = s.sub(1);
+        _c4dbgpf("scanning block: spec is multichar: '{}'", t);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, t.len >= 1);
+        size_t pos = t.first_of("-+");
+        _c4dbgpf("scanning block: spec chomp char at {}", pos);
+        if(pos != npos)
+        {
+            if(t[pos] == '-')
+                chomp = CHOMP_STRIP;
+            else if(t[pos] == '+')
+                chomp = CHOMP_KEEP;
+            if(pos == 0)
+                t = t.sub(1);
+            else
+                t = t.first(pos);
+        }
+        // from here to the end, only digits are considered
+        digits = t.left_of(t.first_not_of("0123456789"));
+        if( ! digits.empty())
+        {
+            if( ! c4::atou(digits, &indentation))
+                _c4err("parse error: could not read decimal");
+            _c4dbgpf("scanning block: indentation specified: {}. add {} from curr state -> {}", indentation, m_state->indref, indentation+m_state->indref);
+            indentation += m_state->indref;
+        }
+    }
+
+    // finish the current line
+    _line_progressed(s.len);
+    _line_ended();
+    _scan_line();
+
+    _c4dbgpf("scanning block: style={}  chomp={}  indentation={}", newline==BLOCK_FOLD ? "fold" : "literal",
+        chomp==CHOMP_CLIP ? "clip" : (chomp==CHOMP_STRIP ? "strip" : "keep"), indentation);
+
+    // start with a zero-length block, already pointing at the right place
+    substr raw_block(m_buf.data() + m_state->pos.offset, size_t(0));// m_state->line_contents.full.sub(0, 0);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, raw_block.begin() == m_state->line_contents.full.begin());
+
+    // read every full line into a raw block,
+    // from which newlines are to be stripped as needed.
+    //
+    // If no explicit indentation was given, pick it from the first
+    // non-empty line. See
+    // https://yaml.org/spec/1.2.2/#8111-block-indentation-indicator
+    size_t num_lines = 0, first = m_state->pos.line, provisional_indentation = npos;
+    LineContents lc;
+    while(( ! _finished_file()))
+    {
+        // peek next line, but do not advance immediately
+        lc.reset_with_next_line(m_buf, m_state->pos.offset);
+        _c4dbgpf("scanning block: peeking at '{}'", lc.stripped);
+        // evaluate termination conditions
+        if(indentation != npos)
+        {
+            // stop when the line is deindented and not empty
+            if(lc.indentation < indentation && ( ! lc.rem.trim(" \t\r\n").empty()))
+            {
+                _c4dbgpf("scanning block: indentation decreased ref={} thisline={}", indentation, lc.indentation);
+                break;
+            }
+            else if(indentation == 0)
+            {
+                if((lc.rem == "..." || lc.rem.begins_with("... "))
+                    ||
+                   (lc.rem == "---" || lc.rem.begins_with("--- ")))
+                {
+                    _c4dbgp("scanning block: stop. indentation=0 and stream ended");
+                    break;
+                }
+            }
+        }
+        else
+        {
+            _c4dbgpf("scanning block: indentation ref not set. firstnonws={}", lc.stripped.first_not_of(' '));
+            if(lc.stripped.first_not_of(' ') != npos) // non-empty line
+            {
+                _c4dbgpf("scanning block: line not empty. indref={} indprov={} indentation={}", m_state->indref, provisional_indentation, lc.indentation);
+                if(provisional_indentation == npos)
+                {
+                    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+                    if(lc.indentation < m_state->indref)
+                    {
+                        _c4dbgpf("scanning block: block terminated indentation={} < indref={}", lc.indentation, m_state->indref);
+                        break;
+                    }
+                    else
+                    #endif
+                    if(lc.indentation == m_state->indref)
+                    {
+                        if(has_any(RSEQ|RMAP))
+                        {
+                            _c4dbgpf("scanning block: block terminated. reading container and indentation={}==indref={}", lc.indentation, m_state->indref);
+                            break;
+                        }
+                    }
+                    _c4dbgpf("scanning block: set indentation ref from this line: ref={}", lc.indentation);
+                    indentation = lc.indentation;
+                }
+                else
+                {
+                    if(lc.indentation >= provisional_indentation)
+                    {
+                        _c4dbgpf("scanning block: set indentation ref from provisional indentation: provisional_ref={}, thisline={}", provisional_indentation, lc.indentation);
+                        //indentation = provisional_indentation ? provisional_indentation : lc.indentation;
+                        indentation = lc.indentation;
+                    }
+                    else
+                    {
+                        break;
+                        //_c4err("parse error: first non-empty block line should have at least the original indentation");
+                    }
+                }
+            }
+            else // empty line
+            {
+                _c4dbgpf("scanning block: line empty or {} spaces. line_indentation={} prov_indentation={}", lc.stripped.len, lc.indentation, provisional_indentation);
+                if(provisional_indentation != npos)
+                {
+                    if(lc.stripped.len >= provisional_indentation)
+                    {
+                        _c4dbgpf("scanning block: increase provisional_ref {} -> {}", provisional_indentation, lc.stripped.len);
+                        provisional_indentation = lc.stripped.len;
+                    }
+                    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+                    else if(lc.indentation >= provisional_indentation && lc.indentation != npos)
+                    {
+                        _c4dbgpf("scanning block: increase provisional_ref {} -> {}", provisional_indentation, lc.indentation);
+                        provisional_indentation = lc.indentation;
+                    }
+                    #endif
+                }
+                else
+                {
+                    provisional_indentation = lc.indentation ? lc.indentation : has_any(RSEQ|RVAL);
+                    _c4dbgpf("scanning block: initialize provisional_ref={}", provisional_indentation);
+                    if(provisional_indentation == npos)
+                    {
+                        provisional_indentation = lc.stripped.len ? lc.stripped.len : has_any(RSEQ|RVAL);
+                        _c4dbgpf("scanning block: initialize provisional_ref={}", provisional_indentation);
+                    }
+                }
+            }
+        }
+        // advance now that we know the folded scalar continues
+        m_state->line_contents = lc;
+        _c4dbgpf("scanning block: append '{}'", m_state->line_contents.rem);
+        raw_block.len += m_state->line_contents.full.len;
+        _line_progressed(m_state->line_contents.rem.len);
+        _line_ended();
+        ++num_lines;
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_state->pos.line == (first + num_lines));
+    C4_UNUSED(num_lines);
+    C4_UNUSED(first);
+
+    if(indentation == npos)
+    {
+        _c4dbgpf("scanning block: set indentation from provisional: {}", provisional_indentation);
+        indentation = provisional_indentation;
+    }
+
+    if(num_lines)
+        _line_ended_undo();
+
+    _c4dbgpf("scanning block: raw=~~~{}~~~", raw_block);
+
+    // ok! now we strip the newlines and spaces according to the specs
+    s = _filter_block_scalar(raw_block, newline, chomp, indentation);
+
+    _c4dbgpf("scanning block: final=~~~{}~~~", s);
+
+    return s;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<bool backslash_is_escape, bool keep_trailing_whitespace>
+bool Parser::_filter_nl(substr r, size_t *C4_RESTRICT i, size_t *C4_RESTRICT pos, size_t indentation)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfnl(fmt, ...) _c4dbgpf("filter_nl[{}]: " fmt, *i, __VA_ARGS__)
+    #else
+    #define _c4dbgfnl(...)
+    #endif
+
+    const char curr = r[*i];
+    bool replaced = false;
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, indentation != npos);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, curr == '\n');
+
+    _c4dbgfnl("found newline. sofar=[{}]~~~{}~~~", *pos, m_filter_arena.first(*pos));
+    size_t ii = *i;
+    size_t numnl_following = count_following_newlines(r, &ii, indentation);
+    if(numnl_following)
+    {
+        _c4dbgfnl("{} consecutive (empty) lines {} in the middle. totalws={}", 1+numnl_following, ii < r.len ? "in the middle" : "at the end", ii - *i);
+        for(size_t j = 0; j < numnl_following; ++j)
+            m_filter_arena.str[(*pos)++] = '\n';
+    }
+    else
+    {
+        if(r.first_not_of(" \t", *i+1) != npos)
+        {
+            m_filter_arena.str[(*pos)++] = ' ';
+            _c4dbgfnl("single newline. convert to space. ii={}/{}. sofar=[{}]~~~{}~~~", ii, r.len, *pos, m_filter_arena.first(*pos));
+            replaced = true;
+        }
+        else
+        {
+            if C4_IF_CONSTEXPR (keep_trailing_whitespace)
+            {
+                m_filter_arena.str[(*pos)++] = ' ';
+                _c4dbgfnl("single newline. convert to space. ii={}/{}. sofar=[{}]~~~{}~~~", ii, r.len, *pos, m_filter_arena.first(*pos));
+                replaced = true;
+            }
+            else
+            {
+                _c4dbgfnl("last newline, everything else is whitespace. ii={}/{}", ii, r.len);
+                *i = r.len;
+            }
+        }
+        if C4_IF_CONSTEXPR (backslash_is_escape)
+        {
+            if(ii < r.len && r.str[ii] == '\\')
+            {
+                const char next = ii+1 < r.len ? r.str[ii+1] : '\0';
+                if(next == ' ' || next == '\t')
+                {
+                    _c4dbgfnl("extend skip to backslash{}", "");
+                    ++ii;
+                }
+            }
+        }
+    }
+    *i = ii - 1; // correct for the loop increment
+
+    #undef _c4dbgfnl
+
+    return replaced;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<bool keep_trailing_whitespace>
+void Parser::_filter_ws(substr r, size_t *C4_RESTRICT i, size_t *C4_RESTRICT pos)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfws(fmt, ...) _c4dbgpf("filt_nl[{}]: " fmt, *i, __VA_ARGS__)
+    #else
+    #define _c4dbgfws(...)
+    #endif
+
+    const char curr = r[*i];
+    _c4dbgfws("found whitespace '{}'", _c4prc(curr));
+    _RYML_CB_ASSERT(m_stack.m_callbacks, curr == ' ' || curr == '\t');
+
+    size_t first = *i > 0 ? r.first_not_of(" \t", *i) : r.first_not_of(' ', *i);
+    if(first != npos)
+    {
+        if(r[first] == '\n' || r[first] == '\r') // skip trailing whitespace
+        {
+            _c4dbgfws("whitespace is trailing on line. firstnonws='{}'@{}", _c4prc(r[first]), first);
+            *i = first - 1; // correct for the loop increment
+        }
+        else // a legit whitespace
+        {
+            m_filter_arena.str[(*pos)++] = curr;
+            _c4dbgfws("legit whitespace. sofar=[{}]~~~{}~~~", *pos, m_filter_arena.first(*pos));
+        }
+    }
+    else
+    {
+        _c4dbgfws("... everything else is trailing whitespace{}", "");
+        if C4_IF_CONSTEXPR (keep_trailing_whitespace)
+            for(size_t j = *i; j < r.len; ++j)
+                m_filter_arena.str[(*pos)++] = r[j];
+        *i = r.len;
+    }
+
+    #undef _c4dbgfws
+}
+
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_filter_plain_scalar(substr s, size_t indentation)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfps(...) _c4dbgpf("filt_plain_scalar" __VA_ARGS__)
+    #else
+    #define _c4dbgfps(...)
+    #endif
+
+    _c4dbgfps("before=~~~{}~~~", s);
+
+    substr r = s.triml(" \t");
+    _grow_filter_arena(r.len);
+    size_t pos = 0; // the filtered size
+    bool filtered_chars = false;
+    for(size_t i = 0; i < r.len; ++i)
+    {
+        const char curr = r.str[i];
+        _c4dbgfps("[{}]: '{}'", i, _c4prc(curr));
+        if(curr == ' ' || curr == '\t')
+        {
+            _filter_ws</*keep_trailing_ws*/false>(r, &i, &pos);
+        }
+        else if(curr == '\n')
+        {
+            filtered_chars = _filter_nl</*backslash_is_escape*/false, /*keep_trailing_ws*/false>(r, &i, &pos, indentation);
+        }
+        else if(curr == '\r')  // skip \r --- https://stackoverflow.com/questions/1885900
+        {
+            ;
+        }
+        else
+        {
+            m_filter_arena.str[pos++] = r[i];
+        }
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+    if(pos < r.len || filtered_chars)
+    {
+        r = _finish_filter_arena(r, pos);
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.len >= r.len);
+    _c4dbgfps("#filteredchars={} after=~~~{}~~~", s.len - r.len, r);
+
+    #undef _c4dbgfps
+    return r;
+}
+
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_filter_squot_scalar(substr s)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfsq(...) _c4dbgpf("filt_squo_scalar")
+    #else
+    #define _c4dbgfsq(...)
+    #endif
+
+    // from the YAML spec for double-quoted scalars:
+    // https://yaml.org/spec/1.2-old/spec.html#style/flow/single-quoted
+
+    _c4dbgfsq(": before=~~~{}~~~", s);
+
+    _grow_filter_arena(s.len);
+    substr r = s;
+    size_t pos = 0; // the filtered size
+    bool filtered_chars = false;
+    for(size_t i = 0; i < r.len; ++i)
+    {
+        const char curr = r[i];
+        _c4dbgfsq("[{}]: '{}'", i, _c4prc(curr));
+        if(curr == ' ' || curr == '\t')
+        {
+            _filter_ws</*keep_trailing_ws*/true>(r, &i, &pos);
+        }
+        else if(curr == '\n')
+        {
+            filtered_chars = _filter_nl</*backslash_is_escape*/false, /*keep_trailing_ws*/true>(r, &i, &pos, /*indentation*/0);
+        }
+        else if(curr == '\r')  // skip \r --- https://stackoverflow.com/questions/1885900
+        {
+            ;
+        }
+        else if(curr == '\'')
+        {
+            char next = i+1 < r.len ? r[i+1] : '\0';
+            if(next == '\'')
+            {
+                _c4dbgfsq("[{}]: two consecutive quotes", i);
+                filtered_chars = true;
+                m_filter_arena.str[pos++] = '\'';
+                ++i;
+            }
+        }
+        else
+        {
+            m_filter_arena.str[pos++] = curr;
+        }
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+    if(pos < r.len || filtered_chars)
+    {
+        r = _finish_filter_arena(r, pos);
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.len >= r.len);
+    _c4dbgpf(": #filteredchars={} after=~~~{}~~~", s.len - r.len, r);
+
+    #undef _c4dbgfsq
+    return r;
+}
+
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_filter_dquot_scalar(substr s)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfdq(...) _c4dbgpf("filt_dquo_scalar" __VA_ARGS__)
+    #else
+    #define _c4dbgfdq(...)
+    #endif
+
+    _c4dbgfdq(": before=~~~{}~~~", s);
+
+    // from the YAML spec for double-quoted scalars:
+    // https://yaml.org/spec/1.2-old/spec.html#style/flow/double-quoted
+    //
+    // All leading and trailing white space characters are excluded
+    // from the content. Each continuation line must therefore contain
+    // at least one non-space character. Empty lines, if any, are
+    // consumed as part of the line folding.
+
+    _grow_filter_arena(s.len + 2u * s.count('\\'));
+    substr r = s;
+    size_t pos = 0; // the filtered size
+    bool filtered_chars = false;
+    for(size_t i = 0; i < r.len; ++i)
+    {
+        const char curr = r[i];
+        _c4dbgfdq("[{}]: '{}'", i, _c4prc(curr));
+        if(curr == ' ' || curr == '\t')
+        {
+            _filter_ws</*keep_trailing_ws*/true>(r, &i, &pos);
+        }
+        else if(curr == '\n')
+        {
+            filtered_chars = _filter_nl</*backslash_is_escape*/true, /*keep_trailing_ws*/true>(r, &i, &pos, /*indentation*/0);
+        }
+        else if(curr == '\r')  // skip \r --- https://stackoverflow.com/questions/1885900
+        {
+            ;
+        }
+        else if(curr == '\\')
+        {
+            char next = i+1 < r.len ? r[i+1] : '\0';
+            _c4dbgfdq("[{}]: backslash, next='{}'", i, _c4prc(next));
+            filtered_chars = true;
+            if(next == '\r')
+            {
+                if(i+2 < r.len && r[i+2] == '\n')
+                {
+                    ++i; // newline escaped with \ -- skip both (add only one as i is loop-incremented)
+                    next = '\n';
+                    _c4dbgfdq("[{}]: was \\r\\n, now next='\\n'", i);
+                }
+            }
+            // remember the loop will also increment i
+            if(next == '\n')
+            {
+                size_t ii = i + 2;
+                for( ; ii < r.len; ++ii)
+                {
+                    if(r.str[ii] == ' ' || r.str[ii] == '\t')  // skip leading whitespace
+                        ;
+                    else
+                        break;
+                }
+                i += ii - i - 1;
+            }
+            else if(next == '"' || next == '/'  || next == ' ' || next == '\t') // escapes for json compatibility
+            {
+                m_filter_arena.str[pos++] = next;
+                ++i;
+            }
+            else if(next == '\r')
+            {
+                //++i;
+            }
+            else if(next == 'n')
+            {
+                m_filter_arena.str[pos++] = '\n';
+                ++i;
+            }
+            else if(next == 'r')
+            {
+                m_filter_arena.str[pos++] = '\r';
+                ++i; // skip
+            }
+            else if(next == 't')
+            {
+                m_filter_arena.str[pos++] = '\t';
+                ++i;
+            }
+            else if(next == '\\')
+            {
+                m_filter_arena.str[pos++] = '\\';
+                ++i;
+            }
+            else if(next == 'x') // UTF8
+            {
+                if(i + 1u + 2u >= r.len)
+                    _c4err("\\x requires 2 hex digits");
+                uint8_t byteval = {};
+                if(!read_hex(r.sub(i + 2u, 2u), &byteval))
+                    _c4err("failed to read \\x codepoint");
+                m_filter_arena.str[pos++] = *(char*)&byteval;
+                i += 1u + 2u;
+            }
+            else if(next == 'u') // UTF16
+            {
+                if(i + 1u + 4u >= r.len)
+                    _c4err("\\u requires 4 hex digits");
+                char readbuf[8];
+                csubstr codepoint = r.sub(i + 2u, 4u);
+                uint32_t codepoint_val = {};
+                if(!read_hex(codepoint, &codepoint_val))
+                    _c4err("failed to parse \\u codepoint");
+                size_t numbytes = decode_code_point((uint8_t*)readbuf, sizeof(readbuf), codepoint_val);
+                C4_ASSERT(numbytes <= 4);
+                memcpy(m_filter_arena.str + pos, readbuf, numbytes);
+                pos += numbytes;
+                i += 1u + 4u;
+            }
+            else if(next == 'U') // UTF32
+            {
+                if(i + 1u + 8u >= r.len)
+                    _c4err("\\U requires 8 hex digits");
+                char readbuf[8];
+                csubstr codepoint = r.sub(i + 2u, 8u);
+                uint32_t codepoint_val = {};
+                if(!read_hex(codepoint, &codepoint_val))
+                    _c4err("failed to parse \\U codepoint");
+                size_t numbytes = decode_code_point((uint8_t*)readbuf, sizeof(readbuf), codepoint_val);
+                C4_ASSERT(numbytes <= 4);
+                memcpy(m_filter_arena.str + pos, readbuf, numbytes);
+                pos += numbytes;
+                i += 1u + 8u;
+            }
+            // https://yaml.org/spec/1.2.2/#rule-c-ns-esc-char
+            else if(next == '0')
+            {
+                m_filter_arena.str[pos++] = '\0';
+                ++i;
+            }
+            else if(next == 'b') // backspace
+            {
+                m_filter_arena.str[pos++] = '\b';
+                ++i;
+            }
+            else if(next == 'f') // form feed
+            {
+                m_filter_arena.str[pos++] = '\f';
+                ++i;
+            }
+            else if(next == 'a') // bell character
+            {
+                m_filter_arena.str[pos++] = '\a';
+                ++i;
+            }
+            else if(next == 'v') // vertical tab
+            {
+                m_filter_arena.str[pos++] = '\v';
+                ++i;
+            }
+            else if(next == 'e') // escape character
+            {
+                m_filter_arena.str[pos++] = '\x1b';
+                ++i;
+            }
+            else if(next == '_') // unicode non breaking space \u00a0
+            {
+                // https://www.compart.com/en/unicode/U+00a0
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x3e, 0xc2);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x60, 0xa0);
+                ++i;
+            }
+            else if(next == 'N') // unicode next line \u0085
+            {
+                // https://www.compart.com/en/unicode/U+0085
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x3e, 0xc2);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x7b, 0x85);
+                ++i;
+            }
+            else if(next == 'L') // unicode line separator \u2028
+            {
+                // https://www.utf8-chartable.de/unicode-utf8-table.pl?start=8192&number=1024&names=-&utf8=0x&unicodeinhtml=hex
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x1e, 0xe2);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x80, 0x80);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x58, 0xa8);
+                ++i;
+            }
+            else if(next == 'P') // unicode paragraph separator \u2029
+            {
+                // https://www.utf8-chartable.de/unicode-utf8-table.pl?start=8192&number=1024&names=-&utf8=0x&unicodeinhtml=hex
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x1e, 0xe2);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x80, 0x80);
+                m_filter_arena.str[pos++] = _RYML_CHCONST(-0x57, 0xa9);
+                ++i;
+            }
+            _c4dbgfdq("[{}]: backslash...sofar=[{}]~~~{}~~~", i, pos, m_filter_arena.first(pos));
+        }
+        else
+        {
+            m_filter_arena.str[pos++] = curr;
+        }
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+    if(pos < r.len || filtered_chars)
+    {
+        r = _finish_filter_arena(r, pos);
+    }
+
+    _RYML_CB_ASSERT(m_stack.m_callbacks, s.len >= r.len);
+    _c4dbgpf(": #filteredchars={} after=~~~{}~~~", s.len - r.len, r);
+
+    #undef _c4dbgfdq
+
+    return r;
+}
+
+
+//-----------------------------------------------------------------------------
+bool Parser::_apply_chomp(substr buf, size_t *C4_RESTRICT pos, BlockChomp_e chomp)
+{
+    substr trimmed = buf.first(*pos).trimr('\n');
+    bool added_newline = false;
+    switch(chomp)
+    {
+    case CHOMP_KEEP:
+        if(trimmed.len == *pos)
+        {
+            _c4dbgpf("chomp=KEEP: add missing newline @{}", *pos);
+            //m_filter_arena.str[(*pos)++] = '\n';
+            added_newline = true;
+        }
+        break;
+    case CHOMP_CLIP:
+        if(trimmed.len == *pos)
+        {
+            _c4dbgpf("chomp=CLIP: add missing newline @{}", *pos);
+            m_filter_arena.str[(*pos)++] = '\n';
+            added_newline = true;
+        }
+        else
+        {
+            _c4dbgpf("chomp=CLIP: include single trailing newline @{}", trimmed.len+1);
+            *pos = trimmed.len + 1;
+        }
+        break;
+    case CHOMP_STRIP:
+        _c4dbgpf("chomp=STRIP: strip {}-{}-{} newlines", *pos, trimmed.len, *pos-trimmed.len);
+        *pos = trimmed.len;
+        break;
+    default:
+        _c4err("unknown chomp style");
+    }
+    return added_newline;
+}
+
+
+//-----------------------------------------------------------------------------
+csubstr Parser::_filter_block_scalar(substr s, BlockStyle_e style, BlockChomp_e chomp, size_t indentation)
+{
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgfbl(fmt, ...) _c4dbgpf("filt_block" fmt, __VA_ARGS__)
+    #else
+    #define _c4dbgfbl(...)
+    #endif
+
+    _c4dbgfbl(": indentation={} before=[{}]~~~{}~~~", indentation, s.len, s);
+
+    if(chomp != CHOMP_KEEP && s.trim(" \n\r\t").len == 0u)
+    {
+        _c4dbgp("filt_block: empty scalar");
+        return s.first(0);
+    }
+
+    substr r = s;
+
+    switch(style)
+    {
+    case BLOCK_LITERAL:
+        {
+            _c4dbgp("filt_block: style=literal");
+            // trim leading whitespace up to indentation
+            {
+                size_t numws = r.first_not_of(' ');
+                if(numws != npos)
+                {
+                    if(numws > indentation)
+                        r = r.sub(indentation);
+                    else
+                        r = r.sub(numws);
+                    _c4dbgfbl(": after triml=[{}]~~~{}~~~", r.len, r);
+                }
+                else
+                {
+                    if(chomp != CHOMP_KEEP || r.len == 0)
+                    {
+                        _c4dbgfbl(": all spaces {}, return empty", r.len);
+                        return r.first(0);
+                    }
+                    else
+                    {
+                        r[0] = '\n';
+                        return r.first(1);
+                    }
+                }
+            }
+            _grow_filter_arena(s.len + 2u);  // use s.len! because we may need to add a newline at the end, so the leading indentation will allow space for that newline
+            size_t pos = 0; // the filtered size
+            for(size_t i = 0; i < r.len; ++i)
+            {
+                const char curr = r.str[i];
+                _c4dbgfbl("[{}]='{}'  pos={}", i, _c4prc(curr), pos);
+                if(curr == '\r')
+                    continue;
+                m_filter_arena.str[pos++] = curr;
+                if(curr == '\n')
+                {
+                    _c4dbgfbl("[{}]: found newline", i);
+                    // skip indentation on the next line
+                    csubstr rem = r.sub(i+1);
+                    size_t first = rem.first_not_of(' ');
+                    if(first != npos)
+                    {
+                        _RYML_CB_ASSERT(m_stack.m_callbacks, first < rem.len);
+                        _RYML_CB_ASSERT(m_stack.m_callbacks, i+1+first < r.len);
+                        _c4dbgfbl("[{}]: {} spaces follow before next nonws character @ [{}]='{}'", i, first, i+1+first, rem.str[first]);
+                        if(first < indentation)
+                        {
+                            _c4dbgfbl("[{}]: skip {}<{} spaces from indentation", i, first, indentation);
+                            i += first;
+                        }
+                        else
+                        {
+                            _c4dbgfbl("[{}]: skip {} spaces from indentation", i, indentation);
+                            i += indentation;
+                        }
+                    }
+                    else
+                    {
+                        _RYML_CB_ASSERT(m_stack.m_callbacks, i+1 <= r.len);
+                        first = rem.len;
+                        _c4dbgfbl("[{}]: {} spaces to the end", i, first);
+                        if(first)
+                        {
+                            if(first < indentation)
+                            {
+                                _c4dbgfbl("[{}]: skip everything", i);
+                                --pos;
+                                break;
+                            }
+                            else
+                            {
+                                _c4dbgfbl("[{}]: skip {} spaces from indentation", i, indentation);
+                                i += indentation;
+                            }
+                        }
+                        else if(i+1 == r.len)
+                        {
+                            if(chomp == CHOMP_STRIP)
+                                --pos;
+                            break;
+                        }
+                    }
+                }
+            }
+            _RYML_CB_ASSERT(m_stack.m_callbacks, s.len >= pos);
+            _c4dbgfbl(": #filteredchars={} after=~~~{}~~~", s.len - r.len, r);
+            bool changed = _apply_chomp(m_filter_arena, &pos, chomp);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+            _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= s.len);
+            if(pos < r.len || changed)
+            {
+                r = _finish_filter_arena(s, pos); // write into s
+            }
+            break;
+        }
+    case BLOCK_FOLD:
+        {
+            _c4dbgp("filt_block: style=fold");
+            _grow_filter_arena(r.len + 2);
+            size_t pos = 0; // the filtered size
+            bool filtered_chars = false;
+            bool started = false;
+            bool is_indented = false;
+            size_t i = r.first_not_of(' ');
+            _c4dbgfbl(": first non space at {}", i);
+            if(i > indentation)
+            {
+                is_indented = true;
+                i = indentation;
+            }
+            _c4dbgfbl(": start folding at {}, is_indented={}", i, (int)is_indented);
+            auto on_change_indentation = [&](size_t numnl_following, size_t last_newl, size_t first_non_whitespace){
+                _c4dbgfbl("[{}]: add 1+{} newlines", i, numnl_following);
+                for(size_t j = 0; j < 1 + numnl_following; ++j)
+                    m_filter_arena.str[pos++] = '\n';
+                for(i = last_newl + 1 + indentation; i < first_non_whitespace; ++i)
+                {
+                    if(r.str[i] == '\r')
+                        continue;
+                    _c4dbgfbl("[{}]: add '{}'", i, _c4prc(r.str[i]));
+                    m_filter_arena.str[pos++] = r.str[i];
+                }
+                --i;
+            };
+            for( ; i < r.len; ++i)
+            {
+                const char curr = r.str[i];
+                _c4dbgfbl("[{}]='{}'", i, _c4prc(curr));
+                if(curr == '\n')
+                {
+                    filtered_chars = true;
+                    // skip indentation on the next line, and advance over the next non-indented blank lines as well
+                    size_t first_non_whitespace;
+                    size_t numnl_following = (size_t)-1;
+                    while(r[i] == '\n')
+                    {
+                        ++numnl_following;
+                        csubstr rem = r.sub(i+1);
+                        size_t first = rem.first_not_of(' ');
+                        _c4dbgfbl("[{}]: found newline. first={} rem.len={}", i, first, rem.len);
+                        if(first != npos)
+                        {
+                            first_non_whitespace = first + i+1;
+                            while(first_non_whitespace < r.len && r[first_non_whitespace] == '\r')
+                                ++first_non_whitespace;
+                            _RYML_CB_ASSERT(m_stack.m_callbacks, first < rem.len);
+                            _RYML_CB_ASSERT(m_stack.m_callbacks, i+1+first < r.len);
+                            _c4dbgfbl("[{}]: {} spaces follow before next nonws character @ [{}]='{}'", i, first, i+1+first, _c4prc(rem.str[first]));
+                            if(first < indentation)
+                            {
+                                _c4dbgfbl("[{}]: skip {}<{} spaces from indentation", i, first, indentation);
+                                i += first;
+                            }
+                            else
+                            {
+                                _c4dbgfbl("[{}]: skip {} spaces from indentation", i, indentation);
+                                i += indentation;
+                                if(first > indentation)
+                                {
+                                    _c4dbgfbl("[{}]: {} further indented than {}, stop newlining", i, first, indentation);
+                                    goto finished_counting_newlines;
+                                }
+                            }
+                            // prepare the next while loop iteration
+                            // by setting i at the next newline after
+                            // an empty line
+                            if(r[first_non_whitespace] == '\n')
+                                i = first_non_whitespace;
+                            else
+                                goto finished_counting_newlines;
+                        }
+                        else
+                        {
+                            _RYML_CB_ASSERT(m_stack.m_callbacks, i+1 <= r.len);
+                            first = rem.len;
+                            first_non_whitespace = first + i+1;
+                            if(first)
+                            {
+                                _c4dbgfbl("[{}]: {} spaces to the end", i, first);
+                                if(first < indentation)
+                                {
+                                    _c4dbgfbl("[{}]: skip everything", i);
+                                    i += first;
+                                }
+                                else
+                                {
+                                    _c4dbgfbl("[{}]: skip {} spaces from indentation", i, indentation);
+                                    i += indentation;
+                                    if(first > indentation)
+                                    {
+                                        _c4dbgfbl("[{}]: {} spaces missing. not done yet", i, indentation - first);
+                                        goto finished_counting_newlines;
+                                    }
+                                }
+                            }
+                            else // if(i+1 == r.len)
+                            {
+                                _c4dbgfbl("[{}]: it's the final newline", i);
+                                _RYML_CB_ASSERT(m_stack.m_callbacks, i+1 == r.len);
+                                _RYML_CB_ASSERT(m_stack.m_callbacks, rem.len == 0);
+                            }
+                            goto end_of_scalar;
+                        }
+                    }
+                end_of_scalar:
+                    // Write all the trailing newlines. Since we're
+                    // at the end no folding is needed, so write every
+                    // newline (add 1).
+                    _c4dbgfbl("[{}]: add {} trailing newlines", i, 1+numnl_following);
+                    for(size_t j = 0; j < 1 + numnl_following; ++j)
+                        m_filter_arena.str[pos++] = '\n';
+                    break;
+                finished_counting_newlines:
+                    _c4dbgfbl("[{}]: #newlines={} firstnonws={}", i, numnl_following, first_non_whitespace);
+                    while(first_non_whitespace < r.len && r[first_non_whitespace] == '\t')
+                        ++first_non_whitespace;
+                    _c4dbgfbl("[{}]: #newlines={} firstnonws={}", i, numnl_following, first_non_whitespace);
+                    _RYML_CB_ASSERT(m_stack.m_callbacks, first_non_whitespace <= r.len);
+                    size_t last_newl = r.last_of('\n', first_non_whitespace);
+                    size_t this_indentation = first_non_whitespace - last_newl - 1;
+                    _c4dbgfbl("[{}]: #newlines={} firstnonws={} lastnewl={} this_indentation={} vs indentation={}", i, numnl_following, first_non_whitespace, last_newl, this_indentation, indentation);
+                    _RYML_CB_ASSERT(m_stack.m_callbacks, first_non_whitespace >= last_newl + 1);
+                    _RYML_CB_ASSERT(m_stack.m_callbacks, this_indentation >= indentation);
+                    if(!started)
+                    {
+                        _c4dbgfbl("[{}]: #newlines={}. write all leading newlines", i, numnl_following);
+                        for(size_t j = 0; j < 1 + numnl_following; ++j)
+                            m_filter_arena.str[pos++] = '\n';
+                        if(this_indentation > indentation)
+                        {
+                            is_indented = true;
+                            _c4dbgfbl("[{}]: advance ->{}", i, last_newl + indentation);
+                            i = last_newl + indentation;
+                        }
+                        else
+                        {
+                            i = first_non_whitespace - 1;
+                            _c4dbgfbl("[{}]: advance ->{}", i, first_non_whitespace);
+                        }
+                    }
+                    else if(this_indentation == indentation)
+                    {
+                        _c4dbgfbl("[{}]: same indentation", i);
+                        if(!is_indented)
+                        {
+                            if(numnl_following == 0)
+                            {
+                                _c4dbgfbl("[{}]: fold!", i);
+                                m_filter_arena.str[pos++] = ' ';
+                            }
+                            else
+                            {
+                                _c4dbgfbl("[{}]: add {} newlines", i, 1 + numnl_following);
+                                for(size_t j = 0; j < numnl_following; ++j)
+                                    m_filter_arena.str[pos++] = '\n';
+                            }
+                            i = first_non_whitespace - 1;
+                            _c4dbgfbl("[{}]: advance {}->{}", i, i, first_non_whitespace);
+                        }
+                        else
+                        {
+                            _c4dbgfbl("[{}]: back to ref indentation", i);
+                            is_indented = false;
+                            on_change_indentation(numnl_following, last_newl, first_non_whitespace);
+                            _c4dbgfbl("[{}]: advance {}->{}", i, i, first_non_whitespace);
+                        }
+                    }
+                    else
+                    {
+                        _c4dbgfbl("[{}]: increased indentation.", i);
+                        is_indented = true;
+                        _RYML_CB_ASSERT(m_stack.m_callbacks, this_indentation > indentation);
+                        on_change_indentation(numnl_following, last_newl, first_non_whitespace);
+                        _c4dbgfbl("[{}]: advance {}->{}", i, i, first_non_whitespace);
+                    }
+                }
+                else if(curr != '\r')
+                {
+                    if(curr != '\t')
+                        started = true;
+                    m_filter_arena.str[pos++] = curr;
+                }
+            }
+            _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+            _c4dbgfbl(": #filteredchars={} after=[{}]~~~{}~~~", (int)s.len - (int)pos, pos, m_filter_arena.first(pos));
+            bool changed = _apply_chomp(m_filter_arena, &pos, chomp);
+            if(pos < r.len || filtered_chars || changed)
+            {
+                r = _finish_filter_arena(s, pos); // write into s
+            }
+        }
+        break;
+    default:
+        _c4err("unknown block style");
+    }
+
+    _c4dbgfbl(": final=[{}]~~~{}~~~", r.len, r);
+
+    #undef _c4dbgfbl
+
+    return r;
+}
+
+//-----------------------------------------------------------------------------
+size_t Parser::_count_nlines(csubstr src)
+{
+    return 1 + src.count('\n');
+}
+
+//-----------------------------------------------------------------------------
+void Parser::_handle_directive(csubstr directive_)
+{
+    csubstr directive = directive_;
+    if(directive.begins_with("%TAG"))
+    {
+        TagDirective td;
+        _c4dbgpf("%TAG directive: {}", directive_);
+        directive = directive.sub(4);
+        if(!directive.begins_with(' '))
+            _c4err("malformed tag directive: {}", directive_);
+        directive = directive.triml(' ');
+        size_t pos = directive.find(' ');
+        if(pos == npos)
+            _c4err("malformed tag directive: {}", directive_);
+        td.handle = directive.first(pos);
+        directive = directive.sub(td.handle.len).triml(' ');
+        pos = directive.find(' ');
+        if(pos != npos)
+            directive = directive.first(pos);
+        td.prefix = directive;
+        td.next_node_id = m_tree->size();
+        if(m_tree->size() > 0)
+        {
+            size_t prev = m_tree->size() - 1;
+            if(m_tree->is_root(prev) && m_tree->type(prev) != NOTYPE && !m_tree->is_stream(prev))
+                ++td.next_node_id;
+        }
+        _c4dbgpf("%TAG: handle={} prefix={} next_node={}", td.handle, td.prefix, td.next_node_id);
+        m_tree->add_tag_directive(td);
+    }
+    else if(directive.begins_with("%YAML"))
+    {
+        _c4dbgpf("%YAML directive! ignoring...: {}", directive);
+    }
+}
+
+//-----------------------------------------------------------------------------
+void Parser::set_flags(flag_t f, State * s)
+{
+#ifdef RYML_DBG
+    char buf1_[64], buf2_[64];
+    csubstr buf1 = _prfl(buf1_, f);
+    csubstr buf2 = _prfl(buf2_, s->flags);
+    _c4dbgpf("state[{}]: setting flags to {}: before={}", s-m_stack.begin(), buf1, buf2);
+#endif
+    s->flags = f;
+}
+
+void Parser::add_flags(flag_t on, State * s)
+{
+#ifdef RYML_DBG
+    char buf1_[64], buf2_[64], buf3_[64];
+    csubstr buf1 = _prfl(buf1_, on);
+    csubstr buf2 = _prfl(buf2_, s->flags);
+    csubstr buf3 = _prfl(buf3_, s->flags|on);
+    _c4dbgpf("state[{}]: adding flags {}: before={} after={}", s-m_stack.begin(), buf1, buf2, buf3);
+#endif
+    s->flags |= on;
+}
+
+void Parser::addrem_flags(flag_t on, flag_t off, State * s)
+{
+#ifdef RYML_DBG
+    char buf1_[64], buf2_[64], buf3_[64], buf4_[64];
+    csubstr buf1 = _prfl(buf1_, on);
+    csubstr buf2 = _prfl(buf2_, off);
+    csubstr buf3 = _prfl(buf3_, s->flags);
+    csubstr buf4 = _prfl(buf4_, ((s->flags|on)&(~off)));
+    _c4dbgpf("state[{}]: adding flags {} / removing flags {}: before={} after={}", s-m_stack.begin(), buf1, buf2, buf3, buf4);
+#endif
+    s->flags |= on;
+    s->flags &= ~off;
+}
+
+void Parser::rem_flags(flag_t off, State * s)
+{
+#ifdef RYML_DBG
+    char buf1_[64], buf2_[64], buf3_[64];
+    csubstr buf1 = _prfl(buf1_, off);
+    csubstr buf2 = _prfl(buf2_, s->flags);
+    csubstr buf3 = _prfl(buf3_, s->flags&(~off));
+    _c4dbgpf("state[{}]: removing flags {}: before={} after={}", s-m_stack.begin(), buf1, buf2, buf3);
+#endif
+    s->flags &= ~off;
+}
+
+//-----------------------------------------------------------------------------
+
+csubstr Parser::_prfl(substr buf, flag_t flags)
+{
+    size_t pos = 0;
+    bool gotone = false;
+
+    #define _prflag(fl)                                     \
+    if((flags & fl) == (fl))                                \
+    {                                                       \
+        if(gotone)                                          \
+        {                                                   \
+            if(pos + 1 < buf.len)                           \
+                buf[pos] = '|';                             \
+            ++pos;                                          \
+        }                                                   \
+        csubstr fltxt = #fl;                                \
+        if(pos + fltxt.len <= buf.len)                      \
+            memcpy(buf.str + pos, fltxt.str, fltxt.len);    \
+        pos += fltxt.len;                                   \
+        gotone = true;                                      \
+    }
+
+    _prflag(RTOP);
+    _prflag(RUNK);
+    _prflag(RMAP);
+    _prflag(RSEQ);
+    _prflag(FLOW);
+    _prflag(QMRK);
+    _prflag(RKEY);
+    _prflag(RVAL);
+    _prflag(RNXT);
+    _prflag(SSCL);
+    _prflag(QSCL);
+    _prflag(RSET);
+    _prflag(NDOC);
+    _prflag(RSEQIMAP);
+
+    #undef _prflag
+
+    RYML_ASSERT(pos <= buf.len);
+
+    return buf.first(pos);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+void Parser::_grow_filter_arena(size_t num_characters_needed)
+{
+    _c4dbgpf("grow: arena={} numchars={}", m_filter_arena.len, num_characters_needed);
+    if(num_characters_needed <= m_filter_arena.len)
+        return;
+    size_t sz = m_filter_arena.len << 1;
+    _c4dbgpf("grow: sz={}", sz);
+    sz = num_characters_needed > sz ? num_characters_needed : sz;
+    _c4dbgpf("grow: sz={}", sz);
+    sz = sz < 128u ? 128u : sz;
+    _c4dbgpf("grow: sz={}", sz);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, sz >= num_characters_needed);
+    _resize_filter_arena(sz);
+}
+
+void Parser::_resize_filter_arena(size_t num_characters)
+{
+    if(num_characters > m_filter_arena.len)
+    {
+        _c4dbgpf("resize: sz={}", num_characters);
+        char *prev = m_filter_arena.str;
+        if(m_filter_arena.str)
+        {
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_filter_arena.len > 0);
+            _RYML_CB_FREE(m_stack.m_callbacks, m_filter_arena.str, char, m_filter_arena.len);
+        }
+        m_filter_arena.str = _RYML_CB_ALLOC_HINT(m_stack.m_callbacks, char, num_characters, prev);
+        m_filter_arena.len = num_characters;
+    }
+}
+
+substr Parser::_finish_filter_arena(substr dst, size_t pos)
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= m_filter_arena.len);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, pos <= dst.len);
+    memcpy(dst.str, m_filter_arena.str, pos);
+    return dst.first(pos);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+csubstr Parser::location_contents(Location const& loc) const
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, loc.offset < m_buf.len);
+    return m_buf.sub(loc.offset);
+}
+
+Location Parser::location(NodeRef node) const
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, node.valid());
+    return location(*node.tree(), node.id());
+}
+
+Location Parser::location(Tree const& tree, size_t node) const
+{
+    _RYML_CB_CHECK(m_stack.m_callbacks, m_buf.str == m_newline_offsets_buf.str);
+    _RYML_CB_CHECK(m_stack.m_callbacks, m_buf.len == m_newline_offsets_buf.len);
+    if(tree.has_key(node))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, tree.key(node).is_sub(m_buf));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.is_super(tree.key(node)));
+        return val_location(tree.key(node).str);
+    }
+    else if(tree.has_val(node))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, tree.val(node).is_sub(m_buf));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.is_super(tree.val(node)));
+        return val_location(tree.val(node).str);
+    }
+    else if(tree.is_container(node))
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, !tree.has_key(node));
+        if(!tree.is_stream(node))
+        {
+            const char *node_start = tree._p(node)->m_val.scalar.str;  // this was stored in the container
+            if(tree.has_children(node))
+            {
+                size_t child = tree.first_child(node);
+                if(tree.has_key(child))
+                {
+                    // when a map starts, the container was set after the key
+                    csubstr k = tree.key(child);
+                    if(node_start > k.str)
+                        node_start = k.str;
+                }
+            }
+            return val_location(node_start);
+        }
+        else // it's a stream
+        {
+            return val_location(m_buf.str); // just return the front of the buffer
+        }
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, tree.type(node) == NOTYPE);
+    return val_location(m_buf.str);
+}
+
+Location Parser::val_location(const char *val) const
+{
+    if(_locations_dirty())
+        _prepare_locations();
+    csubstr src = m_buf;
+    _RYML_CB_CHECK(m_stack.m_callbacks, src.str == m_newline_offsets_buf.str);
+    _RYML_CB_CHECK(m_stack.m_callbacks, src.len == m_newline_offsets_buf.len);
+    _RYML_CB_CHECK(m_stack.m_callbacks, val >= src.begin() && val <= src.end());
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_newline_offsets != nullptr);
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_newline_offsets_size > 0);
+    using linetype = size_t const* C4_RESTRICT;
+    linetype line = nullptr;
+    size_t offset = (size_t)(val - src.begin());
+    if(m_newline_offsets_size < 30)
+    {
+        // do a linear search if the size is small.
+        for(linetype curr = m_newline_offsets; curr < m_newline_offsets + m_newline_offsets_size; ++curr)
+        {
+            if(*curr > offset)
+            {
+                line = curr;
+                break;
+            }
+        }
+    }
+    else
+    {
+        // Do a bisection search if the size is not small.
+        //
+        // We could use std::lower_bound but this is simple enough and
+        // spares the include of <algorithm>.
+        size_t count = m_newline_offsets_size;
+        size_t step;
+        linetype it;
+        line = m_newline_offsets;
+        while(count)
+        {
+            step = count >> 1;
+            it = line + step;
+            if(*it < offset)
+            {
+                line = ++it;
+                count -= step + 1;
+            }
+            else
+            {
+                count = step;
+            }
+        }
+    }
+    if(line)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, *line > offset);
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_buf.empty());
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_newline_offsets_size == 1);
+        line = m_newline_offsets;
+    }
+    _RYML_CB_ASSERT(m_stack.m_callbacks, line >= m_newline_offsets && line < m_newline_offsets + m_newline_offsets_size);;
+    Location loc = {};
+    loc.name = m_file;
+    loc.offset = offset;
+    loc.line = (size_t)(line - m_newline_offsets);
+    if(line > m_newline_offsets)
+        loc.col = (offset - *(line-1) - 1u);
+    else
+        loc.col = offset;
+    return loc;
+}
+
+void Parser::_prepare_locations() const
+{
+    _RYML_CB_ASSERT(m_stack.m_callbacks, !m_file.empty());
+    size_t numnewlines = 1u + m_buf.count('\n');
+    _resize_locations(numnewlines);
+    m_newline_offsets_size = 0;
+    for(size_t i = 0; i < m_buf.len; i++)
+        if(m_buf[i] == '\n')
+            m_newline_offsets[m_newline_offsets_size++] = i;
+    m_newline_offsets[m_newline_offsets_size++] = m_buf.len;
+    _RYML_CB_ASSERT(m_stack.m_callbacks, m_newline_offsets_size == numnewlines);
+}
+
+void Parser::_resize_locations(size_t numnewlines) const
+{
+    if(numnewlines > m_newline_offsets_capacity)
+    {
+        if(m_newline_offsets)
+            _RYML_CB_FREE(m_stack.m_callbacks, m_newline_offsets, size_t, m_newline_offsets_capacity);
+        m_newline_offsets = _RYML_CB_ALLOC_HINT(m_stack.m_callbacks, size_t, numnewlines, m_newline_offsets);
+        m_newline_offsets_capacity = numnewlines;
+    }
+}
+
+void Parser::_mark_locations_dirty()
+{
+    m_newline_offsets_size = 0u;
+    m_newline_offsets_buf = m_buf;
+}
+
+bool Parser::_locations_dirty() const
+{
+    return !m_newline_offsets_size;
+}
+
+} // namespace yml
+} // namespace c4
+
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/parse.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/node.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+
+namespace c4 {
+namespace yml {
+
+size_t NodeRef::set_key_serialized(c4::fmt::const_base64_wrapper w)
+{
+    _apply_seed();
+    csubstr encoded = this->to_arena(w);
+    this->set_key(encoded);
+    return encoded.len;
+}
+
+size_t NodeRef::set_val_serialized(c4::fmt::const_base64_wrapper w)
+{
+    _apply_seed();
+    csubstr encoded = this->to_arena(w);
+    this->set_val(encoded);
+    return encoded.len;
+}
+
+size_t NodeRef::deserialize_key(c4::fmt::base64_wrapper w) const
+{
+    RYML_ASSERT( ! is_seed());
+    RYML_ASSERT(valid());
+    RYML_ASSERT(get() != nullptr);
+    return from_chars(key(), &w);
+}
+
+size_t NodeRef::deserialize_val(c4::fmt::base64_wrapper w) const
+{
+    RYML_ASSERT( ! is_seed());
+    RYML_ASSERT(valid());
+    RYML_ASSERT(get() != nullptr);
+    return from_chars(val(), &w);
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/node.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/preprocess.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_PREPROCESS_HPP_
+#define _C4_YML_PREPROCESS_HPP_
+
+/** @file preprocess.hpp Functions for preprocessing YAML prior to parsing. */
+
+/** @defgroup Preprocessors Preprocessor functions
+ *
+ * These are the existing preprocessors:
+ *
+ * @code{.cpp}
+ * size_t preprocess_json(csubstr json, substr buf)
+ * size_t preprocess_rxmap(csubstr json, substr buf)
+ * @endcode
+ */
+
+#ifndef _C4_YML_COMMON_HPP_
+//included above:
+//#include "./common.hpp"
+#endif
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/substr.hpp
+//#include <c4/substr.hpp>
+#if !defined(C4_SUBSTR_HPP_) && !defined(_C4_SUBSTR_HPP_)
+#error "amalgamate: file c4/substr.hpp must have been included at this point"
+#endif /* C4_SUBSTR_HPP_ */
+
+
+
+namespace c4 {
+namespace yml {
+
+namespace detail {
+using Preprocessor = size_t(csubstr, substr);
+template<Preprocessor PP, class CharContainer>
+substr preprocess_into_container(csubstr input, CharContainer *out)
+{
+    // try to write once. the preprocessor will stop writing at the end of
+    // the container, but will process all the input to determine the
+    // required container size.
+    size_t sz = PP(input, to_substr(*out));
+    // if the container size is not enough, resize, and run again in the
+    // resized container
+    if(sz > out->size())
+    {
+        out->resize(sz);
+        sz = PP(input, to_substr(*out));
+    }
+    return to_substr(*out).first(sz);
+}
+} // namespace detail
+
+
+//-----------------------------------------------------------------------------
+
+/** @name preprocess_rxmap
+ * Convert flow-type relaxed maps (with implicit bools) into strict YAML
+ * flow map.
+ *
+ * @code{.yaml}
+ * {a, b, c, d: [e, f], g: {a, b}}
+ * # is converted into this:
+ * {a: 1, b: 1, c: 1, d: [e, f], g: {a, b}}
+ * @endcode
+
+ * @note this is NOT recursive - conversion happens only in the top-level map
+ * @param rxmap A relaxed map
+ * @param buf output buffer
+ * @param out output container
+ */
+
+//@{
+
+/** Write into a given output buffer. This function is safe to call with
+ * empty or small buffers; it won't write beyond the end of the buffer.
+ *
+ * @return the number of characters required for output
+ */
+RYML_EXPORT size_t preprocess_rxmap(csubstr rxmap, substr buf);
+
+
+/** Write into an existing container. It is resized to contained the output.
+ * @return a substr of the container
+ * @overload preprocess_rxmap */
+template<class CharContainer>
+substr preprocess_rxmap(csubstr rxmap, CharContainer *out)
+{
+    return detail::preprocess_into_container<preprocess_rxmap>(rxmap, out);
+}
+
+
+/** Create a container with the result.
+ * @overload preprocess_rxmap */
+template<class CharContainer>
+CharContainer preprocess_rxmap(csubstr rxmap)
+{
+    CharContainer out;
+    preprocess_rxmap(rxmap, &out);
+    return out;
+}
+
+//@}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_PREPROCESS_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/preprocess.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.hpp
+//#include "c4/yml/preprocess.hpp"
+#if !defined(C4_YML_PREPROCESS_HPP_) && !defined(_C4_YML_PREPROCESS_HPP_)
+#error "amalgamate: file c4/yml/preprocess.hpp must have been included at this point"
+#endif /* C4_YML_PREPROCESS_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/parser_dbg.hpp
+//#include "c4/yml/detail/parser_dbg.hpp"
+#if !defined(C4_YML_DETAIL_PARSER_DBG_HPP_) && !defined(_C4_YML_DETAIL_PARSER_DBG_HPP_)
+#error "amalgamate: file c4/yml/detail/parser_dbg.hpp must have been included at this point"
+#endif /* C4_YML_DETAIL_PARSER_DBG_HPP_ */
+
+
+/** @file preprocess.hpp Functions for preprocessing YAML prior to parsing. */
+
+namespace c4 {
+namespace yml {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace {
+C4_ALWAYS_INLINE bool _is_idchar(char c)
+{
+    return (c >= 'a' && c <= 'z')
+        || (c >= 'A' && c <= 'Z')
+        || (c >= '0' && c <= '9')
+        || (c == '_' || c == '-' || c == '~' || c == '$');
+}
+
+typedef enum { kReadPending = 0, kKeyPending = 1, kValPending = 2 } _ppstate;
+C4_ALWAYS_INLINE _ppstate _next(_ppstate s)
+{
+    int n = (int)s + 1;
+    return (_ppstate)(n <= (int)kValPending ? n : 0);
+}
+} // empty namespace
+
+
+//-----------------------------------------------------------------------------
+
+size_t preprocess_rxmap(csubstr s, substr buf)
+{
+    detail::_SubstrWriter writer(buf);
+    _ppstate state = kReadPending;
+    size_t last = 0;
+
+    if(s.begins_with('{'))
+    {
+        RYML_CHECK(s.ends_with('}'));
+        s = s.offs(1, 1);
+    }
+
+    writer.append('{');
+
+    for(size_t i = 0; i < s.len; ++i)
+    {
+        const char curr = s[i];
+        const char next = i+1 < s.len ? s[i+1] : '\0';
+
+        if(curr == '\'' || curr == '"')
+        {
+            csubstr ss = s.sub(i).pair_range_esc(curr, '\\');
+            i += static_cast<size_t>(ss.end() - (s.str + i));
+            state = _next(state);
+        }
+        else if(state == kReadPending && _is_idchar(curr))
+        {
+            state = _next(state);
+        }
+
+        switch(state)
+        {
+        case kKeyPending:
+        {
+            if(curr == ':' && next == ' ')
+            {
+                state = _next(state);
+            }
+            else if(curr == ',' && next == ' ')
+            {
+                writer.append(s.range(last, i));
+                writer.append(": 1, ");
+                last = i + 2;
+            }
+            break;
+        }
+        case kValPending:
+        {
+            if(curr == '[' || curr == '{' || curr == '(')
+            {
+                csubstr ss = s.sub(i).pair_range_nested(curr, '\\');
+                i += static_cast<size_t>(ss.end() - (s.str + i));
+                state = _next(state);
+            }
+            else if(curr == ',' && next == ' ')
+            {
+                state = _next(state);
+            }
+            break;
+        }
+        default:
+            // nothing to do
+            break;
+        }
+    }
+
+    writer.append(s.sub(last));
+    if(state == kKeyPending)
+        writer.append(": 1");
+    writer.append('}');
+
+    return writer.pos;
+}
+
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/detail/checks.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/checks.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_YML_DETAIL_CHECKS_HPP_
+#define C4_YML_DETAIL_CHECKS_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wtype-limits" // error: comparison of unsigned expression >= 0 is always true
+#elif defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4296/*expression is always 'boolean_value'*/)
+#endif
+
+namespace c4 {
+namespace yml {
+
+
+void check_invariants(Tree const& t, size_t node=NONE);
+void check_free_list(Tree const& t);
+void check_arena(Tree const& t);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void check_invariants(Tree const& t, size_t node)
+{
+    if(node == NONE)
+    {
+        if(t.size() == 0) return;
+        node = t.root_id();
+    }
+
+    auto const& n = *t._p(node);
+#ifdef RYML_DBG
+    if(n.m_first_child != NONE || n.m_last_child != NONE)
+    {
+        printf("check(%zu): fc=%zu lc=%zu\n", node, n.m_first_child, n.m_last_child);
+    }
+    else
+    {
+        printf("check(%zu)\n", node);
+    }
+#endif
+
+    C4_CHECK(n.m_parent != node);
+    if(n.m_parent == NONE)
+    {
+        C4_CHECK(t.is_root(node));
+    }
+    else //if(n.m_parent != NONE)
+    {
+        C4_CHECK(t.has_child(n.m_parent, node));
+
+        auto const& p = *t._p(n.m_parent);
+        if(n.m_prev_sibling == NONE)
+        {
+            C4_CHECK(p.m_first_child == node);
+            C4_CHECK(t.first_sibling(node) == node);
+        }
+        else
+        {
+            C4_CHECK(p.m_first_child != node);
+            C4_CHECK(t.first_sibling(node) != node);
+        }
+
+        if(n.m_next_sibling == NONE)
+        {
+            C4_CHECK(p.m_last_child == node);
+            C4_CHECK(t.last_sibling(node) == node);
+        }
+        else
+        {
+            C4_CHECK(p.m_last_child != node);
+            C4_CHECK(t.last_sibling(node) != node);
+        }
+    }
+
+    C4_CHECK(n.m_first_child != node);
+    C4_CHECK(n.m_last_child != node);
+    if(n.m_first_child != NONE || n.m_last_child != NONE)
+    {
+        C4_CHECK(n.m_first_child != NONE);
+        C4_CHECK(n.m_last_child != NONE);
+    }
+
+    C4_CHECK(n.m_prev_sibling != node);
+    C4_CHECK(n.m_next_sibling != node);
+    if(n.m_prev_sibling != NONE)
+    {
+        C4_CHECK(t._p(n.m_prev_sibling)->m_next_sibling == node);
+        C4_CHECK(t._p(n.m_prev_sibling)->m_prev_sibling != node);
+    }
+    if(n.m_next_sibling != NONE)
+    {
+        C4_CHECK(t._p(n.m_next_sibling)->m_prev_sibling == node);
+        C4_CHECK(t._p(n.m_next_sibling)->m_next_sibling != node);
+    }
+
+    size_t count = 0;
+    for(size_t i = n.m_first_child; i != NONE; i = t.next_sibling(i))
+    {
+#ifdef RYML_DBG
+        printf("check(%zu):               descend to child[%zu]=%zu\n", node, count, i);
+#endif
+        auto const& ch = *t._p(i);
+        C4_CHECK(ch.m_parent == node);
+        C4_CHECK(ch.m_next_sibling != i);
+        ++count;
+    }
+    C4_CHECK(count == t.num_children(node));
+
+    if(n.m_prev_sibling == NONE && n.m_next_sibling == NONE)
+    {
+        if(n.m_parent != NONE)
+        {
+            C4_CHECK(t.num_children(n.m_parent) == 1);
+            C4_CHECK(t.num_siblings(node) == 1);
+        }
+    }
+
+    if(node == t.root_id())
+    {
+        C4_CHECK(t.size() == t.m_size);
+        C4_CHECK(t.capacity() == t.m_cap);
+        C4_CHECK(t.m_cap == t.m_size + t.slack());
+        check_free_list(t);
+        check_arena(t);
+    }
+
+    for(size_t i = t.first_child(node); i != NONE; i = t.next_sibling(i))
+    {
+        check_invariants(t, i);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void check_free_list(Tree const& t)
+{
+    if(t.m_free_head == NONE)
+    {
+        C4_CHECK(t.m_free_tail == t.m_free_head);
+        return;
+    }
+
+    C4_CHECK(t.m_free_head >= 0 && t.m_free_head < t.m_cap);
+    C4_CHECK(t.m_free_tail >= 0 && t.m_free_tail < t.m_cap);
+
+    auto const& head = *t._p(t.m_free_head);
+    //auto const& tail = *t._p(t.m_free_tail);
+
+    //C4_CHECK(head.m_prev_sibling == NONE);
+    //C4_CHECK(tail.m_next_sibling == NONE);
+
+    size_t count = 0;
+    for(size_t i = t.m_free_head, prev = NONE; i != NONE; i = t._p(i)->m_next_sibling)
+    {
+        auto const& elm = *t._p(i);
+        if(&elm != &head)
+        {
+            C4_CHECK(elm.m_prev_sibling == prev);
+        }
+        prev = i;
+        ++count;
+    }
+    C4_CHECK(count == t.slack());
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void check_arena(Tree const& t)
+{
+    C4_CHECK(t.m_arena.len == 0 || (t.m_arena_pos >= 0 && t.m_arena_pos <= t.m_arena.len));
+    C4_CHECK(t.arena_size() == t.m_arena_pos);
+    C4_CHECK(t.arena_slack() + t.m_arena_pos == t.m_arena.len);
+}
+
+
+} /* namespace yml */
+} /* namespace c4 */
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+#endif /* C4_YML_DETAIL_CHECKS_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/detail/checks.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/detail/print.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/detail/print.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_YML_DETAIL_PRINT_HPP_
+#define C4_YML_DETAIL_PRINT_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+
+
+namespace c4 {
+namespace yml {
+
+
+inline size_t print_node(Tree const& p, size_t node, int level, size_t count, bool print_children)
+{
+    printf("[%zd]%*s[%zd] %p", count, (2*level), "", node, (void*)p.get(node));
+    if(p.is_root(node))
+    {
+        printf(" [ROOT]");
+    }
+    printf(" %s:", p.type_str(node));
+    if(p.has_key(node))
+    {
+        if(p.has_key_anchor(node))
+        {
+            csubstr ka = p.key_anchor(node);
+            printf(" &%.*s", (int)ka.len, ka.str);
+        }
+        if(p.has_key_tag(node))
+        {
+            csubstr kt = p.key_tag(node);
+            csubstr k  = p.key(node);
+            printf(" %.*s '%.*s'", (int)kt.len, kt.str, (int)k.len, k.str);
+        }
+        else
+        {
+            csubstr k  = p.key(node);
+            printf(" '%.*s'", (int)k.len, k.str);
+        }
+    }
+    else
+    {
+        RYML_ASSERT( ! p.has_key_tag(node));
+    }
+    if(p.has_val(node))
+    {
+        if(p.has_val_tag(node))
+        {
+            csubstr vt = p.val_tag(node);
+            csubstr v  = p.val(node);
+            printf(" %.*s '%.*s'", (int)vt.len, vt.str, (int)v.len, v.str);
+        }
+        else
+        {
+            csubstr v  = p.val(node);
+            printf(" '%.*s'", (int)v.len, v.str);
+        }
+    }
+    else
+    {
+        if(p.has_val_tag(node))
+        {
+            csubstr vt = p.val_tag(node);
+            printf(" %.*s", (int)vt.len, vt.str);
+        }
+    }
+    if(p.has_val_anchor(node))
+    {
+        auto &a = p.val_anchor(node);
+        printf(" valanchor='&%.*s'", (int)a.len, a.str);
+    }
+    printf(" (%zd sibs)", p.num_siblings(node));
+
+    ++count;
+
+    if(p.is_container(node))
+    {
+        printf(" %zd children:\n", p.num_children(node));
+        if(print_children)
+        {
+            for(size_t i = p.first_child(node); i != NONE; i = p.next_sibling(i))
+            {
+                count = print_node(p, i, level+1, count, print_children);
+            }
+        }
+    }
+    else
+    {
+        printf("\n");
+    }
+
+    return count;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void print_node(NodeRef const& p, int level=0)
+{
+    print_node(*p.tree(), p.id(), level, 0, true);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline size_t print_tree(Tree const& p, size_t node=NONE)
+{
+    printf("--------------------------------------\n");
+    size_t ret = 0;
+    if(!p.empty())
+    {
+        if(node == NONE)
+            node = p.root_id();
+        ret = print_node(p, node, 0, 0, true);
+    }
+    printf("#nodes=%zd vs #printed=%zd\n", p.size(), ret);
+    printf("--------------------------------------\n");
+    return ret;
+}
+
+
+} /* namespace yml */
+} /* namespace c4 */
+
+
+#endif /* C4_YML_DETAIL_PRINT_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/detail/print.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/yml.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/yml.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_YML_HPP_
+#define _C4_YML_YML_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tree.hpp
+//#include "c4/yml/tree.hpp"
+#if !defined(C4_YML_TREE_HPP_) && !defined(_C4_YML_TREE_HPP_)
+#error "amalgamate: file c4/yml/tree.hpp must have been included at this point"
+#endif /* C4_YML_TREE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node.hpp
+//#include "c4/yml/node.hpp"
+#if !defined(C4_YML_NODE_HPP_) && !defined(_C4_YML_NODE_HPP_)
+#error "amalgamate: file c4/yml/node.hpp must have been included at this point"
+#endif /* C4_YML_NODE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.hpp
+//#include "c4/yml/emit.hpp"
+#if !defined(C4_YML_EMIT_HPP_) && !defined(_C4_YML_EMIT_HPP_)
+#error "amalgamate: file c4/yml/emit.hpp must have been included at this point"
+#endif /* C4_YML_EMIT_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse.hpp
+//#include "c4/yml/parse.hpp"
+#if !defined(C4_YML_PARSE_HPP_) && !defined(_C4_YML_PARSE_HPP_)
+#error "amalgamate: file c4/yml/parse.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.hpp
+//#include "c4/yml/preprocess.hpp"
+#if !defined(C4_YML_PREPROCESS_HPP_) && !defined(_C4_YML_PREPROCESS_HPP_)
+#error "amalgamate: file c4/yml/preprocess.hpp must have been included at this point"
+#endif /* C4_YML_PREPROCESS_HPP_ */
+
+
+#endif // _C4_YML_YML_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/yml.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/ryml.hpp
+// https://github.com/biojppm/rapidyaml/src/ryml.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _RYML_HPP_
+#define _RYML_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/yml.hpp
+//#include "c4/yml/yml.hpp"
+#if !defined(C4_YML_YML_HPP_) && !defined(_C4_YML_YML_HPP_)
+#error "amalgamate: file c4/yml/yml.hpp must have been included at this point"
+#endif /* C4_YML_YML_HPP_ */
+
+
+namespace ryml {
+using namespace c4::yml;
+using namespace c4;
+}
+
+#endif /* _RYML_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/ryml.hpp)
+
+#endif /* _RYML_SINGLE_HEADER_AMALGAMATED_HPP_ */
+