diff --git a/minijson_reader.hpp b/minijson_reader.hpp
new file mode 100644
index 0000000..b669cb6
--- /dev/null
+++ b/minijson_reader.hpp
@@ -0,0 +1,1227 @@
+#ifndef MINIJSON_READER_H
+#define MINIJSON_READER_H
+
+#include <cstdlib>
+#include <cctype>
+#include <stdint.h>
+#include <climits>
+#include <cstring>
+#include <cerrno>
+
+#include <vector>
+#include <list>
+#include <string>
+#include <utility>
+
+#include <stdexcept>
+#include <istream>
+
+#define MJR_CPP11_SUPPORTED __cplusplus > 199711L || _MSC_VER >= 1800
+
+#if MJR_CPP11_SUPPORTED
+
+#define MJR_FINAL final
+
+#else
+
+#define MJR_FINAL
+
+#endif // MJR_CPP11_SUPPORTED
+
+#ifndef MJR_NESTING_LIMIT
+#define MJR_NESTING_LIMIT 32
+#endif
+
+#define MJR_STRINGIFY(S) MJR_STRINGIFY_HELPER(S)
+#define MJR_STRINGIFY_HELPER(S) #S
+
+namespace minijson
+{
+
+namespace detail
+{
+
+class noncopyable
+{
+private:
+
+    // C++03 idiom to prevent copy construction and copy assignment
+    noncopyable(const noncopyable&);
+    noncopyable& operator=(const noncopyable&);
+
+public:
+
+    noncopyable()
+    {
+    }
+}; // class noncopyable
+
+class context_base : noncopyable
+{
+public:
+
+    enum context_nested_status
+    {
+        NESTED_STATUS_NONE,
+        NESTED_STATUS_OBJECT,
+        NESTED_STATUS_ARRAY
+    };
+
+private:
+
+    context_nested_status m_nested_status;
+    size_t m_nesting_level;
+
+public:
+
+    context_base() :
+        m_nested_status(NESTED_STATUS_NONE),
+        m_nesting_level(0)
+    {
+    }
+
+    char nested_status() const
+    {
+        return m_nested_status;
+    }
+
+    void begin_nested(context_nested_status nested_status)
+    {
+        m_nested_status = nested_status;
+        m_nesting_level++;
+    }
+
+    void reset_nested_status()
+    {
+        m_nested_status = NESTED_STATUS_NONE;
+    }
+
+    void end_nested()
+    {
+        if (m_nesting_level > 0)
+        {
+            m_nesting_level--;
+        }
+    }
+
+    size_t nesting_level() const
+    {
+        return m_nesting_level;
+    }
+}; // class context_base
+
+class buffer_context_base : public context_base
+{
+protected:
+
+    const char* m_read_buffer;
+    char* m_write_buffer;
+    size_t m_length;
+    size_t m_read_offset;
+    size_t m_write_offset;
+    const char* m_current_write_buffer;
+
+    explicit buffer_context_base(const char* read_buffer, char* write_buffer, size_t length) :
+        m_read_buffer(read_buffer),
+        m_write_buffer(write_buffer),
+        m_length(length),
+        m_read_offset(0),
+        m_write_offset(0),
+        m_current_write_buffer(NULL)
+    {
+        new_write_buffer();
+    }
+
+public:
+
+    char read()
+    {
+        if (m_read_offset >= m_length)
+        {
+            return 0;
+        }
+
+        return m_read_buffer[m_read_offset++];
+    }
+
+    size_t read_offset() const
+    {
+        return m_read_offset;
+    }
+
+    void new_write_buffer()
+    {
+        m_current_write_buffer = m_write_buffer + m_write_offset;
+    }
+
+    void write(char c)
+    {
+        if (m_write_offset >= m_read_offset)
+        {
+            throw std::runtime_error("Invalid write call, please file a bug report");
+        }
+
+        m_write_buffer[m_write_offset++] = c;
+    }
+
+    const char* write_buffer() const
+    {
+        return m_current_write_buffer;
+    }
+}; // class buffer_context_base
+
+} // namespace detail
+
+class buffer_context MJR_FINAL : public detail::buffer_context_base
+{
+public:
+
+    explicit buffer_context(char* buffer, size_t length) :
+        detail::buffer_context_base(buffer, buffer, length)
+    {
+    }
+}; // class buffer_context
+
+class const_buffer_context MJR_FINAL : public detail::buffer_context_base
+{
+public:
+
+    explicit const_buffer_context(const char* buffer, size_t length) :
+        detail::buffer_context_base(buffer, new char[length], length) // don't worry about leaks, buffer_context_base can't throw
+    {
+    }
+
+    ~const_buffer_context()
+    {
+        delete[] m_write_buffer;
+    }
+}; // class const_buffer_context
+
+class istream_context MJR_FINAL : public detail::context_base
+{
+private:
+
+    std::istream& m_stream;
+    size_t m_read_offset;
+    std::list<std::vector<char> > m_write_buffers;
+
+public:
+
+    explicit istream_context(std::istream& stream) :
+        m_stream(stream),
+        m_read_offset(0)
+    {
+        new_write_buffer();
+    }
+
+    char read()
+    {
+        const char c = m_stream.get();
+
+        if (m_stream)
+        {
+            m_read_offset++;
+
+            return c;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    size_t read_offset() const
+    {
+        return m_read_offset;
+    }
+
+    void new_write_buffer()
+    {
+        m_write_buffers.push_back(std::vector<char>());
+    }
+
+    void write(char c)
+    {
+        m_write_buffers.back().push_back(c);
+    }
+
+    // This method to retrieve the address of the write buffer MUST be called
+    // AFTER all the calls to write() for the current write buffer have been performed
+    const char* write_buffer() const
+    {
+        return !m_write_buffers.back().empty() ? &m_write_buffers.back()[0] : NULL;
+    }
+}; // class istream_context
+
+class parse_error : public std::exception
+{
+public:
+
+    enum error_reason
+    {
+        UNKNOWN,
+        EXPECTED_OPENING_QUOTE,
+        EXPECTED_UTF16_LOW_SURROGATE,
+        INVALID_ESCAPE_SEQUENCE,
+        INVALID_UTF16_CHARACTER,
+        EXPECTED_CLOSING_QUOTE,
+        INVALID_VALUE,
+        UNTERMINATED_VALUE,
+        EXPECTED_OPENING_BRACKET,
+        EXPECTED_COLON,
+        EXPECTED_COMMA_OR_CLOSING_BRACKET,
+        NESTED_OBJECT_OR_ARRAY_NOT_PARSED,
+        EXCEEDED_NESTING_LIMIT
+    };
+
+private:
+
+    size_t m_offset;
+    error_reason m_reason;
+
+    template<typename Context>
+    static size_t get_offset(const Context& context)
+    {
+        const size_t read_offset = context.read_offset();
+
+        return (read_offset != 0) ? (read_offset - 1) : 0;
+    }
+
+public:
+
+    template<typename Context>
+    explicit parse_error(const Context& context, error_reason reason) :
+        m_offset(get_offset(context)),
+        m_reason(reason)
+    {
+    }
+
+    size_t offset() const
+    {
+        return m_offset;
+    }
+
+    error_reason reason() const
+    {
+        return m_reason;
+    }
+
+    const char* what() const throw()
+    {
+        switch (m_reason)
+        {
+        case UNKNOWN:                           return "Unknown parse error";
+        case EXPECTED_OPENING_QUOTE:            return "Expected opening quote";
+        case EXPECTED_UTF16_LOW_SURROGATE:      return "Expected UTF-16 low surrogate";
+        case INVALID_ESCAPE_SEQUENCE:           return "Invalid escape sequence";
+        case INVALID_UTF16_CHARACTER:           return "Invalid UTF-16 character";
+        case EXPECTED_CLOSING_QUOTE:            return "Expected closing quote";
+        case INVALID_VALUE:                     return "Invalid value";
+        case UNTERMINATED_VALUE:                return "Unterminated value";
+        case EXPECTED_OPENING_BRACKET:          return "Expected opening bracket";
+        case EXPECTED_COLON:                    return "Expected colon";
+        case EXPECTED_COMMA_OR_CLOSING_BRACKET: return "Expected comma or closing bracket";
+        case NESTED_OBJECT_OR_ARRAY_NOT_PARSED: return "Nested object or array not parsed";
+        case EXCEEDED_NESTING_LIMIT:            return "Exceeded nesting limit (" MJR_STRINGIFY(MJR_NESTING_LIMIT) ")";
+        }
+
+        return ""; // to suppress compiler warnings -- LCOV_EXCL_LINE
+    }
+}; // class parse_error
+
+namespace detail
+{
+
+struct utf8_char
+{
+    uint8_t bytes[4];
+
+    utf8_char()
+    {
+        // wanted use value-initialization, but couldn't because of a weird VS2013 warning
+        std::fill_n(bytes, sizeof(bytes), 0);
+    }
+
+    explicit utf8_char(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3)
+    {
+        bytes[0] = b0;
+        bytes[1] = b1;
+        bytes[2] = b2;
+        bytes[3] = b3;
+    }
+
+    uint8_t& operator[](size_t i)
+    {
+        return bytes[i];
+    }
+
+    const uint8_t& operator[](size_t i) const
+    {
+        return bytes[i];
+    }
+
+    bool operator==(const utf8_char& other) const
+    {
+        return std::equal(bytes, bytes + sizeof(bytes), other.bytes);
+    }
+
+    bool operator!=(const utf8_char& other) const
+    {
+        return !operator==(other);
+    }
+}; // struct utf8_char
+
+// this exception is not to be propagated outside minijson
+struct encoding_error
+{
+};
+
+inline uint32_t utf16_to_utf32(uint16_t high, uint16_t low)
+{
+    uint32_t result;
+
+    if (high <= 0xD7FF || high >= 0xE000)
+    {
+        if (low != 0)
+        {
+            // since the high code unit is not a surrogate, the low code unit should be zero
+            throw encoding_error();
+        }
+
+        result = high;
+    }
+    else
+    {
+        if (high > 0xDBFF) // we already know high >= 0xD800
+        {
+            // the high surrogate is not within the expected range
+            throw encoding_error();
+        }
+
+        if (low < 0xDC00 || low > 0xDFFF)
+        {
+            // the low surrogate is not within the expected range
+            throw encoding_error();
+        }
+
+        high -= 0xD800;
+        low -= 0xDC00;
+        result = 0x010000 + ((high << 10) | low);
+    }
+
+    return result;
+}
+
+inline utf8_char utf32_to_utf8(uint32_t utf32_char)
+{
+    utf8_char result;
+
+    if      (utf32_char <= 0x00007F)
+    {
+        result[0] = utf32_char;
+    }
+    else if (utf32_char <= 0x0007FF)
+    {
+        result[0] = 0xC0 | ((utf32_char & (0x1F <<  6)) >>  6);
+        result[1] = 0x80 | ((utf32_char & (0x3F      ))      );
+    }
+    else if (utf32_char <= 0x00FFFF)
+    {
+        result[0] = 0xE0 | ((utf32_char & (0x0F << 12)) >> 12);
+        result[1] = 0x80 | ((utf32_char & (0x3F <<  6)) >>  6);
+        result[2] = 0x80 | ((utf32_char & (0x3F      ))      );
+    }
+    else if (utf32_char <= 0x1FFFFF)
+    {
+        result[0] = 0xF0 | ((utf32_char & (0x07 << 18)) >> 18);
+        result[1] = 0x80 | ((utf32_char & (0x3F << 12)) >> 12);
+        result[2] = 0x80 | ((utf32_char & (0x3F <<  6)) >>  6);
+        result[3] = 0x80 | ((utf32_char & (0x3F      ))      );
+    }
+    else
+    {
+        // invalid code unit
+        throw encoding_error();
+    }
+
+    return result;
+}
+
+inline utf8_char utf16_to_utf8(uint16_t high, uint16_t low)
+{
+    return utf32_to_utf8(utf16_to_utf32(high, low));
+}
+
+// this exception is not to be propagated outside minijson
+struct number_parse_error
+{
+};
+
+inline long parse_long(const char* str, int base = 10)
+{
+    if ((str == NULL) || (*str == 0) || isspace(str[0])) // we don't accept empty strings or strings with leading spaces
+    {
+        throw number_parse_error();
+    }
+
+    int saved_errno = errno; // save errno
+    errno = 0; // reset errno
+
+    char* endptr;
+    const long result = std::strtol(str, &endptr, base);
+
+    std::swap(saved_errno, errno); // restore errno
+
+    if (*endptr != 0) // we didn't consume the whole string
+    {
+        throw number_parse_error();
+    }
+    else if ((saved_errno == ERANGE) && ((result == LONG_MIN) || (result == LONG_MAX))) // overflow
+    {
+        throw number_parse_error();
+    }
+
+    return result;
+}
+
+inline double parse_double(const char* str)
+{
+    if ((str == NULL) || (*str == 0)) // we don't accept empty strings
+    {
+        throw number_parse_error();
+    }
+
+    // we perform this check to reject hex numbers (supported in C++11) and string with leading spaces
+    for (const char* c = str; *c != 0; c++)
+    {
+        if (!(isdigit(*c) || (*c == '+') || (*c == '-') || (*c == '.') || (*c == 'e') || (*c == 'E')))
+        {
+            throw number_parse_error();
+        }
+    }
+
+    int saved_errno = errno; // save errno
+    errno = 0; // reset errno
+
+    char* endptr;
+    const double result = std::strtod(str, &endptr);
+
+    std::swap(saved_errno, errno); // restore errno
+
+    if (*endptr != 0) // we didn't consume the whole string
+    {
+        throw number_parse_error();
+    }
+    else if (saved_errno == ERANGE) // underflow or overflow
+    {
+        throw number_parse_error();
+    }
+
+    return result;
+}
+
+static const size_t UTF16_ESCAPE_SEQ_LENGTH = 4;
+
+inline uint16_t parse_utf16_escape_sequence(const char* seq)
+{
+    for (size_t i = 0; i < UTF16_ESCAPE_SEQ_LENGTH; i++)
+    {
+        if (!isxdigit(seq[i]))
+        {
+            throw encoding_error();
+        }
+    }
+
+    return static_cast<uint16_t>(parse_long(seq, 16));
+}
+
+template<typename Context>
+void write_utf8_char(Context& context, const utf8_char& c)
+{
+    for (size_t i = 0; i < sizeof(c.bytes); i++)
+    {
+        const char byte = c[i];
+        if ((i > 0) && (byte == 0))
+        {
+            break;
+        }
+
+        context.write(byte);
+    }
+}
+
+template<typename Context>
+void read_quoted_string(Context& context, bool skip_opening_quote = false)
+{
+    enum
+    {
+        OPENING_QUOTE,
+        CHARACTER,
+        ESCAPE_SEQUENCE,
+        UTF16_SEQUENCE,
+        CLOSED
+    } state = (skip_opening_quote) ? CHARACTER : OPENING_QUOTE;
+
+    bool empty = true;
+    char utf16_seq[UTF16_ESCAPE_SEQ_LENGTH + 1] = { 0 };
+    size_t utf16_seq_offset = 0;
+    uint16_t high_surrogate = 0;
+
+    char c;
+
+    while ((state != CLOSED) && ((c = context.read()) != 0))
+    {
+        empty = false;
+
+        switch (state)
+        {
+        case OPENING_QUOTE:
+
+            if (c != '"')
+            {
+                throw parse_error(context, parse_error::EXPECTED_OPENING_QUOTE);
+            }
+            state = CHARACTER;
+
+            break;
+
+        case CHARACTER:
+
+            if (c == '\\')
+            {
+                state = ESCAPE_SEQUENCE;
+            }
+            else if (high_surrogate != 0)
+            {
+                throw parse_error(context, parse_error::EXPECTED_UTF16_LOW_SURROGATE);
+            }
+            else if (c == '"')
+            {
+                state = CLOSED;
+            }
+            else
+            {
+                context.write(c);
+            }
+
+            break;
+
+        case ESCAPE_SEQUENCE:
+
+            state = CHARACTER;
+
+            switch (c)
+            {
+            case '"': context.write('"'); break;
+            case '\\': context.write('\\'); break;
+            case '/': context.write('/'); break;
+            case 'b': context.write('\b'); break;
+            case 'f': context.write('\f'); break;
+            case 'n': context.write('\n'); break;
+            case 'r': context.write('\r'); break;
+            case 't': context.write('\t'); break;
+            case 'u': state = UTF16_SEQUENCE; break;
+            default: throw parse_error(context, parse_error::INVALID_ESCAPE_SEQUENCE);
+            }
+
+            break;
+
+        case UTF16_SEQUENCE:
+
+            utf16_seq[utf16_seq_offset++] = c;
+
+            if (utf16_seq_offset == sizeof(utf16_seq) - 1)
+            {
+                try
+                {
+                    const uint16_t code_unit = parse_utf16_escape_sequence(utf16_seq);
+
+                    if (high_surrogate != 0)
+                    {
+                        // we were waiting for the low surrogate (that now is code_unit)
+                        write_utf8_char(context, utf16_to_utf8(high_surrogate, code_unit));
+                        high_surrogate = 0;
+                    }
+                    else if (code_unit >= 0xD800 && code_unit <= 0xDBFF)
+                    {
+                        high_surrogate = code_unit;
+                    }
+                    else
+                    {
+                        write_utf8_char(context, utf16_to_utf8(code_unit, 0));
+                    }
+                }
+                catch (const encoding_error&)
+                {
+                    throw parse_error(context, parse_error::INVALID_UTF16_CHARACTER);
+                }
+
+                utf16_seq_offset = 0;
+
+                state = CHARACTER;
+            }
+
+            break;
+
+        case CLOSED: // to silence compiler warnings
+
+            throw std::runtime_error("This line should never be reached, please file a bug report"); // LCOV_EXCL_LINE
+        }
+    }
+
+    if (empty && !skip_opening_quote)
+    {
+        throw parse_error(context, parse_error::EXPECTED_OPENING_QUOTE);
+    }
+    else if (state != CLOSED)
+    {
+        throw parse_error(context, parse_error::EXPECTED_CLOSING_QUOTE);
+    }
+
+    context.write(0);
+}
+
+// reads any value that is not a string (or an object/array)
+template<typename Context>
+char read_unquoted_value(Context& context, char first_char = 0)
+{
+    if (first_char != 0)
+    {
+        context.write(first_char);
+    }
+
+    char c;
+
+    while (((c = context.read()) != 0) && (c != ',') && (c != '}') && (c != ']') && !isspace(c))
+    {
+        context.write(c);
+    }
+
+    if (c == 0)
+    {
+        throw parse_error(context, parse_error::UNTERMINATED_VALUE);
+    }
+
+    context.write(0);
+
+    return c; // return the termination character (or it will be lost forever)
+}
+
+} // namespace detail
+
+enum value_type
+{
+    String,
+    Number,
+    Boolean,
+    Object,
+    Array,
+    Null
+};
+
+class value MJR_FINAL
+{
+private:
+
+    value_type m_type;
+    const char* m_buffer;
+    long m_long_value;
+    double m_double_value;
+
+public:
+
+    explicit value(value_type type = Null, const char* buffer = "", long long_value = 0, double double_value = 0.0) :
+        m_type(type),
+        m_buffer(buffer),
+        m_long_value(long_value),
+        m_double_value(double_value)
+    {
+    }
+
+    value_type type() const
+    {
+        return m_type;
+    }
+
+    const char* as_string() const
+    {
+        return m_buffer;
+    }
+
+    long as_long() const
+    {
+        return m_long_value;
+    }
+
+    bool as_bool() const
+    {
+        return (m_long_value) ? true : false; // to avoid VS2013 warnings
+    }
+
+    double as_double() const
+    {
+        return m_double_value;
+    }
+}; // class value
+
+namespace detail
+{
+
+template<typename Context>
+value parse_unquoted_value(const Context& context)
+{
+    const char* const buffer = context.write_buffer();
+
+    if (strcmp(buffer, "true") == 0)
+    {
+        return value(Boolean, buffer, 1, 1.0);
+    }
+    else if (strcmp(buffer, "false") == 0)
+    {
+        return value(Boolean, buffer, 0, 0.0);
+    }
+    else if (strcmp(buffer, "null") == 0)
+    {
+        return value(Null, buffer, 0, 0.0);
+    }
+    else
+    {
+        long long_value = 0;
+        double double_value = 0.0;
+
+        try
+        {
+            long_value = parse_long(buffer);
+            double_value = long_value;
+        }
+        catch (const number_parse_error&)
+        {
+            try
+            {
+                double_value = parse_double(buffer);
+            }
+            catch (const number_parse_error&)
+            {
+                throw parse_error(context, parse_error::INVALID_VALUE);
+            }
+        }
+
+        return value(Number, buffer, long_value, double_value);
+    }
+}
+
+template<typename Context>
+std::pair<value, char> read_value(Context& context, char first_char)
+{
+    if (first_char == '{')
+    {
+        return std::make_pair(value(Object), 0);
+    }
+    else if (first_char == '[')
+    {
+        return std::make_pair(value(Array), 0);
+    }
+    else if (first_char == '"') // quoted string
+    {
+        context.new_write_buffer();
+        read_quoted_string(context, true);
+
+        return std::make_pair(value(String, context.write_buffer()), 0);
+    }
+    else // unquoted value
+    {
+        context.new_write_buffer();
+        const char ending_char = read_unquoted_value(context, first_char);
+
+        return std::make_pair(parse_unquoted_value(context), ending_char);
+    }
+}
+
+template<typename Context>
+void parse_init_helper(const Context& context, char& c, bool& must_read)
+{
+    switch (context.nested_status())
+    {
+    case Context::NESTED_STATUS_NONE:
+        c = 0;
+        must_read = true;
+        break;
+    case Context::NESTED_STATUS_OBJECT:
+        c = '{';
+        must_read = false;
+        break;
+    case Context::NESTED_STATUS_ARRAY:
+        c = '[';
+        must_read = false;
+        break;
+    }
+}
+
+template<typename Context>
+value parse_value_helper(Context& context, char& c, bool& must_read)
+{
+    const std::pair<value, char> read_value_result = detail::read_value(context, c);
+    const value v = read_value_result.first;
+
+    if (v.type() == Object)
+    {
+        context.begin_nested(Context::NESTED_STATUS_OBJECT);
+    }
+    else if (v.type() == Array)
+    {
+        context.begin_nested(Context::NESTED_STATUS_ARRAY);
+    }
+    else if (v.type() != String)
+    {
+        c = read_value_result.second;
+        must_read = false;
+    }
+
+    return v;
+}
+
+} // namespace detail
+
+template<typename Context, typename Handler>
+void parse_object(Context& context, Handler handler)
+{
+    const size_t nesting_level = context.nesting_level();
+    if (nesting_level > MJR_NESTING_LIMIT)
+    {
+        throw parse_error(context, parse_error::EXCEEDED_NESTING_LIMIT);
+    }
+
+    char c = 0;
+    bool must_read = false;
+
+    parse_init_helper(context, c, must_read);
+    context.reset_nested_status();
+
+    enum
+    {
+        OPENING_BRACKET,
+        FIELD_NAME_OR_CLOSING_BRACKET, // in case the object is empty
+        FIELD_NAME,
+        COLON,
+        FIELD_VALUE,
+        COMMA_OR_CLOSING_BRACKET,
+        END
+    } state = OPENING_BRACKET;
+
+    const char* field_name = "";
+
+    while (state != END)
+    {
+        if (context.nesting_level() != nesting_level)
+        {
+            throw parse_error(context, parse_error::NESTED_OBJECT_OR_ARRAY_NOT_PARSED);
+        }
+
+        if (must_read)
+        {
+            c = context.read();
+        }
+
+        must_read = true;
+
+        if (isspace(c)) // skip whitespace
+        {
+            continue;
+        }
+
+        switch (state)
+        {
+        case OPENING_BRACKET:
+            if (c != '{')
+            {
+                throw parse_error(context, parse_error::EXPECTED_OPENING_BRACKET);
+            }
+            state = FIELD_NAME_OR_CLOSING_BRACKET;
+            break;
+
+        case FIELD_NAME_OR_CLOSING_BRACKET:
+            if (c == '}')
+            {
+                state = END;
+                break;
+            }
+            // intentional fall-through
+
+        case FIELD_NAME:
+            if (c != '"')
+            {
+                throw parse_error(context, parse_error::EXPECTED_OPENING_QUOTE);
+            }
+            context.new_write_buffer();
+            detail::read_quoted_string(context, true);
+            field_name = context.write_buffer();
+            state = COLON;
+            break;
+
+        case COLON:
+            if (c != ':')
+            {
+                throw parse_error(context, parse_error::EXPECTED_COLON);
+            }
+            state = FIELD_VALUE;
+            break;
+
+        case FIELD_VALUE:
+            handler(field_name, parse_value_helper(context, c, must_read));
+            state = COMMA_OR_CLOSING_BRACKET;
+            break;
+
+        case COMMA_OR_CLOSING_BRACKET:
+            if (c == ',')
+            {
+                state = FIELD_NAME;
+            }
+            else if (c == '}')
+            {
+                state = END;
+            }
+            else
+            {
+                throw parse_error(context, parse_error::EXPECTED_COMMA_OR_CLOSING_BRACKET);
+            }
+            break;
+
+        case END:
+
+            throw std::runtime_error("This line should never be reached, please file a bug report"); // LCOV_EXCL_LINE
+        }
+
+        if (c == 0)
+        {
+            throw std::runtime_error("This line should never be reached, please file a bug report"); // LCOV_EXCL_LINE
+        }
+    }
+
+    context.end_nested();
+}
+
+template<typename Context, typename Handler>
+void parse_array(Context& context, Handler handler)
+{
+    const size_t nesting_level = context.nesting_level();
+    if (nesting_level > MJR_NESTING_LIMIT)
+    {
+        throw parse_error(context, parse_error::EXCEEDED_NESTING_LIMIT);
+    }
+
+    char c = 0;
+    bool must_read = false;
+
+    parse_init_helper(context, c, must_read);
+    context.reset_nested_status();
+
+    enum
+    {
+        OPENING_BRACKET,
+        VALUE_OR_CLOSING_BRACKET, // in case the array is empty
+        VALUE,
+        COMMA_OR_CLOSING_BRACKET,
+        END
+    } state = OPENING_BRACKET;
+
+    while (state != END)
+    {
+        if (context.nesting_level() != nesting_level)
+        {
+            throw parse_error(context, parse_error::NESTED_OBJECT_OR_ARRAY_NOT_PARSED);
+        }
+
+        if (must_read)
+        {
+            c = context.read();
+        }
+
+        must_read = true;
+
+        if (isspace(c)) // skip whitespace
+        {
+            continue;
+        }
+
+        switch (state)
+        {
+        case OPENING_BRACKET:
+            if (c != '[')
+            {
+                throw parse_error(context, parse_error::EXPECTED_OPENING_BRACKET);
+            }
+            state = VALUE_OR_CLOSING_BRACKET;
+            break;
+
+        case VALUE_OR_CLOSING_BRACKET:
+            if (c == ']')
+            {
+                state = END;
+                break;
+            }
+            // intentional fall-through
+
+        case VALUE:
+            handler(parse_value_helper(context, c, must_read));
+            state = COMMA_OR_CLOSING_BRACKET;
+            break;
+
+        case COMMA_OR_CLOSING_BRACKET:
+            if (c == ',')
+            {
+                state = VALUE;
+            }
+            else if (c == ']')
+            {
+                state = END;
+            }
+            else
+            {
+                throw parse_error(context, parse_error::EXPECTED_COMMA_OR_CLOSING_BRACKET);
+            }
+            break;
+
+        case END:
+
+            throw std::runtime_error("This line should never be reached, please file a bug report"); // LCOV_EXCL_LINE
+        }
+
+        if (c == 0)
+        {
+            throw std::runtime_error("This line should never be reached, please file a bug report"); // LCOV_EXCL_LINE
+        }
+    }
+
+    context.end_nested();
+}
+
+namespace detail
+{
+
+class dispatch_rule; // forward declaration
+
+} // namespace detail
+
+class dispatch : detail::noncopyable
+{
+    friend class detail::dispatch_rule;
+
+private:
+
+    const char* m_field_name;
+    bool m_handled;
+
+public:
+
+    explicit dispatch(const char* field_name) :
+        m_field_name(field_name),
+        m_handled(false)
+    {
+    }
+
+    explicit dispatch(const std::string& field_name) :
+        m_field_name(field_name.c_str()),
+        m_handled(false)
+    {
+    }
+
+    detail::dispatch_rule operator<<(const char* field_name);
+    detail::dispatch_rule operator<<(const std::string& field_name);
+}; // class dispatch
+
+namespace detail
+{
+
+class dispatch_rule
+{
+private:
+
+    dispatch& m_dispatch;
+    const char* m_field_name;
+
+public:
+
+    explicit dispatch_rule(dispatch& parent_dispatch, const char* field_name) :
+        m_dispatch(parent_dispatch),
+        m_field_name(field_name)
+    {
+    }
+
+    template<typename Handler>
+    dispatch& operator>>(Handler handler) const
+    {
+        if (!m_dispatch.m_handled && ((m_field_name == NULL) || (strcmp(m_dispatch.m_field_name, m_field_name) == 0)))
+        {
+            handler();
+            m_dispatch.m_handled = true;
+        }
+
+        return m_dispatch;
+    }
+}; // class dispatch_rule
+
+template<typename Context>
+class ignore
+{
+    Context& m_context;
+
+public:
+
+    explicit ignore(Context& context) :
+        m_context(context)
+    {
+    }
+
+    void operator()(const char*, value)
+    {
+        operator()();
+    }
+
+    void operator()(value)
+    {
+        operator()();
+    }
+
+    void operator()() const
+    {
+        switch (m_context.nested_status())
+        {
+        case Context::NESTED_STATUS_NONE:
+            break;
+        case Context::NESTED_STATUS_OBJECT:
+            parse_object(m_context, *this);
+            break;
+        case Context::NESTED_STATUS_ARRAY:
+            parse_array(m_context, *this);
+            break;
+        }
+    }
+}; // class ignore
+
+} // namespace detail
+
+inline detail::dispatch_rule dispatch::operator<<(const char* field_name)
+{
+    return detail::dispatch_rule(*this, field_name);
+}
+
+inline detail::dispatch_rule dispatch::operator<<(const std::string& field_name)
+{
+    return operator<<(field_name.c_str());
+}
+
+static const char* const any = NULL;
+
+template<typename Context>
+void ignore(Context& context)
+{
+    detail::ignore<Context> ignore(context);
+    ignore();
+}
+
+} // namespace minijson
+
+#endif // MINIJSON_READER_H
+
+#undef MJR_STRINGIFY
+#undef MJR_STRINGIFY_HELPER
diff --git a/minijson_writer.hpp b/minijson_writer.hpp
new file mode 100644
index 0000000..eb14b78
--- /dev/null
+++ b/minijson_writer.hpp
@@ -0,0 +1,891 @@
+#ifndef MINIJSON_WRITER_H
+#define MINIJSON_WRITER_H
+
+#include <cstddef>
+#include <iomanip>
+#include <iterator>
+#include <locale>
+#include <ostream>
+#include <string>
+#include <utility>
+
+#define MJW_CPP11_SUPPORTED __cplusplus > 199711L || _MSC_VER >= 1800
+
+#if MJW_CPP11_SUPPORTED
+
+#include <cmath>
+#include <type_traits>
+#define MJW_LIB_NS std
+#define MJW_ISFINITE(X) std::isfinite(X)
+#define MJW_STATIC_ASSERT(COND, MESSAGE) static_assert(COND, MESSAGE)
+
+#else
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#define MJW_LIB_NS boost
+#define MJW_ISFINITE(X) boost::math::isfinite(X)
+#define MJW_STATIC_ASSERT(COND, MESSAGE) BOOST_STATIC_ASSERT(COND)
+
+#endif
+
+namespace minijson
+{
+
+enum null_t
+{
+    null = 0
+};
+
+class writer_configuration
+{
+private:
+
+    size_t m_nesting_level;
+    bool m_pretty_printing;
+    size_t m_indent_spaces;
+    bool m_use_tabs;
+    bool m_horizontal_array;
+    bool m_close_on_destroy;
+
+public:
+
+    explicit writer_configuration() :
+        m_nesting_level(0),
+        m_pretty_printing(false),
+        m_indent_spaces(4),
+        m_use_tabs(false),
+        m_horizontal_array(false),
+        m_close_on_destroy(true)
+    {
+    }
+
+    size_t nesting_level() const
+    {
+        return m_nesting_level;
+    }
+
+    writer_configuration increase_nesting_level() const
+    {
+        writer_configuration result = *this;
+        result.m_nesting_level++;
+
+        return result;
+    }
+
+    bool pretty_printing() const
+    {
+        return m_pretty_printing;
+    }
+
+    writer_configuration pretty_printing(bool value) const
+    {
+        writer_configuration result = *this;
+        result.m_pretty_printing = value;
+
+        return result;
+    }
+
+    size_t indent_spaces() const
+    {
+        return m_indent_spaces;
+    }
+
+    writer_configuration indent_spaces(size_t value) const
+    {
+        writer_configuration result = *this;
+        result.m_indent_spaces = value;
+
+        return result;
+    }
+
+    bool use_tabs() const
+    {
+        return m_use_tabs;
+    }
+
+    writer_configuration use_tabs(bool value) const
+    {
+        writer_configuration result = *this;
+        result.m_use_tabs = value;
+
+        return result;
+    }
+
+    bool horizontal_array() const
+    {
+        return m_horizontal_array;
+    }
+
+    writer_configuration horizontal_array(bool value) const
+    {
+        writer_configuration result = *this;
+        result.m_horizontal_array = value;
+
+        return result;
+    }
+
+    writer_configuration& horizontal_array_inplace(bool value)
+    {
+        m_horizontal_array = value;
+        return *this;
+    }
+
+    bool close_on_destroy() const
+    {
+        return m_close_on_destroy;
+    }
+
+    writer_configuration& close_on_destroy_inplace(bool value)
+    {
+        m_close_on_destroy = value;
+        return *this;
+    }
+};
+
+template<typename V, typename Enable = void>
+struct default_value_writer;
+
+template<typename InputIt>
+void write_array(
+        std::ostream& stream,
+        InputIt begin, InputIt end,
+        const writer_configuration& configuration = writer_configuration());
+
+template<typename InputIt, typename ValueWriter>
+void write_array(
+        std::ostream& stream,
+        InputIt begin, InputIt end,
+        const ValueWriter& value_writer,
+        const writer_configuration& configuration = writer_configuration());
+
+namespace detail
+{
+
+template<bool>
+struct enable_if;
+
+template<>
+struct enable_if<true>
+{
+    typedef void type;
+};
+
+template<typename InputIt>
+struct get_value_type
+{
+    typedef typename MJW_LIB_NS::remove_cv<typename std::iterator_traits<InputIt>::value_type>::type type;
+};
+
+#if MJW_CPP11_SUPPORTED
+
+template<size_t Rank>
+struct overload_rank : overload_rank<Rank - 1>
+{
+};
+
+template<>
+struct overload_rank<0>
+{
+};
+
+typedef overload_rank<63> call_ranked;
+
+template<typename Functor>
+struct two_or_three_args_functor
+{
+private:
+
+    Functor functor;
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    auto operator_impl(Arg1&& arg1, Arg2&& arg2, Arg3&& arg3, overload_rank<1>)
+        -> decltype(functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3)))
+    {
+        functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3));
+    }
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    auto operator_impl(Arg1&& arg1, Arg2&& arg2, Arg3&&, overload_rank<0>)
+        -> decltype(functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)))
+    {
+        functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2));
+    }
+
+public:
+
+    explicit two_or_three_args_functor(Functor functor) :
+        functor(std::move(functor))
+    {
+    }
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    void operator()(Arg1&& arg1, Arg2&& arg2, Arg3&& arg3)
+    {
+        operator_impl(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3), call_ranked());
+    }
+};
+
+#else
+
+template<typename Functor>
+struct two_or_three_args_functor : Functor
+{
+    mutable Functor functor;
+
+    explicit two_or_three_args_functor(const Functor& functor) :
+        Functor(functor),
+        functor(functor)
+    {
+    }
+
+    using Functor::operator();
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    void operator()(Arg1& arg1, Arg2& arg2, Arg3&) const
+    {
+        functor(arg1, arg2);
+    }
+};
+
+template<typename R, typename X1, typename X2>
+struct two_or_three_args_functor<R (*)(X1, X2)>
+{
+    typedef R (*Function)(X1, X2);
+
+    Function function;
+
+    explicit two_or_three_args_functor(Function function) :
+        function(function)
+    {
+    }
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    void operator()(Arg1& arg1, Arg2& arg2, Arg3&) const
+    {
+        function(arg1, arg2);
+    }
+};
+
+template<typename R, typename X1, typename X2, typename X3>
+struct two_or_three_args_functor<R (*)(X1, X2, X3)>
+{
+    typedef R (*Function)(X1, X2, X3);
+
+    Function function;
+
+    explicit two_or_three_args_functor(Function function) :
+        function(function)
+    {
+    }
+
+    template<typename Arg1, typename Arg2, typename Arg3>
+    void operator()(Arg1& arg1, Arg2& arg2, Arg3& arg3) const
+    {
+        function(arg1, arg2, arg3);
+    }
+};
+
+#endif
+
+template<typename Functor>
+two_or_three_args_functor<Functor> wrap_two_or_three_args_functor(Functor functor)
+{
+    return two_or_three_args_functor<Functor>(functor);
+}
+
+template<size_t Size = 128>
+class buffered_writer
+{
+    MJW_STATIC_ASSERT(Size != 0, "Illegal instantiation of buffered_writer");
+
+private:
+
+    std::ostream& m_stream;
+    char m_buffer[Size];
+    size_t m_offset;
+
+    buffered_writer(const buffered_writer &);
+    buffered_writer &operator=(const buffered_writer &);
+
+public:
+
+    explicit buffered_writer(std::ostream& stream) :
+        m_stream(stream),
+        m_offset(0)
+    {
+    }
+
+    buffered_writer& operator<<(char c)
+    {
+        if (m_offset == Size)
+        {
+            flush();
+        }
+
+        m_buffer[m_offset++] = c;
+
+        return *this;
+    }
+
+    template<size_t N>
+    buffered_writer& operator<<(const char (&str)[N])
+    {
+        MJW_STATIC_ASSERT(N != 0, "Illegal instantiation of buffered_writer::operator<<(const char (&str)[N])");
+
+        for (size_t i = 0; i < N - 1; i++)
+        {
+            operator<<(str[i]);
+        }
+
+        return *this;
+    }
+
+    void flush()
+    {
+        m_stream.write(m_buffer, m_offset);
+
+        m_offset = 0;
+    }
+};
+
+namespace
+{
+
+void adjust_stream_settings(std::ostream& stream)
+{
+    stream.imbue(std::locale::classic());
+    stream << std::resetiosflags(std::ios::showpoint | std::ios::showpos);
+    stream << std::dec << std::setw(0);
+}
+
+void write_quoted_string(std::ostream& stream, const char* str)
+{
+    stream << std::hex << std::right << std::setfill('0');
+
+    buffered_writer<> writer(stream);
+
+    writer << '"';
+
+    while (*str != '\0')
+    {
+        switch (*str)
+        {
+        case '"':
+            writer << "\\\"";
+            break;
+
+        case '\\':
+            writer << "\\\\";
+            break;
+
+        case '\n':
+            writer << "\\n";
+            break;
+
+        case '\r':
+            writer << "\\r";
+            break;
+
+        case '\t':
+            writer << "\\t";
+            break;
+
+        default:
+            if ((*str > 0 && *str < 32) || *str == 127) // ASCII control characters (NUL is not supported)
+            {
+                writer << "\\u";
+
+                writer.flush();
+                stream << std::setw(4) << static_cast<unsigned>(*str);
+            }
+            else
+            {
+                writer << *str;
+            }
+            break;
+        }
+        str++;
+    }
+
+    writer << '"';
+
+    writer.flush();
+
+    stream << std::dec;
+}
+
+} // unnamed namespace
+
+template<typename InputIt>
+struct range
+{
+    InputIt begin;
+    InputIt end;
+};
+
+template<typename InputIt>
+range<InputIt> make_range(InputIt begin, InputIt end)
+{
+    const range<InputIt> range = { begin, end };
+
+    return range;
+}
+
+template<typename InputIt, typename ValueWriter>
+class range_writer
+{
+private:
+
+    ValueWriter m_value_writer;
+
+public:
+
+    explicit range_writer(const ValueWriter& value_writer) :
+        m_value_writer(value_writer)
+    {
+    }
+
+    void operator()(std::ostream& stream, const range<InputIt>& range, const writer_configuration& configuration) const
+    {
+        write_array(stream, range.begin, range.end, m_value_writer, configuration);
+    }
+};
+
+} // namespace detail
+
+class writer
+{
+private:
+
+    enum status
+    {
+        EMPTY,
+        OPEN,
+        CLOSED
+    };
+
+    bool m_array;
+    status m_status;
+    std::ostream* m_stream;
+    writer_configuration m_configuration;
+
+    enum pretty_print_token
+    {
+        BEFORE_ELEMENT,
+        AFTER_COLON,
+        BEFORE_CLOSING_BRACKET
+    };
+
+    void write_pretty_print_token(pretty_print_token token)
+    {
+        if (!m_configuration.pretty_printing())
+        {
+            return;
+        }
+
+        detail::buffered_writer<16> writer(*m_stream);
+
+        if ((token == BEFORE_ELEMENT) || ((token == BEFORE_CLOSING_BRACKET) && (m_status != EMPTY)))
+        {
+            if (!m_configuration.horizontal_array())
+            {
+                const size_t base_depth = (token == BEFORE_ELEMENT) ? 1 : 0;
+                const size_t no_indent_characters = m_configuration.use_tabs() ?
+                        (base_depth + m_configuration.nesting_level()) :
+                        (base_depth + m_configuration.nesting_level()) * m_configuration.indent_spaces();
+
+                writer << '\n';
+
+                for (size_t i = 0; i < no_indent_characters; i++)
+                {
+                    writer << ((m_configuration.use_tabs()) ? '\t' : ' ');
+                }
+            }
+        }
+        else if (token == AFTER_COLON)
+        {
+            writer << ' ';
+        }
+
+        writer.flush();
+    }
+
+    void write_opening_bracket()
+    {
+        if (m_array)
+        {
+            *m_stream << '[';
+        }
+        else
+        {
+            *m_stream << '{';
+        }
+    }
+
+    void write_closing_bracket()
+    {
+        write_pretty_print_token(BEFORE_CLOSING_BRACKET);
+
+        if (m_array)
+        {
+            *m_stream << ']';
+        }
+        else
+        {
+            *m_stream << '}';
+        }
+    }
+
+protected:
+
+    void next_field()
+    {
+        if (m_status == EMPTY)
+        {
+            write_opening_bracket();
+        }
+        else if (m_status == OPEN)
+        {
+            *m_stream << ',';
+        }
+
+        write_pretty_print_token(BEFORE_ELEMENT);
+
+        m_status = OPEN;
+    }
+
+    void write_field_name(const char* name)
+    {
+        detail::write_quoted_string(*m_stream, name);
+
+        *m_stream << ':';
+
+        write_pretty_print_token(AFTER_COLON);
+    }
+
+    template<typename V, typename ValueWriter>
+    void write_helper(const char* field_name, const V& value, const ValueWriter& value_writer)
+    {
+        if (m_status == CLOSED)
+        {
+            return;
+        }
+
+        detail::adjust_stream_settings(*m_stream);
+
+        next_field();
+
+        if (field_name != NULL)
+        {
+            write_field_name(field_name);
+        }
+
+        const writer_configuration nested_object_configuration = m_configuration.increase_nesting_level();
+        detail::wrap_two_or_three_args_functor(value_writer)(*m_stream, value, nested_object_configuration);
+    }
+
+    explicit writer(std::ostream& stream, bool array, const writer_configuration& configuration) :
+        m_array(array),
+        m_status(EMPTY),
+        m_stream(&stream),
+        m_configuration(configuration)
+    {
+    }
+
+public:
+    ~writer()
+    {
+        if (m_configuration.close_on_destroy())
+            close();
+    }
+
+    std::ostream& stream() const
+    {
+        return *m_stream;
+    }
+
+    const writer_configuration& configuration() const
+    {
+        return m_configuration;
+    }
+
+    writer_configuration& configuration()
+    {
+        return m_configuration;
+    }
+
+    void close()
+    {
+        if (m_status == CLOSED)
+        {
+            return;
+        }
+
+        detail::adjust_stream_settings(*m_stream);
+
+        if (m_status == EMPTY)
+        {
+            write_opening_bracket();
+        }
+
+        write_closing_bracket();
+
+        m_status = CLOSED;
+        m_stream->flush();
+    }
+
+};
+
+class object_writer;
+class array_writer;
+
+class object_writer : public writer
+{
+public:
+
+    explicit object_writer(std::ostream& stream, const writer_configuration& configuration = writer_configuration()) :
+        writer(stream, false, configuration)
+    {
+    }
+
+    template<typename V>
+    void write(const char* field_name, const V& value)
+    {
+        write_helper(field_name, value, default_value_writer<V>());
+    }
+
+    template<typename V, typename ValueWriter>
+    void write(const char* field_name, const V& value, const ValueWriter& value_writer)
+    {
+        write_helper(field_name, value, value_writer);
+    }
+
+    template<typename InputIt>
+    void write_array(const char* field_name, InputIt begin, InputIt end)
+    {
+        write_array(field_name, begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>());
+    }
+
+    template<typename InputIt, typename ValueWriter>
+    void write_array(const char* field_name, InputIt begin, InputIt end, ValueWriter value_writer)
+    {
+        write(field_name, detail::make_range(begin, end), detail::range_writer<InputIt, ValueWriter>(value_writer));
+    }
+
+    object_writer nested_object(const char* field_name);
+
+    array_writer nested_array(const char* field_name);
+
+};
+
+class array_writer : public writer
+{
+public:
+
+    explicit array_writer(std::ostream& stream, const writer_configuration& configuration = writer_configuration()) :
+        writer(stream, true, configuration)
+    {
+    }
+
+    template<typename V>
+    void write(const V& value)
+    {
+        write_helper(NULL, value, default_value_writer<V>());
+    }
+
+    template<typename V, typename ValueWriter>
+    void write(const V& value, const ValueWriter& value_writer)
+    {
+        write_helper(NULL, value, value_writer);
+    }
+
+    template<typename InputIt>
+    void write_array(InputIt begin, InputIt end)
+    {
+        write_array(begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>());
+    }
+
+    template<typename InputIt, typename ValueWriter>
+    void write_array(InputIt begin, InputIt end, ValueWriter value_writer)
+    {
+        write(detail::make_range(begin, end), detail::range_writer<InputIt, ValueWriter>(value_writer));
+    }
+
+    object_writer nested_object();
+
+    array_writer nested_array();
+
+};
+
+inline object_writer object_writer::nested_object(const char* field_name)
+{
+    detail::adjust_stream_settings(stream());
+
+    next_field();
+    write_field_name(field_name);
+
+    return object_writer(stream(), configuration().increase_nesting_level());
+}
+
+inline array_writer object_writer::nested_array(const char* field_name)
+{
+    detail::adjust_stream_settings(stream());
+
+    next_field();
+    write_field_name(field_name);
+
+    return array_writer(stream(), configuration().increase_nesting_level());
+}
+
+inline object_writer array_writer::nested_object()
+{
+    detail::adjust_stream_settings(stream());
+
+    next_field();
+
+    return object_writer(stream(), configuration().increase_nesting_level());
+}
+
+inline array_writer array_writer::nested_array()
+{
+    detail::adjust_stream_settings(stream());
+
+    next_field();
+
+    return array_writer(stream(), configuration().increase_nesting_level());
+}
+
+template<>
+struct default_value_writer<null_t>
+{
+    void operator()(std::ostream& stream, null_t) const
+    {
+        stream << "null";
+    }
+};
+
+#if MJW_CPP11_SUPPORTED
+template<>
+struct default_value_writer<std::nullptr_t>
+{
+    void operator()(std::ostream& stream, std::nullptr_t) const
+    {
+        default_value_writer<null_t>()(stream, null);
+    }
+};
+#endif
+
+template<typename IntegralType>
+struct default_value_writer<
+        IntegralType,
+        typename detail::enable_if<MJW_LIB_NS::is_integral<IntegralType>::value && !MJW_LIB_NS::is_same<IntegralType, bool>::value>::type>
+{
+    void operator()(std::ostream& stream, IntegralType value) const
+    {
+        // the unary plus is used here to force chars to be printed as integers
+        stream << +value;
+    }
+};
+
+template<>
+struct default_value_writer<bool>
+{
+    void operator()(std::ostream& stream, bool value) const
+    {
+        if (value)
+        {
+            stream << "true";
+        }
+        else
+        {
+            stream << "false";
+        }
+    }
+};
+
+template<typename FloatingPoint>
+struct default_value_writer<
+        FloatingPoint,
+        typename detail::enable_if<MJW_LIB_NS::is_floating_point<FloatingPoint>::value>::type>
+{
+    void operator()(std::ostream& stream, FloatingPoint value) const
+    {
+        // Numeric values that cannot be represented as sequences of digits
+        // (such as Infinity and NaN) are not permitted in JSON
+        if (!MJW_ISFINITE(value))
+        {
+            default_value_writer<null_t>()(stream, null); // falling back to null
+        }
+        else
+        {
+            stream << value;
+        }
+    }
+};
+
+template<>
+struct default_value_writer<char*>
+{
+    void operator()(std::ostream& stream, const char* str) const
+    {
+        detail::write_quoted_string(stream, str);
+    }
+};
+
+template<>
+struct default_value_writer<const char*> : public default_value_writer<char*>
+{
+};
+
+template<size_t N>
+struct default_value_writer<char[N]> : public default_value_writer<char*>
+{
+};
+
+template<size_t N>
+struct default_value_writer<const char[N]> : public default_value_writer<char*>
+{
+};
+
+template<>
+struct default_value_writer<std::string>
+{
+    void operator()(std::ostream& stream, const std::string& str) const
+    {
+        default_value_writer<char*>()(stream, str.c_str());
+    }
+};
+
+template<typename InputIt>
+void write_array(
+        std::ostream& stream,
+        InputIt begin, InputIt end,
+        const writer_configuration& configuration)
+{
+    write_array(stream, begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>(), configuration);
+}
+
+template<typename InputIt, typename ValueWriter>
+void write_array(
+        std::ostream& stream,
+        InputIt begin, InputIt end,
+        const ValueWriter& value_writer,
+        const writer_configuration& configuration)
+{
+    array_writer writer(stream, configuration);
+
+    for (InputIt it = begin; it != end; ++it)
+    {
+        writer.write(*it, value_writer);
+    }
+
+    writer.close();
+}
+
+} // namespace minijson
+
+#endif // MINIJSON_WRITER_H
diff --git a/ryml_all.hpp b/ryml_all.hpp
new file mode 100644
index 0000000..5bcd4c7
--- /dev/null
+++ b/ryml_all.hpp
@@ -0,0 +1,44298 @@
+#ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
+#define _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. Because the
+//     amalgamated header file is large, to speed up compilation of
+//     your project, protect the include with its include guard
+//     `_RYML_SINGLE_HEADER_AMALGAMATED_HPP_`, ie like this:
+//     ```
+//     #ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
+//     #include <ryml_all.hpp>
+//     #endif
+//     ```
+//
+//   - 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, define the preprocessor symbol
+//     RYML_SHARED before including the header. 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_
+#define _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/version.hpp
+// https://github.com/biojppm/c4core/src/c4/version.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_VERSION_HPP_
+#define _C4_VERSION_HPP_
+
+/** @file version.hpp */
+
+#define C4CORE_VERSION "0.2.6"
+#define C4CORE_VERSION_MAJOR 0
+#define C4CORE_VERSION_MINOR 2
+#define C4CORE_VERSION_PATCH 6
+
+// 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 {
+
+C4CORE_EXPORT const char* version();
+C4CORE_EXPORT int version_major();
+C4CORE_EXPORT int version_minor();
+C4CORE_EXPORT int version_patch();
+
+} // namespace c4
+
+#endif /* _C4_VERSION_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/version.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__) || defined(__linux)
+#   define C4_UNIX
+#   define C4_LINUX
+#elif defined(__unix__) || defined(__unix)
+#   define C4_UNIX
+#elif defined(__arm__) || defined(__aarch64__)
+#   define C4_ARM
+#elif defined(__xtensa__) || defined(__XTENSA__)
+#   define C4_XTENSA
+#elif defined(SWIG)
+#   define C4_SWIG
+#else
+#   error "unknown platform"
+#endif
+
+#if defined(__posix) || defined(C4_UNIX) || defined(C4_LINUX)
+#   define C4_POSIX
+#endif
+
+
+#endif /* _C4_PLATFORM_HPP_ */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/platform.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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 also 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 // NOLINT
+
+
+// NOTE: to find defined macros in a platform,
+// g++ <flags> -dM -E - </dev/null | sort
+
+#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(__ARM_ARCH_8A__)  \
+        || (defined(__ARCH_ARM) && __ARCH_ARM >= 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(__ARM_ARCH_7EM__) \
+        || (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(__ARM_ARCH_6KZ__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6)
+#           define C4_CPU_ARMV6
+#       elif (defined(__ARM_ARCH) && __ARM_ARCH == 5) \
+        || defined(__ARM_ARCH_5TEJ__) \
+        || defined(__ARM_ARCH_5TE__) \
+        || defined(__ARM_ARCH_5T__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
+#           define C4_CPU_ARMV5
+#       elif (defined(__ARM_ARCH) && __ARM_ARCH == 4) \
+        || defined(__ARM_ARCH_4T__) \
+        || defined(__ARM_ARCH_4__) \
+        || (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__)) \
+       || defined(_MSC_VER) // winarm64 does not provide any of the above macros,
+                            // but advises little-endianess:
+                            // https://docs.microsoft.com/en-us/cpp/build/overview-of-arm-abi-conventions?view=msvc-170
+                            // So if it is visual studio compiling, we'll assume 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(__xtensa__) || defined(__XTENSA__)
+#   define C4_CPU_XTENSA
+#   define C4_WORDSIZE 4
+// not sure about this...
+#   if defined(__XTENSA_EL__) || defined(__xtensa_el__)
+#       define C4_BYTE_ORDER _C4EL
+#   else
+#       define C4_BYTE_ORDER _C4EB
+#   endif
+
+#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(__loongarch__)
+#   if defined(__loongarch64)
+#       define C4_CPU_LOONGARCH64
+#       define C4_WORDSIZE 8
+#   else
+#       define C4_CPU_LOONGARCH
+#       define C4_WORDSIZE 4
+#   endif
+#   define C4_BYTE_ORDER _C4EL
+
+#elif defined(__mips__) || defined(_mips) || defined(mips)
+#   if defined(__mips)
+#       if __mips == 64
+#           define C4_CPU_MIPS64
+#           define C4_WORDSIZE 8
+#       elif __mips == 32
+#           define C4_CPU_MIPS32
+#           define C4_WORDSIZE 4
+#       endif
+#   elif defined(__arch64__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 64) || (defined(__LP64__) && __LP64__)
+#       define C4_CPU_MIPS64
+#       define C4_WORDSIZE 8
+#   elif defined(__arch32__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 32) || (defined(__LP32__) && __LP32__)
+#       define C4_CPU_MIPS32
+#       define C4_WORDSIZE 4
+#   else
+#       error "unknown mips architecture"
+#   endif
+#   if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#       define C4_BYTE_ORDER _C4EB
+#   elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#       define C4_BYTE_ORDER _C4EL
+#   else
+#       error "unknown mips endianness"
+#   endif
+
+#elif defined(__sparc__) || defined(__sparc) || defined(sparc)
+#   if defined(__arch64__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 64) || (defined(__LP64__) && __LP64__)
+#       define C4_CPU_SPARC64
+#       define C4_WORDSIZE 8
+#   elif defined(__arch32__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 32) || (defined(__LP32__) && __LP32__)
+#       define C4_CPU_SPARC32
+#       define C4_WORDSIZE 4
+#   else
+#       error "unknown sparc architecture"
+#   endif
+#   define C4_BYTE_ORDER _C4EB
+
+#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)
+
+// (amalgamate) these includes are needed to work around
+// conditional includes in the gcc4.8 shim
+#include <cstdint>
+#include <type_traits>
+#include <cstring>
+
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/gcc-4.8.hpp
+// https://github.com/biojppm/c4core/src/c4/gcc-4.8.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_GCC_4_8_HPP_
+#define _C4_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);
+    }
+}
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ == 8
+typedef long double max_align_t ;
+#endif
+
+}
+#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_GCC_4_8_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/gcc-4.8.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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(__clang__)
+#   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 C4_MSVC_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__)
+#       ifdef __MINGW32__
+#           define C4_MINGW
+#       endif
+#       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)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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
+#   if defined(_MSC_VER) && !defined(__clang__)
+#       if _MSC_VER >= 1910  // >VS2015: VS2017, VS2019, VS2022
+#           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 */
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if _MSC_VER < 1900
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+#  elif _MSC_VER < 2000
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+#  endif
+#else
+#  if __cplusplus < 201103
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+#  elif __cplusplus == 201103
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+#  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
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if (defined(_CPPUNWIND) && (_CPPUNWIND == 1))
+#    define C4_EXCEPTIONS
+#  endif
+#else
+#  if defined(__EXCEPTIONS) || defined(__cpp_exceptions)
+#    define C4_EXCEPTIONS
+#  endif
+#endif
+
+#ifdef C4_EXCEPTIONS
+#  define C4_IF_EXCEPTIONS_(exc_code, setjmp_code) exc_code
+#  define C4_IF_EXCEPTIONS(exc_code, setjmp_code) do { exc_code } while(0)
+#else
+#  define C4_IF_EXCEPTIONS_(exc_code, setjmp_code) setjmp_code
+#  define C4_IF_EXCEPTIONS(exc_code, setjmp_code) do { setjmp_code } while(0)
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if defined(_CPPRTTI)
+#    define C4_RTTI
+#  endif
+#else
+#  if defined(__GXX_RTTI)
+#    define C4_RTTI
+#  endif
+#endif
+
+#ifdef C4_RTTI
+#  define C4_IF_RTTI_(code_rtti, code_no_rtti) code_rtti
+#  define C4_IF_RTTI(code_rtti, code_no_rtti) do { code_rtti } while(0)
+#else
+#  define C4_IF_RTTI_(code_rtti, code_no_rtti) code_no_rtti
+#  define C4_IF_RTTI(code_rtti, code_no_rtti) do { code_no_rtti } while(0)
+#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) && !defined(__clang__)
+#       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
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   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_CONST
+#   define C4_PURE
+#   define C4_FLATTEN
+#   define C4_HOT         /** @todo */
+#   define C4_COLD        /** @todo */
+#   define C4_ASSUME(...) __assume(__VA_ARGS__)
+#   define C4_EXPECT(x, y) x /** @todo */
+#   define C4_LIKELY(x)   x
+#   define C4_UNLIKELY(x) x
+#   define C4_UNREACHABLE() _c4_msvc_unreachable()
+#   define C4_ATTR_FORMAT(...) /** */
+#   define C4_NORETURN [[noreturn]]
+#   if _MSC_VER >= 1700 // VS2012
+#       define C4_NODISCARD _Check_return_
+#   else
+#       define C4_NODISCARD
+#   endif
+[[noreturn]] __forceinline void _c4_msvc_unreachable() { __assume(false); } ///< https://stackoverflow.com/questions/60802864/emulating-gccs-builtin-unreachable-in-visual-studio
+#   define C4_UNREACHABLE_AFTER_ERR() /* */
+#else
+    ///< @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))
+#   define C4_CONST __attribute__((const))
+#   define C4_PURE __attribute__((pure))
+/** 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))
+#   define C4_NODISCARD __attribute__((warn_unused_result))
+#   define C4_UNREACHABLE_AFTER_ERR() C4_UNREACHABLE()
+// C4_ASSUME
+// see https://stackoverflow.com/questions/63493968/reproducing-clangs-builtin-assume-for-gcc
+// preferred option: C++ standard attribute
+#   ifdef __has_cpp_attribute
+#       if __has_cpp_attribute(assume) >= 202207L
+#           define C4_ASSUME(...) [[assume(__VA_ARGS__)]]
+#       endif
+#   endif
+// first fallback: compiler intrinsics/attributes for assumptions
+#   ifndef C4_ASSUME
+#       if defined(__clang__)
+#           define C4_ASSUME(...) __builtin_assume(__VA_ARGS__)
+#       elif defined(__GNUC__)
+#       if __GNUC__ >= 13
+#           define C4_ASSUME(...) __attribute__((__assume__(__VA_ARGS__)))
+#       endif
+#       endif
+#   endif
+// second fallback: possibly evaluating uses of unreachable()
+// Set this to 1 if you want to allow assumptions to possibly evaluate.
+#   ifndef C4_ASSUME_ALLOW_EVAL
+#       define C4_ASSUME_ALLOW_EVAL 0
+#   endif
+#   if !defined(C4_ASSUME) && (C4_ASSUME_ALLOW_EVAL)
+#       define C4_ASSUME(...) do { if (!bool(__VA_ARGS__)) C4_UNREACHABLE(); ) while(0)
+#   endif
+// last fallback: define macro as doing nothing
+#   ifndef C4_ASSUME
+#       define C4_ASSUME(...)
+#   endif
+#endif
+
+
+#if C4_CPP >= 14
+#   define C4_DEPRECATED(msg) [[deprecated(msg)]]
+#else
+#   if defined(_MSC_VER)
+#       define C4_DEPRECATED(msg) __declspec(deprecated(msg))
+#   else // defined(__GNUC__) || defined(__clang__)
+#       define C4_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#   endif
+#endif
+
+
+#ifdef _MSC_VER
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __FUNCSIG__
+#else /// @todo assuming gcc-like compiler. check it is actually so.
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __PRETTY_FUNCTION__
+#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"); } // NOLINT
+#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 */
+#if defined(_MSC_VER) && !defined(__clang__)
+#   define C4_KEEP_EMPTY_LOOP { char c; C4_DONT_OPTIMIZE(c); }
+#else
+#   define C4_KEEP_EMPTY_LOOP { asm(""); }
+#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 */
+
+// NOLINTBEGIN(bugprone-macro-parentheses)
+
+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
+
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic push
+#if __GNUC__ >= 6
+#pragma GCC diagnostic ignored "-Wunused-const-variable"
+#endif
+#endif
+
+/** 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{};
+
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+
+//--------------------------------------------------
+
+/** 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 // NOLINT
+{
+    template<class... T> EmptyStruct(T && ...){} // NOLINT
+};
+
+/** Just what its name says. Useful sometimes as a default policy class to
+ * be inherited from. */
+struct EmptyStructVirtual // NOLINT
+{
+    virtual ~EmptyStructVirtual() = default;
+    template<class... T> EmptyStructVirtual(T && ...){} // NOLINT
+};
+
+
+/** */
+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(std::forward<T>(val)) {} // NOLINT
+    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(std::forward<T>(val)) {} // NOLINT
+};
+
+/** 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
+
+// NOLINTEND(bugprone-macro-parentheses)
+
+#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_BUILTIN_TRAP      2
+#define DEBUG_BREAK_USE_SIGTRAP           3
+#define DEBUG_BREAK_USE_BUILTIN_DEBUGTRAP 4
+
+#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_BUILTIN_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_BUILTIN_DEBUGTRAP
+__attribute__((always_inline))
+__inline__ static void debug_break(void)
+{
+	__builtin_debugtrap();
+}
+#elif DEBUG_BREAK_IMPL == DEBUG_BREAK_USE_BUILTIN_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_
+
+
+#if defined(NDEBUG) || defined(C4_NO_DEBUG_BREAK)
+#   define C4_DEBUG_BREAK()
+#else
+#   ifdef __clang__
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wundef"
+#       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__)
+#       pragma GCC diagnostic push
+#       pragma GCC diagnostic ignored "-Wundef"
+#   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__)
+#       pragma GCC diagnostic pop
+#   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 = 0x01u << 0u,
+    /** when an error happens log a message. */
+    ON_ERROR_LOG = 0x01u << 1u,
+    /** when an error happens invoke a callback if it was set with
+     * set_error_callback(). */
+    ON_ERROR_CALLBACK = 0x01u << 2u,
+    /** when an error happens call std::terminate(). */
+    ON_ERROR_ABORT = 0x01u << 3u,
+    /** when an error happens and exceptions are enabled throw an exception.
+     * Without effect otherwise. */
+    ON_ERROR_THROW = 0x01u << 4u,
+    /** 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 // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    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;
+
+// watchout: for VS the [[noreturn]] needs to come before other annotations like C4CORE_EXPORT
+[[noreturn]] 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/
+
+// TODO: add C4_MESSAGE() https://stackoverflow.com/questions/18252351/custom-preprocessor-macro-for-a-conditional-pragma-message-xxx?rq=1
+
+
+#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))
+#else // C4_MSVC
+#define C4_SUPPRESS_WARNING_MSVC_PUSH
+#define C4_SUPPRESS_WARNING_MSVC(w)
+#define C4_SUPPRESS_WARNING_MSVC_POP
+#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")
+#else // C4_CLANG
+#define C4_SUPPRESS_WARNING_CLANG_PUSH
+#define C4_SUPPRESS_WARNING_CLANG(w)
+#define C4_SUPPRESS_WARNING_CLANG_POP
+#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")
+#else // C4_GCC
+#define C4_SUPPRESS_WARNING_GCC_PUSH
+#define C4_SUPPRESS_WARNING_GCC(w)
+#define C4_SUPPRESS_WARNING_GCC_POP
+#endif // C4_GCC
+
+
+#define C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(w)   \
+    C4_SUPPRESS_WARNING_MSVC_PUSH               \
+    C4_SUPPRESS_WARNING_MSVC(w)
+
+#define C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)  \
+    C4_SUPPRESS_WARNING_CLANG_PUSH              \
+    C4_SUPPRESS_WARNING_CLANG(w)
+
+#define C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)    \
+    C4_SUPPRESS_WARNING_GCC_PUSH                \
+    C4_SUPPRESS_WARNING_GCC(w)
+
+
+#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_ */
+
+// 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/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/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_ */
+
+#ifdef C4_MSVC
+#include <intrin.h>
+#endif
+//included above:
+//#include <string.h>
+
+#if (defined(__GNUC__) && __GNUC__ >= 10) || defined(__has_builtin)
+#define _C4_USE_LSB_INTRINSIC(which) __has_builtin(which)
+#define _C4_USE_MSB_INTRINSIC(which) __has_builtin(which)
+#elif defined(C4_MSVC)
+#define _C4_USE_LSB_INTRINSIC(which) true
+#define _C4_USE_MSB_INTRINSIC(which) true
+#else
+// let's try our luck
+#define _C4_USE_LSB_INTRINSIC(which) true
+#define _C4_USE_MSB_INTRINSIC(which) true
+#endif
+
+
+/** @file memory_util.hpp Some memory utilities. */
+
+// NOLINTBEGIN(google-runtime-int)
+
+namespace c4 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+/** 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));
+}
+
+C4_ALWAYS_INLINE C4_CONST bool mem_overlaps(void const* a, void const* b, size_t sza, size_t szb)
+{
+    // thanks @timwynants
+    return (((const char*)b + szb) > a && b < ((const char*)a+sza));
+}
+
+void mem_repeat(void* dest, void const* pattern, size_t pattern_size, size_t num_times);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class T>
+C4_ALWAYS_INLINE C4_CONST bool is_aligned(T *ptr, uintptr_t alignment=alignof(T))
+{
+    return (uintptr_t(ptr) & (alignment - uintptr_t(1))) == uintptr_t(0);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// least significant bit
+
+/** @name msb Compute the least significant bit
+ * @note the input value must be nonzero
+ * @note the input type must be unsigned
+ */
+/** @{ */
+
+// https://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightLinear
+#define _c4_lsb_fallback                                                \
+    unsigned c = 0;                                                     \
+    v = (v ^ (v - 1)) >> 1; /* Set v's trailing 0s to 1s and zero rest */ \
+    for(; v; ++c)                                                       \
+        v >>= 1;                                                        \
+    return (unsigned) c
+
+// u8
+template<class I>
+C4_CONSTEXPR14
+auto lsb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 1u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_LSB_INTRINSIC(__builtin_ctz)
+        // upcast to use the intrinsic, it's cheaper.
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanForward(&bit, (unsigned long)v);
+                return bit;
+            #else
+                _c4_lsb_fallback;
+            #endif
+        #else
+            return (unsigned)__builtin_ctz((unsigned)v);
+        #endif
+    #else
+        _c4_lsb_fallback;
+    #endif
+}
+
+// u16
+template<class I>
+C4_CONSTEXPR14
+auto lsb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 2u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_LSB_INTRINSIC(__builtin_ctz)
+        // upcast to use the intrinsic, it's cheaper.
+        // Then remember that the upcast makes it to 31bits
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanForward(&bit, (unsigned long)v);
+                return bit;
+            #else
+                _c4_lsb_fallback;
+            #endif
+        #else
+            return (unsigned)__builtin_ctz((unsigned)v);
+        #endif
+    #else
+        _c4_lsb_fallback;
+    #endif
+}
+
+// u32
+template<class I>
+C4_CONSTEXPR14
+auto lsb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 4u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_LSB_INTRINSIC(__builtin_ctz)
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanForward(&bit, v);
+                return bit;
+            #else
+                _c4_lsb_fallback;
+            #endif
+        #else
+            return (unsigned)__builtin_ctz((unsigned)v);
+        #endif
+    #else
+        _c4_lsb_fallback;
+    #endif
+}
+
+// u64 in 64bits
+template<class I>
+C4_CONSTEXPR14
+auto lsb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 8u && sizeof(unsigned long) == 8u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_LSB_INTRINSIC(__builtin_ctzl)
+        #if defined(C4_MSVC)
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanForward64(&bit, v);
+                return bit;
+            #else
+                _c4_lsb_fallback;
+            #endif
+        #else
+            return (unsigned)__builtin_ctzl((unsigned long)v);
+        #endif
+    #else
+        _c4_lsb_fallback;
+    #endif
+}
+
+// u64 in 32bits
+template<class I>
+C4_CONSTEXPR14
+auto lsb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 8u && sizeof(unsigned long long) == 8u && sizeof(unsigned long) != sizeof(unsigned long long), unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_LSB_INTRINSIC(__builtin_ctzll)
+        #if defined(C4_MSVC)
+            #if !defined(C4_CPU_X86) && !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanForward64(&bit, v);
+                return bit;
+            #else
+                _c4_lsb_fallback;
+            #endif
+        #else
+            return (unsigned)__builtin_ctzll((unsigned long long)v);
+        #endif
+    #else
+        _c4_lsb_fallback;
+    #endif
+}
+
+#undef _c4_lsb_fallback
+
+/** @} */
+
+
+namespace detail {
+template<class I, I val, unsigned num_bits, bool finished> struct _lsb11;
+template<class I, I val, unsigned num_bits>
+struct _lsb11<I, val, num_bits, false>
+{
+    enum : unsigned { num = _lsb11<I, (val>>1), num_bits+I(1), (((val>>1)&I(1))!=I(0))>::num };
+};
+template<class I, I val, unsigned num_bits>
+struct _lsb11<I, val, num_bits, true>
+{
+    enum : unsigned { 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 : unsigned { value = detail::_lsb11<I, number, 0, ((number&I(1))!=I(0))>::num};
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// most significant bit
+
+
+/** @name msb Compute the most significant bit
+ * @note the input value must be nonzero
+ * @note the input type must be unsigned
+ */
+/** @{ */
+
+
+#define _c4_msb8_fallback                       \
+    unsigned n = 0;                             \
+    if(v & I(0xf0)) v >>= 4, n |= I(4);         \
+    if(v & I(0x0c)) v >>= 2, n |= I(2);         \
+    if(v & I(0x02)) v >>= 1, n |= I(1);         \
+    return n
+
+#define _c4_msb16_fallback                      \
+    unsigned n = 0;                             \
+    if(v & I(0xff00)) v >>= 8, n |= I(8);       \
+    if(v & I(0x00f0)) v >>= 4, n |= I(4);       \
+    if(v & I(0x000c)) v >>= 2, n |= I(2);       \
+    if(v & I(0x0002)) v >>= 1, n |= I(1);       \
+    return n
+
+#define _c4_msb32_fallback                      \
+    unsigned n = 0;                             \
+    if(v & I(0xffff0000)) v >>= 16, n |= 16;    \
+    if(v & I(0x0000ff00)) v >>= 8, n |= 8;      \
+    if(v & I(0x000000f0)) v >>= 4, n |= 4;      \
+    if(v & I(0x0000000c)) v >>= 2, n |= 2;      \
+    if(v & I(0x00000002)) v >>= 1, n |= 1;      \
+    return n
+
+#define _c4_msb64_fallback                              \
+    unsigned n = 0;                                     \
+    if(v & I(0xffffffff00000000)) v >>= 32, n |= I(32); \
+    if(v & I(0x00000000ffff0000)) v >>= 16, n |= I(16); \
+    if(v & I(0x000000000000ff00)) v >>= 8, n |= I(8);   \
+    if(v & I(0x00000000000000f0)) v >>= 4, n |= I(4);   \
+    if(v & I(0x000000000000000c)) v >>= 2, n |= I(2);   \
+    if(v & I(0x0000000000000002)) v >>= 1, n |= I(1);   \
+    return n
+
+
+// u8
+template<class I>
+C4_CONSTEXPR14
+auto msb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 1u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_MSB_INTRINSIC(__builtin_clz)
+        // upcast to use the intrinsic, it's cheaper.
+        // Then remember that the upcast makes it to 31bits
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanReverse(&bit, (unsigned long)v);
+                return bit;
+            #else
+                _c4_msb8_fallback;
+            #endif
+        #else
+            return 31u - (unsigned)__builtin_clz((unsigned)v);
+        #endif
+    #else
+        _c4_msb8_fallback;
+    #endif
+}
+
+// u16
+template<class I>
+C4_CONSTEXPR14
+auto msb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 2u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_MSB_INTRINSIC(__builtin_clz)
+        // upcast to use the intrinsic, it's cheaper.
+        // Then remember that the upcast makes it to 31bits
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanReverse(&bit, (unsigned long)v);
+                return bit;
+            #else
+                _c4_msb16_fallback;
+            #endif
+        #else
+            return 31u - (unsigned)__builtin_clz((unsigned)v);
+        #endif
+    #else
+        _c4_msb16_fallback;
+    #endif
+}
+
+// u32
+template<class I>
+C4_CONSTEXPR14
+auto msb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 4u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_MSB_INTRINSIC(__builtin_clz)
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanReverse(&bit, v);
+                return bit;
+            #else
+                _c4_msb32_fallback;
+            #endif
+        #else
+            return 31u - (unsigned)__builtin_clz((unsigned)v);
+        #endif
+    #else
+        _c4_msb32_fallback;
+    #endif
+}
+
+// u64 in 64bits
+template<class I>
+C4_CONSTEXPR14
+auto msb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 8u && sizeof(unsigned long) == 8u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_MSB_INTRINSIC(__builtin_clzl)
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanReverse64(&bit, v);
+                return bit;
+            #else
+                _c4_msb64_fallback;
+            #endif
+        #else
+            return 63u - (unsigned)__builtin_clzl((unsigned long)v);
+        #endif
+    #else
+        _c4_msb64_fallback;
+    #endif
+}
+
+// u64 in 32bits
+template<class I>
+C4_CONSTEXPR14
+auto msb(I v) noexcept
+    -> typename std::enable_if<sizeof(I) == 8u && sizeof(unsigned long long) == 8u && sizeof(unsigned long) != sizeof(unsigned long long), unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_unsigned<I>::value);
+    C4_ASSERT(v != 0);
+    #if _C4_USE_MSB_INTRINSIC(__builtin_clzll)
+        #ifdef C4_MSVC
+            #if !defined(C4_CPU_X86) && !defined(C4_CPU_ARM64) && !defined(C4_CPU_ARM)
+                unsigned long bit;
+                _BitScanReverse64(&bit, v);
+                return bit;
+            #else
+                _c4_msb64_fallback;
+            #endif
+        #else
+            return 63u - (unsigned)__builtin_clzll((unsigned long long)v);
+        #endif
+    #else
+        _c4_msb64_fallback;
+    #endif
+}
+
+#undef _c4_msb8_fallback
+#undef _c4_msb16_fallback
+#undef _c4_msb32_fallback
+#undef _c4_msb64_fallback
+
+/** @} */
+
+
+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 : unsigned { 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 : unsigned { num = (unsigned)(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 : unsigned { value = detail::_msb11<I, number, 0, (number==I(0))>::num };
+};
+
+
+
+#undef _C4_USE_LSB_INTRINSIC
+#undef _C4_USE_MSB_INTRINSIC
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// there is an implicit conversion below; it happens when E or B are
+// narrower than int, and thus any operation will upcast the result to
+// int, and then downcast to assign
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wconversion")
+
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(B base, E exponent) noexcept -> typename std::enable_if<std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    if(exponent >= 0)
+    {
+        for(E e = 0; e < exponent; ++e)
+            r *= base;
+    }
+    else
+    {
+        exponent *= E(-1);
+        for(E e = 0; e < exponent; ++e)
+            r /= base;
+    }
+    return r;
+}
+
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, B base, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(E exponent) noexcept -> typename std::enable_if<std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    if(exponent >= 0)
+    {
+        for(E e = 0; e < exponent; ++e)
+            r *= base;
+    }
+    else
+    {
+        exponent *= E(-1);
+        for(E e = 0; e < exponent; ++e)
+            r /= base;
+    }
+    return r;
+}
+
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, class Base, Base base, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(E exponent) noexcept -> typename std::enable_if<std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    B bbase = B(base);
+    if(exponent >= 0)
+    {
+        for(E e = 0; e < exponent; ++e)
+            r *= bbase;
+    }
+    else
+    {
+        exponent *= E(-1);
+        for(E e = 0; e < exponent; ++e)
+            r /= bbase;
+    }
+    return r;
+}
+
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(B base, E exponent) noexcept -> typename std::enable_if<!std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    for(E e = 0; e < exponent; ++e)
+        r *= base;
+    return r;
+}
+
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, B base, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(E exponent) noexcept -> typename std::enable_if<!std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    for(E e = 0; e < exponent; ++e)
+        r *= base;
+    return r;
+}
+/** integer power; this function is constexpr-14 because of the local
+ * variables */
+template<class B, class Base, Base base, class E>
+C4_CONSTEXPR14 C4_CONST auto ipow(E exponent) noexcept -> typename std::enable_if<!std::is_signed<E>::value, B>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<E>::value);
+    B r = B(1);
+    B bbase = B(base);
+    for(E e = 0; e < exponent; ++e)
+        r *= bbase;
+    return r;
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** 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;
+    for(I i = first_bit; i < last_bit; ++i)
+    {
+        r |= (I(1) << 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); } // NOLINT
+    C4_ALWAYS_INLINE C4_CONSTEXPR14 Second const& second() const { return reinterpret_cast<Second const&>(*this); } // NOLINT
+};
+
+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>()>;
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // namespace c4
+
+// NOLINTEND(google-runtime-int)
+
+#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 // NOLINT(*-member-functions)
+{
+    const char *name = nullptr;
+    virtual ~MemoryResource() = default;
+
+    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 // NOLINT(*-member-functions)
+{
+
+    MemoryResourceMalloc() { name = "malloc"; }
+
+protected:
+
+    void* do_allocate(size_t sz, size_t alignment, void *hint) override
+    {
+        C4_UNUSED(hint);
+        return c4::aalloc(sz, alignment);
+    }
+
+    void do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        C4_UNUSED(sz);
+        C4_UNUSED(alignment);
+        c4::afree(ptr);
+    }
+
+    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:
+
+    void* do_allocate(size_t sz, size_t alignment, void* hint) override
+    {
+        return m_local->allocate(sz, alignment, hint);
+    }
+
+    void* do_reallocate(void* ptr, size_t oldsz, size_t newsz, size_t alignment) override
+    {
+        return m_local->reallocate(ptr, oldsz, newsz, alignment);
+    }
+
+    void do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        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); }
+
+    ~_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 // NOLINT(*-member-functions)
+{
+
+    C4_NO_COPY_OR_MOVE(MemoryResourceLinear);
+
+public:
+
+    using detail::_MemoryResourceSingleChunk::_MemoryResourceSingleChunk;
+
+protected:
+
+    void* do_allocate(size_t sz, size_t alignment, void *hint) override;
+    void  do_deallocate(void* ptr, size_t sz, size_t alignment) override;
+    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 // NOLINT(*-member-functions)
+{
+
+    C4_NO_COPY_OR_MOVE(MemoryResourceStack);
+
+public:
+
+    using detail::_MemoryResourceSingleChunk::_MemoryResourceSingleChunk;
+
+protected:
+
+    void* do_allocate(size_t sz, size_t alignment, void *hint) override;
+    void  do_deallocate(void* ptr, size_t sz, size_t alignment) override;
+    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
+{
+    C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4324) // structure was padded due to alignment specifier
+    alignas(alignof(max_align_t)) char m_arr[N];
+    C4_SUPPRESS_WARNING_MSVC_POP
+    MemoryResourceLinearArr() : MemoryResourceLinear(m_arr, N) { name = "linear_arr"; } // NOLINT
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+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; // NOLINT
+    AllocationCounts m_counts; // NOLINT
+
+protected:
+
+    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;
+    }
+
+    void  do_deallocate(void* ptr, size_t sz, size_t alignment) override
+    {
+        m_counts.rem_counts(ptr, sz);
+        m_resource->deallocate(ptr, sz, alignment);
+    }
+
+    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 // NOLINT(*-member-functions)
+{
+    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 // NOLINT(*-member-functions)
+{
+    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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+/** 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) // NOLINT
+{
+    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]));
+    }
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // namespace c4
+
+#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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+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()) {}
+
+    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() = default;
+    MemResGlobal(MemoryResource* r) noexcept { C4_UNUSED(r); C4_ASSERT(r == get_memory_resource()); }
+
+    static MemoryResource* resource() { 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> // NOLINT(*-member-functions)
+{
+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; // 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> // NOLINT(*-member-functions)
+{
+    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>;
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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 const* 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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+/** @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_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;
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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_;
+
+namespace detail {
+template<class T> struct is_blob_type : std::integral_constant<bool, false> {};
+template<class T> struct is_blob_type<blob_<T>> : std::integral_constant<bool, true> {};
+template<class T> struct is_blob_value_type : std::integral_constant<bool, (std::is_fundamental<T>::value || std::is_trivially_copyable<T>::value)> {};
+} // namespace
+
+// NOLINTBEGIN(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+
+template<class T>
+struct blob_
+{
+    static_assert(std::is_same<T, byte>::value || std::is_same<T, cbyte>::value, "must be either byte or cbyte");
+    static_assert(sizeof(T) == 1u, "must be either byte or cbyte");
+
+public:
+
+    T *    buf;
+    size_t len;
+
+public:
+
+    C4_ALWAYS_INLINE blob_() noexcept = default;
+    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;
+
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_(blob_<U> const& that) noexcept : buf(that.buf), len(that.len) {} // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_(blob_<U>     && that) noexcept : buf(that.buf), len(that.len) {} // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_& operator=(blob_<U>     && that) noexcept { buf = that.buf; len = that.len; } // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_& operator=(blob_<U> const& that) noexcept { buf = that.buf; len = that.len; } // NOLINT
+
+    C4_ALWAYS_INLINE blob_(void       *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {} // NOLINT
+    C4_ALWAYS_INLINE blob_(void const *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {} // NOLINT
+
+    #define _C4_REQUIRE_BLOBTYPE(ty) class=typename std::enable_if<((!detail::is_blob_type<ty>::value) && (detail::is_blob_value_type<ty>::value)), T>::type
+    template<class U, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_(U &var) noexcept : buf(reinterpret_cast<T*>(&var)), len(sizeof(U)) {} // NOLINT
+    template<class U, _C4_REQUIRE_BLOBTYPE(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)); } // NOLINT
+    template<class U, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_& operator= (U &var) noexcept { buf = reinterpret_cast<T*>(&var); len = sizeof(U); return *this; } // NOLINT
+    template<class U, size_t N, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_(U (&arr)[N]) noexcept : buf(reinterpret_cast<T*>(arr)), len(sizeof(U) * N) {} // NOLINT
+    template<class U, size_t N, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_& operator= (U (&arr)[N]) noexcept { buf = reinterpret_cast<T*>(arr); len = sizeof(U) * N; return *this; } // NOLINT
+    #undef _C4_REQUIRE_BLOBTYPE
+};
+
+// NOLINTEND(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+
+/** 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
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#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"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+
+namespace c4 {
+
+/** @defgroup doc_substr Substring: read/write string views
+ * @{ */
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+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
+/** @endcond */
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+// 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
+/** @endcond */
+
+
+/** a non-owning string-view, consisting of a character pointer
+ * and a length.
+ *
+ * @note The pointer is explicitly restricted.
+ *
+ * @see a [quickstart
+ * sample](https://rapidyaml.readthedocs.io/latest/doxygen/group__doc__quickstart.html#ga43e253da0692c13967019446809c1113)
+ * in rapidyaml's documentation.
+ */
+template<class C>
+struct C4CORE_EXPORT basic_substring // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+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
+    template<class U=C>
+    C4_ALWAYS_INLINE operator typename std::enable_if<!std::is_const<U>::value, ro_substr const&>::type () const noexcept
+    {
+        return *(ro_substr const*)this; // don't call the str+len ctor because it does a check
+    }
+
+    /** @} */
+
+public:
+
+    /** @name Default construction and assignment */
+    /** @{ */
+
+    C4_ALWAYS_INLINE constexpr basic_substring() noexcept : str(), len() {}
+
+    C4_ALWAYS_INLINE basic_substring(basic_substring const&) noexcept = default;
+    C4_ALWAYS_INLINE basic_substring(basic_substring     &&) noexcept = default;
+    C4_ALWAYS_INLINE basic_substring(std::nullptr_t) noexcept : str(nullptr), len(0) {}
+
+    C4_ALWAYS_INLINE basic_substring& operator= (basic_substring const&) noexcept = default;
+    C4_ALWAYS_INLINE basic_substring& operator= (basic_substring     &&) noexcept = default;
+    C4_ALWAYS_INLINE basic_substring& operator= (std::nullptr_t) noexcept { str = nullptr; len = 0; return *this; }
+
+    C4_ALWAYS_INLINE void clear() noexcept { str = nullptr; len = 0; }
+
+    /** @} */
+
+public:
+
+    /** @name Construction and assignment from characters with the same type */
+    /** @{ */
+
+    /** Construct from an array.
+     * @warning the input string need not be zero terminated, but the
+     * length is taken as if the string was zero terminated */
+    template<size_t N>
+    C4_ALWAYS_INLINE constexpr basic_substring(C (&s_)[N]) noexcept : str(s_), len(N-1) {}
+    /** Construct from a pointer and length.
+     * @warning the input string need not be zero terminated. */
+    C4_ALWAYS_INLINE basic_substring(C *s_, size_t len_) noexcept : str(s_), len(len_) { C4_ASSERT(str || !len_); }
+    /** Construct from two pointers.
+     * @warning the end pointer MUST BE larger than or equal to the begin pointer
+     * @warning the input string need not be zero terminated */
+    C4_ALWAYS_INLINE basic_substring(C *beg_, C *end_) noexcept : str(beg_), len(static_cast<size_t>(end_ - beg_)) { C4_ASSERT(end_ >= beg_); }
+    /** Construct from a C-string (zero-terminated string)
+     * @warning the input string MUST BE zero terminated.
+     * @warning will call strlen()
+     * @note this overload uses SFINAE to prevent it from overriding the array ctor
+     * @see For a more detailed explanation on why the plain overloads cannot
+     * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+    template<class U, typename std::enable_if<std::is_same<U, C*>::value || std::is_same<U, NCC_*>::value, int>::type=0>
+    C4_ALWAYS_INLINE basic_substring(U s_) noexcept : str(s_), len(s_ ? strlen(s_) : 0) {}
+
+    /** Assign from an array.
+     * @warning the input string need not be zero terminated, but the
+     * length is taken as if the string was zero terminated */
+    template<size_t N>
+    C4_ALWAYS_INLINE void assign(C (&s_)[N]) noexcept { str = (s_); len = (N-1); }
+    /** Assign from a pointer and length.
+     * @warning the input string need not be zero terminated. */
+    C4_ALWAYS_INLINE void assign(C *s_, size_t len_) noexcept { str = s_; len = len_; C4_ASSERT(str || !len_); }
+    /** Assign from two pointers.
+     * @warning the end pointer MUST BE larger than or equal to the begin pointer
+     * @warning the input string need not be zero terminated. */
+    C4_ALWAYS_INLINE void assign(C *beg_, C *end_) noexcept { C4_ASSERT(end_ >= beg_); str = (beg_); len = static_cast<size_t>(end_ - beg_); }
+    /** Assign from a C-string (zero-terminated string)
+     * @warning the input string must be zero terminated.
+     * @warning will call strlen()
+     * @note this overload uses SFINAE to prevent it from overriding the array ctor
+     * @see For a more detailed explanation on why the plain overloads cannot
+     * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+    template<class U, typename std::enable_if<std::is_same<U, C*>::value || std::is_same<U, NCC_*>::value, int>::type=0>
+    C4_ALWAYS_INLINE void assign(U s_) noexcept { str = (s_); len = (s_ ? strlen(s_) : 0); }
+
+    /** Assign from an array.
+     * @warning the input string need not be zero terminated. */
+    template<size_t N>
+    C4_ALWAYS_INLINE basic_substring& operator= (C (&s_)[N]) noexcept { str = (s_); len = (N-1); return *this; }
+    /** Assign from a C-string (zero-terminated string)
+     * @warning the input string MUST BE zero terminated.
+     * @warning will call strlen()
+     * @note this overload uses SFINAE to prevent it from overriding the array ctor
+     * @see For a more detailed explanation on why the plain overloads cannot
+     * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+    template<class U, typename std::enable_if<std::is_same<U, C*>::value || std::is_same<U, NCC_*>::value, int>::type=0>
+    C4_ALWAYS_INLINE basic_substring& operator= (U s_) noexcept { str = s_; len = s_ ? strlen(s_) : 0; return *this; }
+
+    /** @} */
+
+public:
+
+    /** @name Standard accessor methods */
+    /** @{ */
+
+    C4_ALWAYS_INLINE C4_PURE bool   has_str()   const noexcept { return ! empty() && str[0] != C(0); }
+    C4_ALWAYS_INLINE C4_PURE bool   empty()     const noexcept { return (len == 0 || str == nullptr); }
+    C4_ALWAYS_INLINE C4_PURE bool   not_empty() const noexcept { return (len != 0 && str != nullptr); }
+    C4_ALWAYS_INLINE C4_PURE size_t size()      const noexcept { return len; }
+
+    C4_ALWAYS_INLINE C4_PURE iterator begin() noexcept { return str; }
+    C4_ALWAYS_INLINE C4_PURE iterator end  () noexcept { return str + len; }
+
+    C4_ALWAYS_INLINE C4_PURE const_iterator begin() const noexcept { return str; }
+    C4_ALWAYS_INLINE C4_PURE const_iterator end  () const noexcept { return str + len; }
+
+    C4_ALWAYS_INLINE C4_PURE C      * data()       noexcept { return str; }
+    C4_ALWAYS_INLINE C4_PURE C const* data() const noexcept { return str; }
+
+    C4_ALWAYS_INLINE C4_PURE C      & operator[] (size_t i)       noexcept { C4_ASSERT(i >= 0 && i < len); return str[i]; }
+    C4_ALWAYS_INLINE C4_PURE C const& operator[] (size_t i) const noexcept { C4_ASSERT(i >= 0 && i < len); return str[i]; }
+
+    C4_ALWAYS_INLINE C4_PURE C      & front()       noexcept { C4_ASSERT(len > 0 && str != nullptr); return *str; }
+    C4_ALWAYS_INLINE C4_PURE C const& front() const noexcept { C4_ASSERT(len > 0 && str != nullptr); return *str; }
+
+    C4_ALWAYS_INLINE C4_PURE C      & back()       noexcept { C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }
+    C4_ALWAYS_INLINE C4_PURE C const& back() const noexcept { C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }
+
+    /** @} */
+
+public:
+
+    /** @name Comparison methods */
+    /** @{ */
+
+    C4_PURE int compare(C const c) const noexcept
+    {
+        C4_XASSERT((str != nullptr) || len == 0);
+        if(C4_LIKELY(str != nullptr && len > 0))
+            return (*str != c) ? *str - c : (static_cast<int>(len) - 1);
+        else
+            return -1;
+    }
+
+    C4_PURE int compare(const char *C4_RESTRICT that, size_t sz) const noexcept
+    {
+        C4_XASSERT(that || sz  == 0);
+        C4_XASSERT(str  || len == 0);
+        if(C4_LIKELY(str && that))
+        {
+            {
+                const size_t min = len < sz ? len : sz;
+                for(size_t i = 0; i < min; ++i)
+                    if(str[i] != that[i])
+                        return str[i] < that[i] ? -1 : 1;
+            }
+            if(len < sz)
+                return -1;
+            else if(len == sz)
+                return 0;
+            else
+                return 1;
+        }
+        else if(len == sz)
+        {
+            C4_XASSERT(len == 0 && sz == 0);
+            return 0;
+        }
+        return len < sz ? -1 : 1;
+    }
+
+    C4_ALWAYS_INLINE C4_PURE int compare(ro_substr const that) const noexcept { return this->compare(that.str, that.len); }
+
+    C4_ALWAYS_INLINE C4_PURE bool operator== (std::nullptr_t) const noexcept { return str == nullptr; }
+    C4_ALWAYS_INLINE C4_PURE bool operator!= (std::nullptr_t) const noexcept { return str != nullptr; }
+
+    C4_ALWAYS_INLINE C4_PURE bool operator== (C const c) const noexcept { return this->compare(c) == 0; }
+    C4_ALWAYS_INLINE C4_PURE bool operator!= (C const c) const noexcept { return this->compare(c) != 0; }
+    C4_ALWAYS_INLINE C4_PURE bool operator<  (C const c) const noexcept { return this->compare(c) <  0; }
+    C4_ALWAYS_INLINE C4_PURE bool operator>  (C const c) const noexcept { return this->compare(c) >  0; }
+    C4_ALWAYS_INLINE C4_PURE bool operator<= (C const c) const noexcept { return this->compare(c) <= 0; }
+    C4_ALWAYS_INLINE C4_PURE bool operator>= (C const c) const noexcept { return this->compare(c) >= 0; }
+
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator== (basic_substring<U> const that) const noexcept { return this->compare(that) == 0; }
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator!= (basic_substring<U> const that) const noexcept { return this->compare(that) != 0; }
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator<  (basic_substring<U> const that) const noexcept { return this->compare(that) <  0; }
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator>  (basic_substring<U> const that) const noexcept { return this->compare(that) >  0; }
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator<= (basic_substring<U> const that) const noexcept { return this->compare(that) <= 0; }
+    template<class U> C4_ALWAYS_INLINE C4_PURE bool operator>= (basic_substring<U> const that) const noexcept { return this->compare(that) >= 0; }
+
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator== (const char (&that)[N]) const noexcept { return this->compare(that, N-1) == 0; }
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator!= (const char (&that)[N]) const noexcept { return this->compare(that, N-1) != 0; }
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator<  (const char (&that)[N]) const noexcept { return this->compare(that, N-1) <  0; }
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator>  (const char (&that)[N]) const noexcept { return this->compare(that, N-1) >  0; }
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator<= (const char (&that)[N]) const noexcept { return this->compare(that, N-1) <= 0; }
+    template<size_t N> C4_ALWAYS_INLINE C4_PURE bool operator>= (const char (&that)[N]) const noexcept { 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) */
+    C4_ALWAYS_INLINE C4_PURE bool is_sub(ro_substr const that) const noexcept
+    {
+        return that.is_super(*this);
+    }
+
+    /** true if that is a substring of *this (ie, from the same buffer) */
+    C4_ALWAYS_INLINE C4_PURE bool is_super(ro_substr const that) const noexcept
+    {
+        if(C4_LIKELY(len > 0))
+            return that.str >= str && that.str+that.len <= str+len;
+        else
+            return that.len == 0 && that.str == str && str != nullptr;
+    }
+
+    /** true if there is overlap of at least one element between that and *this */
+    C4_ALWAYS_INLINE C4_PURE bool overlaps(ro_substr const that) const noexcept
+    {
+        // thanks @timwynants
+        return that.str+that.len > str && that.str < str+len;
+    }
+
+public:
+
+    /** return [first,len[ */
+    C4_ALWAYS_INLINE C4_PURE basic_substring sub(size_t first) const noexcept
+    {
+        C4_ASSERT(first >= 0 && first <= len);
+        return basic_substring(str + first, len - first);
+    }
+
+    /** return [first,first+num[. If num==npos, return [first,len[ */
+    C4_ALWAYS_INLINE C4_PURE basic_substring sub(size_t first, size_t num) const noexcept
+    {
+        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[ */
+    C4_ALWAYS_INLINE C4_PURE basic_substring range(size_t first, size_t last=npos) const noexcept
+    {
+        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 the first @p num elements: [0,num[*/
+    C4_ALWAYS_INLINE C4_PURE basic_substring first(size_t num) const noexcept
+    {
+        C4_ASSERT(num <= len || num == npos);
+        return basic_substring(str, num != npos ? num : len);
+    }
+
+    /** return the last @p num elements: [len-num,len[*/
+    C4_ALWAYS_INLINE C4_PURE basic_substring last(size_t num) const noexcept
+    {
+        C4_ASSERT(num <= len || num == npos);
+        return num != npos ?
+            basic_substring(str + len - num, num) :
+            *this;
+    }
+
+    /** 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. */
+    C4_ALWAYS_INLINE C4_PURE basic_substring offs(size_t left, size_t right) const noexcept
+    {
+        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[ . Same as .first(pos), but provided for compatibility with .right_of() */
+    C4_ALWAYS_INLINE C4_PURE basic_substring left_of(size_t pos) const noexcept
+    {
+        C4_ASSERT(pos <= len || pos == npos);
+        return (pos != npos) ?
+            basic_substring(str, pos) :
+            *this;
+    }
+
+    /** return [0, pos+include_pos[ . Same as .first(pos+1), but provided for compatibility with .right_of() */
+    C4_ALWAYS_INLINE C4_PURE basic_substring left_of(size_t pos, bool include_pos) const noexcept
+    {
+        C4_ASSERT(pos <= len || pos == npos);
+        return (pos != npos) ?
+            basic_substring(str, pos+include_pos) :
+            *this;
+    }
+
+    /** return [pos+1, len[ */
+    C4_ALWAYS_INLINE C4_PURE basic_substring right_of(size_t pos) const noexcept
+    {
+        C4_ASSERT(pos <= len || pos == npos);
+        return (pos != npos) ?
+            basic_substring(str + (pos + 1), len - (pos + 1)) :
+            basic_substring(str + len, size_t(0));
+    }
+
+    /** return [pos+!include_pos, len[ */
+    C4_ALWAYS_INLINE C4_PURE basic_substring right_of(size_t pos, bool include_pos) const noexcept
+    {
+        C4_ASSERT(pos <= len || pos == npos);
+        return (pos != npos) ?
+            basic_substring(str + (pos + !include_pos), len - (pos + !include_pos)) :
+            basic_substring(str + len, size_t(0));
+    }
+
+public:
+
+    /** given @p subs a substring of the current string, get the
+     * portion of the current string to the left of it */
+    C4_ALWAYS_INLINE C4_PURE basic_substring left_of(ro_substr const subs) const noexcept
+    {
+        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 */
+    C4_ALWAYS_INLINE C4_PURE basic_substring right_of(ro_substr const subs) const noexcept
+    {
+        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 */
+    /** @{ */
+
+    size_t find(const C c, size_t start_pos=0) const
+    {
+        return first_of(c, start_pos);
+    }
+    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 */
+    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 */
+    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 */
+    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 */
+    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;
+        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) const
+    {
+        for(size_t i = 0; i < len; ++i)
+        {
+            if(str[i] != c)
+                return i;
+        }
+        return npos;
+    }
+
+    size_t first_not_of(const C c, size_t start) 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) const
+    {
+        for(size_t i = len-1; i != size_t(-1); --i)
+        {
+            if(str[i] != c)
+                return i;
+        }
+        return npos;
+    }
+
+    size_t last_not_of(const C c, size_t start) 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) const
+    {
+        for(size_t i = 0; 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 first_not_of(ro_substr chars, size_t start) 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) const
+    {
+        for(size_t i = len-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;
+    }
+
+    size_t last_not_of(ro_substr chars, size_t start) 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 = size_t(ne.str[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 = size_t(ne.str[0] == '+' || ne.str[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(len >= skip_start + 3)
+        {
+            if(str[skip_start] != '0')
+            {
+                for(size_t i = skip_start; i < len; ++i)
+                {
+                    char c = str[i];
+                    if(c < '0' || c > '9')
+                        return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
+                }
+            }
+            else
+            {
+                char next = str[skip_start + 1];
+                if(next == 'x' || next == 'X')
+                {
+                    skip_start += 2;
+                    for(size_t i = skip_start; i < len; ++i)
+                    {
+                        const char c = str[i];
+                        if( ! _is_hex_char(c))
+                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
+                    }
+                    return *this;
+                }
+                else if(next == 'b' || next == 'B')
+                {
+                    skip_start += 2;
+                    for(size_t i = skip_start; i < len; ++i)
+                    {
+                        const char c = str[i];
+                        if(c != '0' && c != '1')
+                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
+                    }
+                    return *this;
+                }
+                else if(next == 'o' || next == 'O')
+                {
+                    skip_start += 2;
+                    for(size_t i = skip_start; i < len; ++i)
+                    {
+                        const char c = str[i];
+                        if(c < '0' || c > '7')
+                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
+                    }
+                    return *this;
+                }
+            }
+        }
+        // must be a decimal, or it is not a an number
+        for(size_t i = skip_start; i < len; ++i)
+        {
+            const char c = str[i];
+            if(c < '0' || c > '9')
+                return i > skip_start && _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;
+        const size_t skip_start = (ne.str[0] == '+' || ne.str[0] == '-');
+        C4_ASSERT(skip_start == 0 || skip_start == 1);
+        // if we have at least three digits after the leading sign, it
+        // can be decimal, or hex, or bin or oct. Ex:
+        // non-decimal: 0x0, 0b0, 0o0
+        // decimal: 1.0, 10., 1e1, 100, inf, nan, infinity
+        if(ne.len >= skip_start+3)
+        {
+            // if it does not have leading 0, it must be decimal, or it is not a real
+            if(ne.str[skip_start] != '0')
+            {
+                if(ne.str[skip_start] == 'i') // is it infinity or inf?
+                {
+                    basic_substring word = ne._word_follows(skip_start + 1, "nfinity");
+                    if(word.len)
+                        return word;
+                    return ne._word_follows(skip_start + 1, "nf");
+                }
+                else if(ne.str[skip_start] == 'n') // is it nan?
+                {
+                    return ne._word_follows(skip_start + 1, "an");
+                }
+                else // must be a decimal, or it is not a real
+                {
+                    return ne._first_real_span_dec(skip_start);
+                }
+            }
+            else // starts with 0. is it 0x, 0b or 0o?
+            {
+                const char next = ne.str[skip_start + 1];
+                // hexadecimal
+                if(next == 'x' || next == 'X')
+                    return ne._first_real_span_hex(skip_start + 2);
+                // binary
+                else if(next == 'b' || next == 'B')
+                    return ne._first_real_span_bin(skip_start + 2);
+                // octal
+                else if(next == 'o' || next == 'O')
+                    return ne._first_real_span_oct(skip_start + 2);
+                // none of the above. may still be a decimal.
+                else
+                    return ne._first_real_span_dec(skip_start); // do not skip the 0.
+            }
+        }
+        // less than 3 chars after the leading sign. It is either a
+        // decimal or it is not a real. (cannot be any of 0x0, etc).
+        return ne._first_real_span_dec(skip_start);
+    }
+
+    /** true if the character is a delimiter character *at the end* */
+    static constexpr C4_ALWAYS_INLINE C4_CONST bool _is_delim_char(char c) noexcept
+    {
+        return c == ' ' || c == '\n'
+            || c == ']' || c == ')'  || c == '}'
+            || c == ',' || c == ';' || c == '\r' || c == '\t' || c == '\0';
+    }
+
+    /** true if the character is in [0-9a-fA-F] */
+    static constexpr C4_ALWAYS_INLINE C4_CONST bool _is_hex_char(char c) noexcept
+    {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+    }
+
+    C4_NO_INLINE C4_PURE basic_substring _word_follows(size_t pos, csubstr word) const noexcept
+    {
+        size_t posend = pos + word.len;
+        if(len >= posend && sub(pos, word.len) == word)
+            if(len == posend || _is_delim_char(str[posend]))
+                return first(posend);
+        return first(0);
+    }
+
+    // this function is declared inside the class to avoid a VS error with __declspec(dllimport)
+    C4_NO_INLINE C4_PURE basic_substring _first_real_span_dec(size_t pos) const noexcept
+    {
+        bool intchars = false;
+        bool fracchars = false;
+        bool powchars;
+        // integral part
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+            {
+                intchars = true;
+            }
+            else if(c == '.')
+            {
+                ++pos;
+                goto fractional_part_dec; // NOLINT
+            }
+            else if(c == 'e' || c == 'E')
+            {
+                ++pos;
+                goto power_part_dec; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        // no . or p were found; this is either an integral number
+        // or not a number at all
+        return intchars ?
+            *this :
+            first(0);
+    fractional_part_dec:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == '.');
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+            {
+                fracchars = true;
+            }
+            else if(c == 'e' || c == 'E')
+            {
+                ++pos;
+                goto power_part_dec; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars || fracchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        return intchars || fracchars ?
+            *this :
+            first(0);
+    power_part_dec:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == 'e' || str[pos - 1] == 'E');
+        // either digits, or +, or - are expected here, followed by more digits.
+        if((len == pos) || ((!intchars) && (!fracchars)))
+            return first(0);
+        if(str[pos] == '-' || str[pos] == '+')
+            ++pos; // skip the sign
+        powchars = false;
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+                powchars = true;
+            else if(powchars && _is_delim_char(c))
+                return first(pos);
+            else
+                return first(0);
+        }
+        return powchars ? *this : first(0);
+    }
+
+    // this function is declared inside the class to avoid a VS error with __declspec(dllimport)
+    C4_NO_INLINE C4_PURE basic_substring _first_real_span_hex(size_t pos) const noexcept
+    {
+        bool intchars = false;
+        bool fracchars = false;
+        bool powchars;
+        // integral part
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(_is_hex_char(c))
+            {
+                intchars = true;
+            }
+            else if(c == '.')
+            {
+                ++pos;
+                goto fractional_part_hex; // NOLINT
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_hex; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        // no . or p were found; this is either an integral number
+        // or not a number at all
+        return intchars ?
+            *this :
+            first(0);
+    fractional_part_hex:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == '.');
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(_is_hex_char(c))
+            {
+                fracchars = true;
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_hex; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars || fracchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        return intchars || fracchars ?
+            *this :
+            first(0);
+    power_part_hex:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
+        // either a + or a - is expected here, followed by more chars.
+        // also, using (pos+1) in this check will cause an early
+        // return when no more chars follow the sign.
+        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
+            return first(0);
+        ++pos; // this was the sign.
+        // ... so the (pos+1) ensures that we enter the loop and
+        // hence that there exist chars in the power part
+        powchars = false;
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+                powchars = true;
+            else if(powchars && _is_delim_char(c))
+                return first(pos);
+            else
+                return first(0);
+        }
+        return *this;
+    }
+
+    // this function is declared inside the class to avoid a VS error with __declspec(dllimport)
+    C4_NO_INLINE C4_PURE basic_substring _first_real_span_bin(size_t pos) const noexcept
+    {
+        bool intchars = false;
+        bool fracchars = false;
+        bool powchars;
+        // integral part
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c == '0' || c == '1')
+            {
+                intchars = true;
+            }
+            else if(c == '.')
+            {
+                ++pos;
+                goto fractional_part_bin; // NOLINT
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_bin; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        // no . or p were found; this is either an integral number
+        // or not a number at all
+        return intchars ?
+            *this :
+            first(0);
+    fractional_part_bin:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == '.');
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c == '0' || c == '1')
+            {
+                fracchars = true;
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_bin; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars || fracchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        return intchars || fracchars ?
+            *this :
+            first(0);
+    power_part_bin:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
+        // either a + or a - is expected here, followed by more chars.
+        // also, using (pos+1) in this check will cause an early
+        // return when no more chars follow the sign.
+        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
+            return first(0);
+        ++pos; // this was the sign.
+        // ... so the (pos+1) ensures that we enter the loop and
+        // hence that there exist chars in the power part
+        powchars = false;
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+                powchars = true;
+            else if(powchars && _is_delim_char(c))
+                return first(pos);
+            else
+                return first(0);
+        }
+        return *this;
+    }
+
+    // this function is declared inside the class to avoid a VS error with __declspec(dllimport)
+    C4_NO_INLINE C4_PURE basic_substring _first_real_span_oct(size_t pos) const noexcept
+    {
+        bool intchars = false;
+        bool fracchars = false;
+        bool powchars;
+        // integral part
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '7')
+            {
+                intchars = true;
+            }
+            else if(c == '.')
+            {
+                ++pos;
+                goto fractional_part_oct; // NOLINT
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_oct; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        // no . or p were found; this is either an integral number
+        // or not a number at all
+        return intchars ?
+            *this :
+            first(0);
+    fractional_part_oct:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == '.');
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '7')
+            {
+                fracchars = true;
+            }
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power_part_oct; // NOLINT
+            }
+            else if(_is_delim_char(c))
+            {
+                return intchars || fracchars ? first(pos) : first(0);
+            }
+            else
+            {
+                return first(0);
+            }
+        }
+        return intchars || fracchars ?
+            *this :
+            first(0);
+    power_part_oct:
+        C4_ASSERT(pos > 0);
+        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
+        // either a + or a - is expected here, followed by more chars.
+        // also, using (pos+1) in this check will cause an early
+        // return when no more chars follow the sign.
+        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
+            return first(0);
+        ++pos; // this was the sign.
+        // ... so the (pos+1) ensures that we enter the loop and
+        // hence that there exist chars in the power part
+        powchars = false;
+        for( ; pos < len; ++pos)
+        {
+            const char c = str[pos];
+            if(c >= '0' && c <= '9')
+                powchars = true;
+            else if(powchars && _is_delim_char(c))
+                return first(pos);
+            else
+                return first(0);
+        }
+        return *this;
+    }
+
+    /** @} */
+
+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; i < len; 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 && str && 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; } // NOLINT
+
+            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);
+        // calling memcpy with null strings is undefined behavior
+        // and will wreak havoc in calling code's branches.
+        // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+        if(num)
+            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)); // NOLINT
+    }
+
+    /** 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
+     * @p 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(num > 0 && 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
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_substr_adapters substr adapters
+ *
+ * to_substr() and to_csubstr() is used in generic code like
+ * format(), and allow adding construction of substrings from new
+ * types like containers.
+ * @{ */
+
+
+/** neutral version for use in generic code */
+C4_ALWAYS_INLINE substr to_substr(substr s) noexcept { return s; }
+/** neutral version for use in generic code */
+C4_ALWAYS_INLINE csubstr to_csubstr(substr s) noexcept { return s; }
+/** neutral version for use in generic code */
+C4_ALWAYS_INLINE csubstr to_csubstr(csubstr s) noexcept { return s; }
+
+
+template<size_t N>
+C4_ALWAYS_INLINE substr
+to_substr(char (&s)[N]) noexcept { substr ss(s, N-1); return ss; }
+template<size_t N>
+C4_ALWAYS_INLINE csubstr
+to_csubstr(const char (&s)[N]) noexcept { csubstr ss(s, N-1); return ss; }
+
+
+/** @note this overload uses SFINAE to prevent it from overriding the array overload
+ * @see For a more detailed explanation on why the plain overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+template<class U>
+C4_ALWAYS_INLINE typename std::enable_if<std::is_same<U, char*>::value, substr>::type
+to_substr(U s) noexcept { substr ss(s); return ss; }
+/** @note this overload uses SFINAE to prevent it from overriding the array overload
+ * @see For a more detailed explanation on why the plain overloads cannot
+ * coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html */
+template<class U>
+C4_ALWAYS_INLINE typename std::enable_if<std::is_same<U, const char*>::value || std::is_same<U, char*>::value, csubstr>::type
+to_csubstr(U s) noexcept { csubstr ss(s); return ss; }
+
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_substr_cmp substr comparison operators
+ * @{ */
+
+template<typename C, size_t N> inline bool operator== (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) == 0; }
+template<typename C, size_t N> inline bool operator!= (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) != 0; }
+template<typename C, size_t N> inline bool operator<  (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) >  0; }
+template<typename C, size_t N> inline bool operator>  (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) <  0; }
+template<typename C, size_t N> inline bool operator<= (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) >= 0; }
+template<typename C, size_t N> inline bool operator>= (const char (&s)[N], basic_substring<C> const that) noexcept { return that.compare(s, N-1) <= 0; }
+
+template<typename C> inline bool operator== (const char c, basic_substring<C> const that) noexcept { return that.compare(c) == 0; }
+template<typename C> inline bool operator!= (const char c, basic_substring<C> const that) noexcept { return that.compare(c) != 0; }
+template<typename C> inline bool operator<  (const char c, basic_substring<C> const that) noexcept { return that.compare(c) >  0; }
+template<typename C> inline bool operator>  (const char c, basic_substring<C> const that) noexcept { return that.compare(c) <  0; }
+template<typename C> inline bool operator<= (const char c, basic_substring<C> const that) noexcept { return that.compare(c) >= 0; }
+template<typename C> inline bool operator>= (const char c, basic_substring<C> const that) noexcept { return that.compare(c) <= 0; }
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/* 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_
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   pragma warning(push)
+#   pragma warning(disable: 4365) // '=': conversion from 'const _Ty' to 'fast_float::limb', signed/unsigned mismatch
+#   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"
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wnarrowing"
+#   pragma GCC diagnostic ignored "-Wconversion"
+#   pragma GCC diagnostic ignored "-Wsign-conversion"
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#   pragma GCC diagnostic ignored "-Warray-bounds"
+#   if __GNUC__ >= 5
+#       pragma GCC diagnostic ignored "-Wshift-count-overflow"
+#   endif
+#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
+// with contributions from Lénárd Szolnoki
+// with contributions from Jan Pharago
+// with contributions from Maya Warrier
+// with contributions from Taha Khokhar
+// with contributions from Anders Dalvander
+//
+//
+// 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_CONSTEXPR_FEATURE_DETECT_H
+#define FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
+// Testing for https://wg21.link/N3652, adopted in C++14
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#define FASTFLOAT_CONSTEXPR14 constexpr
+#else
+#define FASTFLOAT_CONSTEXPR14
+#endif
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#define FASTFLOAT_HAS_BIT_CAST 1
+#else
+#define FASTFLOAT_HAS_BIT_CAST 0
+#endif
+
+#if defined(__cpp_lib_is_constant_evaluated) &&                                \
+    __cpp_lib_is_constant_evaluated >= 201811L
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1
+#else
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0
+#endif
+
+// Testing for relevant C++20 constexpr library features
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED && FASTFLOAT_HAS_BIT_CAST &&           \
+    defined(__cpp_lib_constexpr_algorithms) &&                                 \
+    __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/
+#define FASTFLOAT_CONSTEXPR20 constexpr
+#define FASTFLOAT_IS_CONSTEXPR 1
+#else
+#define FASTFLOAT_CONSTEXPR20
+#define FASTFLOAT_IS_CONSTEXPR 0
+#endif
+
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 0
+#else
+#define FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE 1
+#endif
+
+#endif // FASTFLOAT_CONSTEXPR_FEATURE_DETECT_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 <limits>
+//included above:
+//#include <type_traits>
+#include <system_error>
+#ifdef __has_include
+#if __has_include(<stdfloat>) && (__cplusplus > 202002L || (defined(_MSVC_LANG) && (_MSVC_LANG > 202002L)))
+#include <stdfloat>
+#endif
+#endif
+
+#define FASTFLOAT_VERSION_MAJOR 8
+#define FASTFLOAT_VERSION_MINOR 0
+#define FASTFLOAT_VERSION_PATCH 0
+
+#define FASTFLOAT_STRINGIZE_IMPL(x) #x
+#define FASTFLOAT_STRINGIZE(x) FASTFLOAT_STRINGIZE_IMPL(x)
+
+#define FASTFLOAT_VERSION_STR                                                  \
+  FASTFLOAT_STRINGIZE(FASTFLOAT_VERSION_MAJOR)                                 \
+  "." FASTFLOAT_STRINGIZE(FASTFLOAT_VERSION_MINOR) "." FASTFLOAT_STRINGIZE(    \
+      FASTFLOAT_VERSION_PATCH)
+
+#define FASTFLOAT_VERSION                                                      \
+  (FASTFLOAT_VERSION_MAJOR * 10000 + FASTFLOAT_VERSION_MINOR * 100 +           \
+   FASTFLOAT_VERSION_PATCH)
+
+namespace fast_float {
+
+enum class chars_format : uint64_t;
+
+namespace detail {
+constexpr chars_format basic_json_fmt = chars_format(1 << 5);
+constexpr chars_format basic_fortran_fmt = chars_format(1 << 6);
+} // namespace detail
+
+enum class chars_format : uint64_t {
+  scientific = 1 << 0,
+  fixed = 1 << 2,
+  hex = 1 << 3,
+  no_infnan = 1 << 4,
+  // RFC 8259: https://datatracker.ietf.org/doc/html/rfc8259#section-6
+  json = uint64_t(detail::basic_json_fmt) | fixed | scientific | no_infnan,
+  // Extension of RFC 8259 where, e.g., "inf" and "nan" are allowed.
+  json_or_infnan = uint64_t(detail::basic_json_fmt) | fixed | scientific,
+  fortran = uint64_t(detail::basic_fortran_fmt) | fixed | scientific,
+  general = fixed | scientific,
+  allow_leading_plus = 1 << 7,
+  skip_white_space = 1 << 8,
+};
+
+template <typename UC> struct from_chars_result_t {
+  UC const *ptr;
+  std::errc ec;
+};
+
+using from_chars_result = from_chars_result_t<char>;
+
+template <typename UC> struct parse_options_t {
+  constexpr explicit parse_options_t(chars_format fmt = chars_format::general,
+                                     UC dot = UC('.'), int b = 10)
+      : format(fmt), decimal_point(dot), base(b) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  UC decimal_point;
+  /** The base used for integers */
+  int base;
+};
+
+using parse_options = parse_options_t<char>;
+
+} // namespace fast_float
+
+#if FASTFLOAT_HAS_BIT_CAST
+#include <bit>
+#endif
+
+#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(__loongarch64))
+#define FASTFLOAT_64BIT 1
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) ||             \
+       defined(__arm__) || defined(_M_ARM) || defined(__ppc__) ||              \
+       defined(__MINGW32__) || defined(__EMSCRIPTEN__))
+#define FASTFLOAT_32BIT 1
+#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 1
+#elif SIZE_MAX == 0xffffffffffffffff
+#define FASTFLOAT_64BIT 1
+#else
+#error Unknown platform (not 32-bit, not 64-bit?)
+#endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__)) ||           \
+    (defined(_M_ARM64) && !defined(__MINGW32__))
+//included above:
+//#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>
+#elif defined(__MVS__)
+#include <sys/endian.h>
+#else
+#ifdef __has_include
+#if __has_include(<endian.h>)
+#include <endian.h>
+#endif //__has_include(<endian.h>)
+#endif //__has_include
+#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
+
+#if defined(__SSE2__) || (defined(FASTFLOAT_VISUAL_STUDIO) &&                  \
+                          (defined(_M_AMD64) || defined(_M_X64) ||             \
+                           (defined(_M_IX86_FP) && _M_IX86_FP == 2)))
+#define FASTFLOAT_SSE2 1
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define FASTFLOAT_NEON 1
+#endif
+
+#if defined(FASTFLOAT_SSE2) || defined(FASTFLOAT_NEON)
+#define FASTFLOAT_HAS_SIMD 1
+#endif
+
+#if defined(__GNUC__)
+// disable -Wcast-align=strict (GCC only)
+#define FASTFLOAT_SIMD_DISABLE_WARNINGS                                        \
+  _Pragma("GCC diagnostic push")                                               \
+      _Pragma("GCC diagnostic ignored \"-Wcast-align\"")
+#else
+#define FASTFLOAT_SIMD_DISABLE_WARNINGS
+#endif
+
+#if defined(__GNUC__)
+#define FASTFLOAT_SIMD_RESTORE_WARNINGS _Pragma("GCC diagnostic pop")
+#else
+#define FASTFLOAT_SIMD_RESTORE_WARNINGS
+#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)                                                    \
+  { ((void)(x)); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+#define FASTFLOAT_DEBUG_ASSERT(x)                                              \
+  { ((void)(x)); }
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x)                                                       \
+  {                                                                            \
+    if (!(x))                                                                  \
+      return false;                                                            \
+  }
+
+#define FASTFLOAT_ENABLE_IF(...)                                               \
+  typename std::enable_if<(__VA_ARGS__), int>::type
+
+namespace fast_float {
+
+fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() {
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED
+  return std::is_constant_evaluated();
+#else
+  return false;
+#endif
+}
+
+template <typename T>
+struct is_supported_float_type
+    : std::integral_constant<
+          bool, std::is_same<T, double>::value || std::is_same<T, float>::value
+#ifdef __STDCPP_FLOAT64_T__
+                    || std::is_same<T, std::float64_t>::value
+#endif
+#ifdef __STDCPP_FLOAT32_T__
+                    || std::is_same<T, std::float32_t>::value
+#endif
+#ifdef __STDCPP_FLOAT16_T__
+                    || std::is_same<T, std::float16_t>::value
+#endif
+#ifdef __STDCPP_BFLOAT16_T__
+                    || std::is_same<T, std::bfloat16_t>::value
+#endif
+          > {
+};
+
+template <typename T>
+using equiv_uint_t = typename std::conditional<
+    sizeof(T) == 1, uint8_t,
+    typename std::conditional<
+        sizeof(T) == 2, uint16_t,
+        typename std::conditional<sizeof(T) == 4, uint32_t,
+                                  uint64_t>::type>::type>::type;
+
+template <typename T> struct is_supported_integer_type : std::is_integral<T> {};
+
+template <typename UC>
+struct is_supported_char_type
+    : std::integral_constant<bool, std::is_same<UC, char>::value ||
+                                       std::is_same<UC, wchar_t>::value ||
+                                       std::is_same<UC, char16_t>::value ||
+                                       std::is_same<UC, char32_t>::value
+#ifdef __cpp_char8_t
+                                       || std::is_same<UC, char8_t>::value
+#endif
+                             > {
+};
+
+// Compares two ASCII strings in a case insensitive manner.
+template <typename UC>
+inline FASTFLOAT_CONSTEXPR14 bool
+fastfloat_strncasecmp(UC const *actual_mixedcase, UC const *expected_lowercase,
+                      size_t length) {
+  for (size_t i = 0; i < length; ++i) {
+    UC const actual = actual_mixedcase[i];
+    if ((actual < 256 ? actual | 32 : actual) != expected_lowercase[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+#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 {
+  T const *ptr;
+  size_t length;
+
+  constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {}
+
+  constexpr span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept { return length; }
+
+  FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
+
+struct value128 {
+  uint64_t low;
+  uint64_t high;
+
+  constexpr value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+
+  constexpr value128() : low(0), high(0) {}
+};
+
+/* Helper C++14 constexpr generic implementation of leading_zeroes */
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 int
+leading_zeroes_generic(uint64_t input_num, 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;
+}
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 int
+leading_zeroes(uint64_t input_num) {
+  assert(input_num > 0);
+  if (cpp20_and_in_constexpr()) {
+    return leading_zeroes_generic(input_num);
+  }
+#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
+  return leading_zeroes_generic(input_num);
+#endif
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline constexpr uint64_t emulu(uint32_t x, uint32_t y) {
+  return x * (uint64_t)y;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t
+umul128_generic(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 = (uint64_t)(adbc < ad);
+  uint64_t lo = bd + (adbc << 32);
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+        (adbc_carry << 32) + (uint64_t)(lo < bd);
+  return lo;
+}
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t _umul128(uint64_t ab,
+                                                                uint64_t cd,
+                                                                uint64_t *hi) {
+  return umul128_generic(ab, cd, hi);
+}
+#endif // !__MINGW64__
+
+#endif // FASTFLOAT_32BIT
+
+// compute 64-bit a*b
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 value128
+full_multiplication(uint64_t a, uint64_t b) {
+  if (cpp20_and_in_constexpr()) {
+    value128 answer;
+    answer.low = umul128_generic(a, b, &answer.high);
+    return answer;
+  }
+  value128 answer;
+#if defined(_M_ARM64) && !defined(__MINGW32__)
+  // ARM64 has native support for 64-bit multiplications, no need to emulate
+  // But MinGW on ARM64 doesn't have native support for 64-bit multiplications
+  answer.high = __umulh(a, b);
+  answer.low = a * b;
+#elif defined(FASTFLOAT_32BIT) ||                                              \
+    (defined(_WIN64) && !defined(__clang__) && !defined(_M_ARM64))
+  answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__)
+  __uint128_t r = ((__uint128_t)a) * b;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+#else
+  answer.low = umul128_generic(a, b, &answer.high);
+#endif
+  return answer;
+}
+
+struct adjusted_mantissa {
+  uint64_t mantissa{0};
+  int32_t power2{0}; // a negative value indicates an invalid result
+  adjusted_mantissa() = default;
+
+  constexpr bool operator==(adjusted_mantissa const &o) const {
+    return mantissa == o.mantissa && power2 == o.power2;
+  }
+
+  constexpr bool operator!=(adjusted_mantissa const &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;
+
+// used for binary_format_lookup_tables<T>::max_mantissa
+constexpr uint64_t constant_55555 = 5 * 5 * 5 * 5 * 5;
+
+template <typename T, typename U = void> struct binary_format_lookup_tables;
+
+template <typename T> struct binary_format : binary_format_lookup_tables<T> {
+  using equiv_uint = equiv_uint_t<T>;
+
+  static constexpr int mantissa_explicit_bits();
+  static constexpr int minimum_exponent();
+  static constexpr int infinite_power();
+  static constexpr int sign_index();
+  static constexpr int
+  min_exponent_fast_path(); // used when fegetround() == FE_TONEAREST
+  static constexpr int max_exponent_fast_path();
+  static constexpr int max_exponent_round_to_even();
+  static constexpr int min_exponent_round_to_even();
+  static constexpr uint64_t max_mantissa_fast_path(int64_t power);
+  static constexpr uint64_t
+  max_mantissa_fast_path(); // used when fegetround() == FE_TONEAREST
+  static constexpr int largest_power_of_ten();
+  static constexpr int smallest_power_of_ten();
+  static constexpr T exact_power_of_ten(int64_t power);
+  static constexpr size_t max_digits();
+  static constexpr equiv_uint exponent_mask();
+  static constexpr equiv_uint mantissa_mask();
+  static constexpr equiv_uint hidden_bit_mask();
+};
+
+template <typename U> struct binary_format_lookup_tables<double, U> {
+  static constexpr double powers_of_ten[] = {
+      1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+      1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
+  // Largest integer value v so that (5**index * v) <= 1<<53.
+  // 0x20000000000000 == 1 << 53
+  static constexpr uint64_t max_mantissa[] = {
+      0x20000000000000,
+      0x20000000000000 / 5,
+      0x20000000000000 / (5 * 5),
+      0x20000000000000 / (5 * 5 * 5),
+      0x20000000000000 / (5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555),
+      0x20000000000000 / (constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * 5 * 5 * 5 * 5),
+      0x20000000000000 /
+          (constant_55555 * constant_55555 * constant_55555 * constant_55555),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5),
+      0x20000000000000 / (constant_55555 * constant_55555 * constant_55555 *
+                          constant_55555 * 5 * 5 * 5 * 5)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr double binary_format_lookup_tables<double, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<double, U>::max_mantissa[];
+
+#endif
+
+template <typename U> struct binary_format_lookup_tables<float, U> {
+  static constexpr float powers_of_ten[] = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f,
+                                            1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
+
+  // Largest integer value v so that (5**index * v) <= 1<<24.
+  // 0x1000000 == 1<<24
+  static constexpr uint64_t max_mantissa[] = {
+      0x1000000,
+      0x1000000 / 5,
+      0x1000000 / (5 * 5),
+      0x1000000 / (5 * 5 * 5),
+      0x1000000 / (5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555),
+      0x1000000 / (constant_55555 * 5),
+      0x1000000 / (constant_55555 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * 5 * 5 * 5 * 5),
+      0x1000000 / (constant_55555 * constant_55555),
+      0x1000000 / (constant_55555 * constant_55555 * 5)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr float binary_format_lookup_tables<float, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t binary_format_lookup_tables<float, U>::max_mantissa[];
+
+#endif
+
+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>::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>::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();
+}
+
+// credit: Jakub Jelínek
+#ifdef __STDCPP_FLOAT16_T__
+template <typename U> struct binary_format_lookup_tables<std::float16_t, U> {
+  static constexpr std::float16_t powers_of_ten[] = {1e0f16, 1e1f16, 1e2f16,
+                                                     1e3f16, 1e4f16};
+
+  // Largest integer value v so that (5**index * v) <= 1<<11.
+  // 0x800 == 1<<11
+  static constexpr uint64_t max_mantissa[] = {0x800,
+                                              0x800 / 5,
+                                              0x800 / (5 * 5),
+                                              0x800 / (5 * 5 * 5),
+                                              0x800 / (5 * 5 * 5 * 5),
+                                              0x800 / (constant_55555)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr std::float16_t
+    binary_format_lookup_tables<std::float16_t, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t
+    binary_format_lookup_tables<std::float16_t, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr std::float16_t
+binary_format<std::float16_t>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::exponent_mask() {
+  return 0x7C00;
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::mantissa_mask() {
+  return 0x03FF;
+}
+
+template <>
+inline constexpr binary_format<std::float16_t>::equiv_uint
+binary_format<std::float16_t>::hidden_bit_mask() {
+  return 0x0400;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::max_exponent_fast_path() {
+  return 4;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::mantissa_explicit_bits() {
+  return 10;
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::float16_t>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::float16_t>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 4
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::min_exponent_fast_path() {
+  return 0;
+}
+
+template <>
+inline constexpr int
+binary_format<std::float16_t>::max_exponent_round_to_even() {
+  return 5;
+}
+
+template <>
+inline constexpr int
+binary_format<std::float16_t>::min_exponent_round_to_even() {
+  return -22;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::minimum_exponent() {
+  return -15;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::infinite_power() {
+  return 0x1F;
+}
+
+template <> inline constexpr int binary_format<std::float16_t>::sign_index() {
+  return 15;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::largest_power_of_ten() {
+  return 4;
+}
+
+template <>
+inline constexpr int binary_format<std::float16_t>::smallest_power_of_ten() {
+  return -27;
+}
+
+template <>
+inline constexpr size_t binary_format<std::float16_t>::max_digits() {
+  return 22;
+}
+#endif // __STDCPP_FLOAT16_T__
+
+// credit: Jakub Jelínek
+#ifdef __STDCPP_BFLOAT16_T__
+template <typename U> struct binary_format_lookup_tables<std::bfloat16_t, U> {
+  static constexpr std::bfloat16_t powers_of_ten[] = {1e0bf16, 1e1bf16, 1e2bf16,
+                                                      1e3bf16};
+
+  // Largest integer value v so that (5**index * v) <= 1<<8.
+  // 0x100 == 1<<8
+  static constexpr uint64_t max_mantissa[] = {0x100, 0x100 / 5, 0x100 / (5 * 5),
+                                              0x100 / (5 * 5 * 5),
+                                              0x100 / (5 * 5 * 5 * 5)};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename U>
+constexpr std::bfloat16_t
+    binary_format_lookup_tables<std::bfloat16_t, U>::powers_of_ten[];
+
+template <typename U>
+constexpr uint64_t
+    binary_format_lookup_tables<std::bfloat16_t, U>::max_mantissa[];
+
+#endif
+
+template <>
+inline constexpr std::bfloat16_t
+binary_format<std::bfloat16_t>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::max_exponent_fast_path() {
+  return 3;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::exponent_mask() {
+  return 0x7F80;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::mantissa_mask() {
+  return 0x007F;
+}
+
+template <>
+inline constexpr binary_format<std::bfloat16_t>::equiv_uint
+binary_format<std::bfloat16_t>::hidden_bit_mask() {
+  return 0x0080;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::mantissa_explicit_bits() {
+  return 7;
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::bfloat16_t>::max_mantissa_fast_path() {
+  return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<std::bfloat16_t>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 3
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::min_exponent_fast_path() {
+  return 0;
+}
+
+template <>
+inline constexpr int
+binary_format<std::bfloat16_t>::max_exponent_round_to_even() {
+  return 3;
+}
+
+template <>
+inline constexpr int
+binary_format<std::bfloat16_t>::min_exponent_round_to_even() {
+  return -24;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::minimum_exponent() {
+  return -127;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::infinite_power() {
+  return 0xFF;
+}
+
+template <> inline constexpr int binary_format<std::bfloat16_t>::sign_index() {
+  return 15;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::largest_power_of_ten() {
+  return 38;
+}
+
+template <>
+inline constexpr int binary_format<std::bfloat16_t>::smallest_power_of_ten() {
+  return -60;
+}
+
+template <>
+inline constexpr size_t binary_format<std::bfloat16_t>::max_digits() {
+  return 98;
+}
+#endif // __STDCPP_BFLOAT16_T__
+
+template <>
+inline constexpr uint64_t
+binary_format<double>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 22
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr uint64_t
+binary_format<float>::max_mantissa_fast_path(int64_t power) {
+  // caller is responsible to ensure that
+  // power >= 0 && power <= 10
+  //
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)max_mantissa[0], max_mantissa[power];
+}
+
+template <>
+inline constexpr double
+binary_format<double>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[power];
+}
+
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+  // Work around clang bug https://godbolt.org/z/zedh7rrhc
+  return (void)powers_of_ten[0], powers_of_ten[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 -64;
+}
+
+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 FASTFLOAT_CONSTEXPR20 void
+to_float(bool negative, adjusted_mantissa am, T &value) {
+  using equiv_uint = equiv_uint_t<T>;
+  equiv_uint word = equiv_uint(am.mantissa);
+  word = equiv_uint(word | equiv_uint(am.power2)
+                               << binary_format<T>::mantissa_explicit_bits());
+  word =
+      equiv_uint(word | equiv_uint(negative) << binary_format<T>::sign_index());
+#if FASTFLOAT_HAS_BIT_CAST
+  value = std::bit_cast<T>(word);
+#else
+  ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+template <typename = void> struct space_lut {
+  static constexpr bool value[] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr bool space_lut<T>::value[];
+
+#endif
+
+template <typename UC> constexpr bool is_space(UC c) {
+  return c < 256 && space_lut<>::value[uint8_t(c)];
+}
+
+template <typename UC> static constexpr uint64_t int_cmp_zeros() {
+  static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4),
+                "Unsupported character size");
+  return (sizeof(UC) == 1) ? 0x3030303030303030
+         : (sizeof(UC) == 2)
+             ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 |
+                uint64_t(UC('0')) << 16 | UC('0'))
+             : (uint64_t(UC('0')) << 32 | UC('0'));
+}
+
+template <typename UC> static constexpr int int_cmp_len() {
+  return sizeof(uint64_t) / sizeof(UC);
+}
+
+template <typename UC> constexpr UC const *str_const_nan();
+
+template <> constexpr char const *str_const_nan<char>() { return "nan"; }
+
+template <> constexpr wchar_t const *str_const_nan<wchar_t>() { return L"nan"; }
+
+template <> constexpr char16_t const *str_const_nan<char16_t>() {
+  return u"nan";
+}
+
+template <> constexpr char32_t const *str_const_nan<char32_t>() {
+  return U"nan";
+}
+
+#ifdef __cpp_char8_t
+template <> constexpr char8_t const *str_const_nan<char8_t>() {
+  return u8"nan";
+}
+#endif
+
+template <typename UC> constexpr UC const *str_const_inf();
+
+template <> constexpr char const *str_const_inf<char>() { return "infinity"; }
+
+template <> constexpr wchar_t const *str_const_inf<wchar_t>() {
+  return L"infinity";
+}
+
+template <> constexpr char16_t const *str_const_inf<char16_t>() {
+  return u"infinity";
+}
+
+template <> constexpr char32_t const *str_const_inf<char32_t>() {
+  return U"infinity";
+}
+
+#ifdef __cpp_char8_t
+template <> constexpr char8_t const *str_const_inf<char8_t>() {
+  return u8"infinity";
+}
+#endif
+
+template <typename = void> struct int_luts {
+  static constexpr uint8_t chdigit[] = {
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   255, 255,
+      255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,
+      35,  255, 255, 255, 255, 255, 255, 10,  11,  12,  13,  14,  15,  16,  17,
+      18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,
+      33,  34,  35,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      255};
+
+  static constexpr size_t maxdigits_u64[] = {
+      64, 41, 32, 28, 25, 23, 22, 21, 20, 19, 18, 18, 17, 17, 16, 16, 16, 16,
+      15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13};
+
+  static constexpr uint64_t min_safe_u64[] = {
+      9223372036854775808ull,  12157665459056928801ull, 4611686018427387904,
+      7450580596923828125,     4738381338321616896,     3909821048582988049,
+      9223372036854775808ull,  12157665459056928801ull, 10000000000000000000ull,
+      5559917313492231481,     2218611106740436992,     8650415919381337933,
+      2177953337809371136,     6568408355712890625,     1152921504606846976,
+      2862423051509815793,     6746640616477458432,     15181127029874798299ull,
+      1638400000000000000,     3243919932521508681,     6221821273427820544,
+      11592836324538749809ull, 876488338465357824,      1490116119384765625,
+      2481152873203736576,     4052555153018976267,     6502111422497947648,
+      10260628712958602189ull, 15943230000000000000ull, 787662783788549761,
+      1152921504606846976,     1667889514952984961,     2386420683693101056,
+      3379220508056640625,     4738381338321616896};
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint8_t int_luts<T>::chdigit[];
+
+template <typename T> constexpr size_t int_luts<T>::maxdigits_u64[];
+
+template <typename T> constexpr uint64_t int_luts<T>::min_safe_u64[];
+
+#endif
+
+template <typename UC>
+fastfloat_really_inline constexpr uint8_t ch_to_digit(UC c) {
+  return int_luts<>::chdigit[static_cast<unsigned char>(c)];
+}
+
+fastfloat_really_inline constexpr size_t max_digits_u64(int base) {
+  return int_luts<>::maxdigits_u64[base - 2];
+}
+
+// If a u64 is exactly max_digits_u64() in length, this is
+// the value below which it has definitely overflowed.
+fastfloat_really_inline constexpr uint64_t min_safe_u64(int base) {
+  return int_luts<>::min_safe_u64[base - 2];
+}
+
+static_assert(std::is_same<equiv_uint_t<double>, uint64_t>::value,
+              "equiv_uint should be uint64_t for double");
+static_assert(std::numeric_limits<double>::is_iec559,
+              "double must fulfill the requirements of IEC 559 (IEEE 754)");
+
+static_assert(std::is_same<equiv_uint_t<float>, uint32_t>::value,
+              "equiv_uint should be uint32_t for float");
+static_assert(std::numeric_limits<float>::is_iec559,
+              "float must fulfill the requirements of IEC 559 (IEEE 754)");
+
+#ifdef __STDCPP_FLOAT64_T__
+static_assert(std::is_same<equiv_uint_t<std::float64_t>, uint64_t>::value,
+              "equiv_uint should be uint64_t for std::float64_t");
+static_assert(
+    std::numeric_limits<std::float64_t>::is_iec559,
+    "std::float64_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT64_T__
+
+#ifdef __STDCPP_FLOAT32_T__
+static_assert(std::is_same<equiv_uint_t<std::float32_t>, uint32_t>::value,
+              "equiv_uint should be uint32_t for std::float32_t");
+static_assert(
+    std::numeric_limits<std::float32_t>::is_iec559,
+    "std::float32_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT32_T__
+
+#ifdef __STDCPP_FLOAT16_T__
+static_assert(
+    std::is_same<binary_format<std::float16_t>::equiv_uint, uint16_t>::value,
+    "equiv_uint should be uint16_t for std::float16_t");
+static_assert(
+    std::numeric_limits<std::float16_t>::is_iec559,
+    "std::float16_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_FLOAT16_T__
+
+#ifdef __STDCPP_BFLOAT16_T__
+static_assert(
+    std::is_same<binary_format<std::bfloat16_t>::equiv_uint, uint16_t>::value,
+    "equiv_uint should be uint16_t for std::bfloat16_t");
+static_assert(
+    std::numeric_limits<std::bfloat16_t>::is_iec559,
+    "std::bfloat16_t must fulfill the requirements of IEC 559 (IEEE 754)");
+#endif // __STDCPP_BFLOAT16_T__
+
+constexpr chars_format operator~(chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(~static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator&(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) &
+                                   static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator|(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) |
+                                   static_cast<int_type>(rhs));
+}
+
+constexpr chars_format operator^(chars_format lhs, chars_format rhs) noexcept {
+  using int_type = std::underlying_type<chars_format>::type;
+  return static_cast<chars_format>(static_cast<int_type>(lhs) ^
+                                   static_cast<int_type>(rhs));
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 chars_format &
+operator&=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs & rhs);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 chars_format &
+operator|=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs | rhs);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 chars_format &
+operator^=(chars_format &lhs, chars_format rhs) noexcept {
+  return lhs = (lhs ^ rhs);
+}
+
+namespace detail {
+// adjust for deprecated feature macros
+constexpr chars_format adjust_for_feature_macros(chars_format fmt) {
+  return fmt
+#ifdef FASTFLOAT_ALLOWS_LEADING_PLUS
+         | chars_format::allow_leading_plus
+#endif
+#ifdef FASTFLOAT_SKIP_WHITE_SPACE
+         | chars_format::skip_white_space
+#endif
+      ;
+}
+} // namespace detail
+
+} // namespace fast_float
+
+#endif
+
+
+#ifndef FASTFLOAT_FAST_FLOAT_H
+#define FASTFLOAT_FAST_FLOAT_H
+
+
+namespace fast_float {
+/**
+ * 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 allow
+ * the fixed point and scientific notation respectively. The default is
+ * `fast_float::chars_format::general` which allows both `fixed` and
+ * `scientific`.
+ */
+template <typename T, typename UC = char,
+          typename = FASTFLOAT_ENABLE_IF(is_supported_float_type<T>::value)>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt = chars_format::general) noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ * Both for floating-point types and integer types.
+ */
+template <typename T, typename UC = char>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept;
+
+/**
+ * from_chars for integer types.
+ */
+template <typename T, typename UC = char,
+          typename = FASTFLOAT_ENABLE_IF(is_supported_integer_type<T>::value)>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base = 10) noexcept;
+
+} // namespace fast_float
+
+#endif // FASTFLOAT_FAST_FLOAT_H
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+//included above:
+//#include <cctype>
+//included above:
+//#include <cstdint>
+//included above:
+//#include <cstring>
+#include <iterator>
+//included above:
+//#include <limits>
+//included above:
+//#include <type_traits>
+
+
+#ifdef FASTFLOAT_SSE2
+#include <emmintrin.h>
+#endif
+
+#ifdef FASTFLOAT_NEON
+#include <arm_neon.h>
+#endif
+
+namespace fast_float {
+
+template <typename UC> fastfloat_really_inline constexpr bool has_simd_opt() {
+#ifdef FASTFLOAT_HAS_SIMD
+  return std::is_same<UC, char16_t>::value;
+#else
+  return false;
+#endif
+}
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+template <typename UC>
+fastfloat_really_inline constexpr bool is_integer(UC c) noexcept {
+  return !(c > UC('9') || c < UC('0'));
+}
+
+fastfloat_really_inline constexpr 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;
+}
+
+// Read 8 UC into a u64. Truncates UC if not char.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+read8_to_u64(UC const *chars) {
+  if (cpp20_and_in_constexpr() || !std::is_same<UC, char>::value) {
+    uint64_t val = 0;
+    for (int i = 0; i < 8; ++i) {
+      val |= uint64_t(uint8_t(*chars)) << (i * 8);
+      ++chars;
+    }
+    return val;
+  }
+  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;
+}
+
+#ifdef FASTFLOAT_SSE2
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(__m128i const data) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  __m128i const packed = _mm_packus_epi16(data, data);
+#ifdef FASTFLOAT_64BIT
+  return uint64_t(_mm_cvtsi128_si64(packed));
+#else
+  uint64_t value;
+  // Visual Studio + older versions of GCC don't support _mm_storeu_si64
+  _mm_storel_epi64(reinterpret_cast<__m128i *>(&value), packed);
+  return value;
+#endif
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(char16_t const *chars) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      _mm_loadu_si128(reinterpret_cast<__m128i const *>(chars)));
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#elif defined(FASTFLOAT_NEON)
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(uint16x8_t const data) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  uint8x8_t utf8_packed = vmovn_u16(data);
+  return vget_lane_u64(vreinterpret_u64_u8(utf8_packed), 0);
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+fastfloat_really_inline uint64_t simd_read8_to_u64(char16_t const *chars) {
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  return simd_read8_to_u64(
+      vld1q_u16(reinterpret_cast<uint16_t const *>(chars)));
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+}
+
+#endif // FASTFLOAT_SSE2
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+uint64_t simd_read8_to_u64(UC const *) {
+  return 0;
+}
+
+// credit  @aqrit
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint32_t
+parse_eight_digits_unrolled(uint64_t val) {
+  uint64_t const mask = 0x000000FF000000FF;
+  uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+  uint64_t const 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);
+}
+
+// Call this if chars are definitely 8 digits.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint32_t
+parse_eight_digits_unrolled(UC const *chars) noexcept {
+  if (cpp20_and_in_constexpr() || !has_simd_opt<UC>()) {
+    return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay
+  }
+  return parse_eight_digits_unrolled(simd_read8_to_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline constexpr bool
+is_made_of_eight_digits_fast(uint64_t val) noexcept {
+  return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+            0x8080808080808080));
+}
+
+#ifdef FASTFLOAT_HAS_SIMD
+
+// Call this if chars might not be 8 digits.
+// Using this style (instead of is_made_of_eight_digits_fast() then
+// parse_eight_digits_unrolled()) ensures we don't load SIMD registers twice.
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+simd_parse_if_eight_digits_unrolled(char16_t const *chars,
+                                    uint64_t &i) noexcept {
+  if (cpp20_and_in_constexpr()) {
+    return false;
+  }
+#ifdef FASTFLOAT_SSE2
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  __m128i const data =
+      _mm_loadu_si128(reinterpret_cast<__m128i const *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  __m128i const t0 = _mm_add_epi16(data, _mm_set1_epi16(32720));
+  __m128i const t1 = _mm_cmpgt_epi16(t0, _mm_set1_epi16(-32759));
+
+  if (_mm_movemask_epi8(t1) == 0) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+#elif defined(FASTFLOAT_NEON)
+  FASTFLOAT_SIMD_DISABLE_WARNINGS
+  uint16x8_t const data = vld1q_u16(reinterpret_cast<uint16_t const *>(chars));
+
+  // (x - '0') <= 9
+  // http://0x80.pl/articles/simd-parsing-int-sequences.html
+  uint16x8_t const t0 = vsubq_u16(data, vmovq_n_u16('0'));
+  uint16x8_t const mask = vcltq_u16(t0, vmovq_n_u16('9' - '0' + 1));
+
+  if (vminvq_u16(mask) == 0xFFFF) {
+    i = i * 100000000 + parse_eight_digits_unrolled(simd_read8_to_u64(data));
+    return true;
+  } else
+    return false;
+  FASTFLOAT_SIMD_RESTORE_WARNINGS
+#else
+  (void)chars;
+  (void)i;
+  return false;
+#endif // FASTFLOAT_SSE2
+}
+
+#endif // FASTFLOAT_HAS_SIMD
+
+// MSVC SFINAE is broken pre-VS2017
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+template <typename UC>
+#else
+template <typename UC, FASTFLOAT_ENABLE_IF(!has_simd_opt<UC>()) = 0>
+#endif
+// dummy for compile
+bool simd_parse_if_eight_digits_unrolled(UC const *, uint64_t &) {
+  return 0;
+}
+
+template <typename UC, FASTFLOAT_ENABLE_IF(!std::is_same<UC, char>::value) = 0>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(UC const *&p, UC const *const pend, uint64_t &i) {
+  if (!has_simd_opt<UC>()) {
+    return;
+  }
+  while ((std::distance(p, pend) >= 8) &&
+         simd_parse_if_eight_digits_unrolled(
+             p, i)) { // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+loop_parse_if_eight_digits(char const *&p, char const *const pend,
+                           uint64_t &i) {
+  // optimizes better than parse_if_eight_digits_unrolled() for UC = char.
+  while ((std::distance(p, pend) >= 8) &&
+         is_made_of_eight_digits_fast(read8_to_u64(p))) {
+    i = i * 100000000 +
+        parse_eight_digits_unrolled(read8_to_u64(
+            p)); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
+}
+
+enum class parse_error {
+  no_error,
+  // [JSON-only] The minus sign must be followed by an integer.
+  missing_integer_after_sign,
+  // A sign must be followed by an integer or dot.
+  missing_integer_or_dot_after_sign,
+  // [JSON-only] The integer part must not have leading zeros.
+  leading_zeros_in_integer_part,
+  // [JSON-only] The integer part must have at least one digit.
+  no_digits_in_integer_part,
+  // [JSON-only] If there is a decimal point, there must be digits in the
+  // fractional part.
+  no_digits_in_fractional_part,
+  // The mantissa must have at least one digit.
+  no_digits_in_mantissa,
+  // Scientific notation requires an exponential part.
+  missing_exponential_part,
+};
+
+template <typename UC> struct parsed_number_string_t {
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  UC const *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  span<UC const> integer{};  // non-nullable
+  span<UC const> fraction{}; // nullable
+  parse_error error{parse_error::no_error};
+};
+
+using byte_span = span<char const>;
+using parsed_number_string = parsed_number_string_t<char>;
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+report_parse_error(UC const *p, parse_error error) {
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.lastmatch = p;
+  answer.error = error;
+  return answer;
+}
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 parsed_number_string_t<UC>
+parse_number_string(UC const *p, UC const *pend,
+                    parse_options_t<UC> options) noexcept {
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  UC const decimal_point = options.decimal_point;
+
+  parsed_number_string_t<UC> answer;
+  answer.valid = false;
+  answer.too_many_digits = false;
+  // assume p < pend, so dereference without checks;
+  answer.negative = (*p == UC('-'));
+  // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+  if ((*p == UC('-')) ||
+      (uint64_t(fmt & chars_format::allow_leading_plus) &&
+       !uint64_t(fmt & detail::basic_json_fmt) && *p == UC('+'))) {
+    ++p;
+    if (p == pend) {
+      return report_parse_error<UC>(
+          p, parse_error::missing_integer_or_dot_after_sign);
+    }
+    if (uint64_t(fmt & detail::basic_json_fmt)) {
+      if (!is_integer(*p)) { // a sign must be followed by an integer
+        return report_parse_error<UC>(p,
+                                      parse_error::missing_integer_after_sign);
+      }
+    } else {
+      if (!is_integer(*p) &&
+          (*p !=
+           decimal_point)) { // a sign must be followed by an integer or the dot
+        return report_parse_error<UC>(
+            p, parse_error::missing_integer_or_dot_after_sign);
+      }
+    }
+  }
+  UC const *const start_digits = p;
+
+  uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+  while ((p != pend) && is_integer(*p)) {
+    // a multiplication by 10 is cheaper than an arbitrary integer
+    // multiplication
+    i = 10 * i +
+        uint64_t(*p -
+                 UC('0')); // might overflow, we will handle the overflow later
+    ++p;
+  }
+  UC const *const end_of_integer_part = p;
+  int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = span<UC const>(start_digits, size_t(digit_count));
+  if (uint64_t(fmt & detail::basic_json_fmt)) {
+    // at least 1 digit in integer part, without leading zeros
+    if (digit_count == 0) {
+      return report_parse_error<UC>(p, parse_error::no_digits_in_integer_part);
+    }
+    if ((start_digits[0] == UC('0') && digit_count > 1)) {
+      return report_parse_error<UC>(start_digits,
+                                    parse_error::leading_zeros_in_integer_part);
+    }
+  }
+
+  int64_t exponent = 0;
+  bool const has_decimal_point = (p != pend) && (*p == decimal_point);
+  if (has_decimal_point) {
+    ++p;
+    UC const *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.
+    loop_parse_if_eight_digits(p, pend, i);
+
+    while ((p != pend) && is_integer(*p)) {
+      uint8_t digit = uint8_t(*p - UC('0'));
+      ++p;
+      i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+    }
+    exponent = before - p;
+    answer.fraction = span<UC const>(before, size_t(p - before));
+    digit_count -= exponent;
+  }
+  if (uint64_t(fmt & detail::basic_json_fmt)) {
+    // at least 1 digit in fractional part
+    if (has_decimal_point && exponent == 0) {
+      return report_parse_error<UC>(p,
+                                    parse_error::no_digits_in_fractional_part);
+    }
+  } else if (digit_count ==
+             0) { // we must have encountered at least one integer!
+    return report_parse_error<UC>(p, parse_error::no_digits_in_mantissa);
+  }
+  int64_t exp_number = 0; // explicit exponential part
+  if ((uint64_t(fmt & chars_format::scientific) && (p != pend) &&
+       ((UC('e') == *p) || (UC('E') == *p))) ||
+      (uint64_t(fmt & detail::basic_fortran_fmt) && (p != pend) &&
+       ((UC('+') == *p) || (UC('-') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)))) {
+    UC const *location_of_e = p;
+    if ((UC('e') == *p) || (UC('E') == *p) || (UC('d') == *p) ||
+        (UC('D') == *p)) {
+      ++p;
+    }
+    bool neg_exp = false;
+    if ((p != pend) && (UC('-') == *p)) {
+      neg_exp = true;
+      ++p;
+    } else if ((p != pend) &&
+               (UC('+') ==
+                *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+      ++p;
+    }
+    if ((p == pend) || !is_integer(*p)) {
+      if (!uint64_t(fmt & chars_format::fixed)) {
+        // The exponential part is invalid for scientific notation, so it must
+        // be a trailing token for fixed notation. However, fixed notation is
+        // disabled, so report a scientific notation error.
+        return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+      }
+      // Otherwise, we will be ignoring the 'e'.
+      p = location_of_e;
+    } else {
+      while ((p != pend) && is_integer(*p)) {
+        uint8_t digit = uint8_t(*p - UC('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 (uint64_t(fmt & chars_format::scientific) &&
+        !uint64_t(fmt & chars_format::fixed)) {
+      return report_parse_error<UC>(p, parse_error::missing_exponential_part);
+    }
+  }
+  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.
+    UC const *start = start_digits;
+    while ((start != pend) && (*start == UC('0') || *start == decimal_point)) {
+      if (*start == UC('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;
+      UC const *int_end = p + answer.integer.len();
+      uint64_t const minimal_nineteen_digit_integer{1000000000000000000};
+      while ((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+        i = i * 10 + uint64_t(*p - UC('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;
+        UC const *frac_end = p + answer.fraction.len();
+        while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+          i = i * 10 + uint64_t(*p - UC('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;
+}
+
+template <typename T, typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+parse_int_string(UC const *p, UC const *pend, T &value,
+                 parse_options_t<UC> options) {
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  int const base = options.base;
+
+  from_chars_result_t<UC> answer;
+
+  UC const *const first = p;
+
+  bool const negative = (*p == UC('-'));
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+  if (!std::is_signed<T>::value && negative) {
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#endif
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  if ((*p == UC('-')) ||
+      (uint64_t(fmt & chars_format::allow_leading_plus) && (*p == UC('+')))) {
+    ++p;
+  }
+
+  UC const *const start_num = p;
+
+  while (p != pend && *p == UC('0')) {
+    ++p;
+  }
+
+  bool const has_leading_zeros = p > start_num;
+
+  UC const *const start_digits = p;
+
+  uint64_t i = 0;
+  if (base == 10) {
+    loop_parse_if_eight_digits(p, pend, i); // use SIMD if possible
+  }
+  while (p != pend) {
+    uint8_t digit = ch_to_digit(*p);
+    if (digit >= base) {
+      break;
+    }
+    i = uint64_t(base) * i + digit; // might overflow, check this later
+    p++;
+  }
+
+  size_t digit_count = size_t(p - start_digits);
+
+  if (digit_count == 0) {
+    if (has_leading_zeros) {
+      value = 0;
+      answer.ec = std::errc();
+      answer.ptr = p;
+    } else {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+    }
+    return answer;
+  }
+
+  answer.ptr = p;
+
+  // check u64 overflow
+  size_t max_digits = max_digits_u64(base);
+  if (digit_count > max_digits) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+  // this check can be eliminated for all other types, but they will all require
+  // a max_digits(base) equivalent
+  if (digit_count == max_digits && i < min_safe_u64(base)) {
+    answer.ec = std::errc::result_out_of_range;
+    return answer;
+  }
+
+  // check other types overflow
+  if (!std::is_same<T, uint64_t>::value) {
+    if (i > uint64_t(std::numeric_limits<T>::max()) + uint64_t(negative)) {
+      answer.ec = std::errc::result_out_of_range;
+      return answer;
+    }
+  }
+
+  if (negative) {
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#endif
+    // this weird workaround is required because:
+    // - converting unsigned to signed when its value is greater than signed max
+    // is UB pre-C++23.
+    // - reinterpret_casting (~i + 1) would work, but it is not constexpr
+    // this is always optimized into a neg instruction (note: T is an integer
+    // type)
+    value = T(-std::numeric_limits<T>::max() -
+              T(i - uint64_t(std::numeric_limits<T>::max())));
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#endif
+  } else {
+    value = T(i);
+  }
+
+  answer.ec = std::errc();
+  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.
+  constexpr static uint64_t 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,
+  };
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <class unused>
+constexpr uint64_t
+    powers_template<unused>::power_of_five_128[number_of_entries];
+
+#endif
+
+using powers = powers_template<>;
+
+} // namespace fast_float
+
+#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 FASTFLOAT_CONSTEXPR20 value128
+compute_product_approximation(int64_t q, uint64_t w) {
+  int const 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 FASTFLOAT_CONSTEXPR14 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 FASTFLOAT_CONSTEXPR20 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);
+}
+
+// Computers w * 10 ** q.
+// The returned value should be a valid number that simply needs 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 FASTFLOAT_CONSTEXPR20 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);
+  // The computed 'product' is always sufficient.
+  // Mathematical proof:
+  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to
+  // appear) See script/mushtak_lemire.py
+
+  // 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);
+  int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3;
+
+  answer.mantissa = product.high >> shift;
+
+  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 in the 32-bit and
+    // and 64-bit case (with no more than 19 digits).
+    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 << shift) == 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 1
+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(stackvec const &) = delete;
+  stackvec &operator=(stackvec const &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
+    FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+
+  FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+
+  // index from the end of the container
+  FASTFLOAT_CONSTEXPR14 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.
+  FASTFLOAT_CONSTEXPR14 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
+  FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+
+  // append item to vector, returning if item was added
+  FASTFLOAT_CONSTEXPR14 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
+  FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
+    limb *ptr = data + length;
+    std::copy_n(s.ptr, s.len(), ptr);
+    set_len(len() + s.len());
+  }
+
+  // try to add items to the vector, returning if items were added
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20
+  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.
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR14 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.
+  FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 uint64_t
+empty_hi64(bool &truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 uint64_t
+uint64_hi64(uint64_t r0, bool &truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 uint64_t
+uint32_hi64(uint32_t r0, bool &truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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)
+  if (!cpp20_and_in_constexpr()) {
+    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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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>
+FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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>
+FASTFLOAT_CONSTEXPR20 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>
+FASTFLOAT_CONSTEXPR20 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;
+}
+
+template <typename = void> struct pow5_tables {
+  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
+};
+
+#if FASTFLOAT_DETAIL_MUST_DEFINE_CONSTEXPR_VARIABLE
+
+template <typename T> constexpr uint32_t pow5_tables<T>::large_step;
+
+template <typename T> constexpr uint64_t pow5_tables<T>::small_power_of_5[];
+
+template <typename T> constexpr limb pow5_tables<T>::large_power_of_5[];
+
+#endif
+
+// 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 : pow5_tables<> {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  FASTFLOAT_CONSTEXPR20 bigint() : vec() {}
+
+  bigint(bigint const &) = delete;
+  bigint &operator=(bigint const &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20 int compare(bigint const &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.
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20 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;
+      limb const *src = vec.data;
+      std::copy_backward(src, src + vec.len(), dst + 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.
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20 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.
+  FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); }
+
+  FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); }
+
+  // multiply as if by 2 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); }
+
+  // multiply as if by 5 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    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) {
+      // Work around clang bug https://godbolt.org/z/zedh7rrhc
+      // This is similar to https://github.com/llvm/llvm-project/issues/47746,
+      // except the workaround described there don't work here
+      FASTFLOAT_TRY(small_mul(
+          vec, limb(((void)small_power_of_5[0], small_power_of_5[exp]))));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
+    FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // 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.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 int32_t
+scientific_exponent(parsed_number_string_t<UC> &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 FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+to_extended(T value) noexcept {
+  using equiv_uint = equiv_uint_t<T>;
+  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;
+#if FASTFLOAT_HAS_BIT_CAST
+  bits = std::bit_cast<equiv_uint>(value);
+#else
+  ::memcpy(&bits, &value, sizeof(T));
+#endif
+  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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR14 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 FASTFLOAT_CONSTEXPR14 void
+round_nearest_tie_even(adjusted_mantissa &am, int32_t shift,
+                       callback cb) noexcept {
+  uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1;
+  uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1);
+  uint64_t truncated_bits = am.mantissa & mask;
+  bool is_above = truncated_bits > halfway;
+  bool 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 FASTFLOAT_CONSTEXPR14 void
+round_down(adjusted_mantissa &am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+skip_zeros(UC const *&first, UC const *last) noexcept {
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      break;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+is_truncated(UC const *first, UC const *last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (!cpp20_and_in_constexpr() &&
+         std::distance(first, last) >= int_cmp_len<UC>()) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != int_cmp_zeros<UC>()) {
+      return true;
+    }
+    first += int_cmp_len<UC>();
+  }
+  while (first != last) {
+    if (*first != UC('0')) {
+      return true;
+    }
+    ++first;
+  }
+  return false;
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 bool
+is_truncated(span<UC const> s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+parse_eight_digits(UC const *&p, limb &value, size_t &counter,
+                   size_t &count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+template <typename UC>
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14 void
+parse_one_digit(UC const *&p, limb &value, size_t &counter,
+                size_t &count) noexcept {
+  value = value * 10 + limb(*p - UC('0'));
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 void
+add_native(bigint &big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20 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
+template <typename UC>
+inline FASTFLOAT_CONSTEXPR20 void
+parse_mantissa(bigint &result, parsed_number_string_t<UC> &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.
+  UC const *p = num.integer.ptr;
+  UC const *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 FASTFLOAT_CONSTEXPR20 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 FASTFLOAT_CONSTEXPR20 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, typename UC>
+inline FASTFLOAT_CONSTEXPR20 adjusted_mantissa
+digit_comp(parsed_number_string_t<UC> &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, typename UC>
+from_chars_result_t<UC>
+    FASTFLOAT_CONSTEXPR14 parse_infnan(UC const *first, UC const *last,
+                                       T &value, chars_format fmt) noexcept {
+  from_chars_result_t<UC> answer{};
+  answer.ptr = first;
+  answer.ec = std::errc(); // be optimistic
+  // assume first < last, so dereference without checks;
+  bool const minusSign = (*first == UC('-'));
+  // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+  if ((*first == UC('-')) ||
+      (uint64_t(fmt & chars_format::allow_leading_plus) &&
+       (*first == UC('+')))) {
+    ++first;
+  }
+  if (last - first >= 3) {
+    if (fastfloat_strncasecmp(first, str_const_nan<UC>(), 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 == UC('(')) {
+        for (UC const *ptr = first + 1; ptr != last; ++ptr) {
+          if (*ptr == UC(')')) {
+            answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+            break;
+          } else if (!((UC('a') <= *ptr && *ptr <= UC('z')) ||
+                       (UC('A') <= *ptr && *ptr <= UC('Z')) ||
+                       (UC('0') <= *ptr && *ptr <= UC('9')) || *ptr == UC('_')))
+            break; // forbidden char, not nan(n-char-seq-opt)
+        }
+      }
+      return answer;
+    }
+    if (fastfloat_strncasecmp(first, str_const_inf<UC>(), 3)) {
+      if ((last - first >= 8) &&
+          fastfloat_strncasecmp(first + 3, str_const_inf<UC>() + 3, 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;
+}
+
+/**
+ * Returns true if the floating-pointing rounding mode is to 'nearest'.
+ * It is the default on most system. This function is meant to be inexpensive.
+ * Credit : @mwalcott3
+ */
+fastfloat_really_inline bool rounds_to_nearest() noexcept {
+  // https://lemire.me/blog/2020/06/26/gcc-not-nearest/
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return false;
+#endif
+  // See
+  // A fast function to check your floating-point rounding mode
+  // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
+  //
+  // This function is meant to be equivalent to :
+  // prior: #include <cfenv>
+  //  return fegetround() == FE_TONEAREST;
+  // However, it is expected to be much faster than the fegetround()
+  // function call.
+  //
+  // The volatile keyword prevents the compiler from computing the function
+  // at compile-time.
+  // There might be other ways to prevent compile-time optimizations (e.g.,
+  // asm). The value does not need to be std::numeric_limits<float>::min(), any
+  // small value so that 1 + x should round to 1 would do (after accounting for
+  // excess precision, as in 387 instructions).
+  static float volatile fmin = std::numeric_limits<float>::min();
+  float fmini = fmin; // we copy it so that it gets loaded at most once.
+//
+// Explanation:
+// Only when fegetround() == FE_TONEAREST do we have that
+// fmin + 1.0f == 1.0f - fmin.
+//
+// FE_UPWARD:
+//  fmin + 1.0f > 1
+//  1.0f - fmin == 1
+//
+// FE_DOWNWARD or  FE_TOWARDZERO:
+//  fmin + 1.0f == 1
+//  1.0f - fmin < 1
+//
+// Note: This may fail to be accurate if fast-math has been
+// enabled, as rounding conventions may not apply.
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(push)
+//  todo: is there a VS warning?
+//  see
+//  https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+  return (fmini + 1.0f == 1.0f - fmini);
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#pragma warning(pop)
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+}
+
+} // namespace detail
+
+template <typename T> struct from_chars_caller {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_advanced(first, last, value, options);
+  }
+};
+
+#ifdef __STDCPP_FLOAT32_T__
+template <> struct from_chars_caller<std::float32_t> {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float32_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float32_t is defined, and we are in C++23 mode; macro set for
+    // float32; set value to float due to equivalence between float and
+    // float32_t
+    float val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+#ifdef __STDCPP_FLOAT64_T__
+template <> struct from_chars_caller<std::float64_t> {
+  template <typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, std::float64_t &value,
+       parse_options_t<UC> options) noexcept {
+    // if std::float64_t is defined, and we are in C++23 mode; macro set for
+    // float64; set value as double due to equivalence between double and
+    // float64_t
+    double val;
+    auto ret = from_chars_advanced(first, last, val, options);
+    value = val;
+    return ret;
+  }
+};
+#endif
+
+template <typename T, typename UC, typename>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value,
+           chars_format fmt /*= chars_format::general*/) noexcept {
+  return from_chars_caller<T>::call(first, last, value,
+                                    parse_options_t<UC>(fmt));
+}
+
+/**
+ * This function overload takes parsed_number_string_t structure that is created
+ * and populated either by from_chars_advanced function taking chars range and
+ * parsing options or other parsing custom function implemented by user.
+ */
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(parsed_number_string_t<UC> &pns, T &value) noexcept {
+
+  static_assert(is_supported_float_type<T>::value,
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  from_chars_result_t<UC> answer;
+
+  answer.ec = std::errc(); // be optimistic
+  answer.ptr = pns.lastmatch;
+  // The implementation of the Clinger's fast path is convoluted because
+  // we want round-to-nearest in all cases, irrespective of the rounding mode
+  // selected on the thread.
+  // We proceed optimistically, assuming that detail::rounds_to_nearest()
+  // returns true.
+  if (binary_format<T>::min_exponent_fast_path() <= pns.exponent &&
+      pns.exponent <= binary_format<T>::max_exponent_fast_path() &&
+      !pns.too_many_digits) {
+    // Unfortunately, the conventional Clinger's fast path is only possible
+    // when the system rounds to the nearest float.
+    //
+    // We expect the next branch to almost always be selected.
+    // We could check it first (before the previous branch), but
+    // there might be performance advantages at having the check
+    // be last.
+    if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) {
+      // We have that fegetround() == FE_TONEAREST.
+      // Next is Clinger's fast path.
+      if (pns.mantissa <= binary_format<T>::max_mantissa_fast_path()) {
+        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;
+      }
+    } else {
+      // We do not have that fegetround() == FE_TONEAREST.
+      // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's
+      // proposal
+      if (pns.exponent >= 0 &&
+          pns.mantissa <=
+              binary_format<T>::max_mantissa_fast_path(pns.exponent)) {
+#if defined(__clang__) || defined(FASTFLOAT_32BIT)
+        // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD
+        if (pns.mantissa == 0) {
+          value = pns.negative ? T(-0.) : T(0.);
+          return answer;
+        }
+#endif
+        value = T(pns.mantissa) *
+                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);
+  // Test for over/underflow.
+  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
+      am.power2 == binary_format<T>::infinite_power()) {
+    answer.ec = std::errc::result_out_of_range;
+  }
+  return answer;
+}
+
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_float_advanced(UC const *first, UC const *last, T &value,
+                          parse_options_t<UC> options) noexcept {
+
+  static_assert(is_supported_float_type<T>::value,
+                "only some floating-point types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+
+  from_chars_result_t<UC> answer;
+  if (uint64_t(fmt & chars_format::skip_white_space)) {
+    while ((first != last) && fast_float::is_space(*first)) {
+      first++;
+    }
+  }
+  if (first == last) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+  parsed_number_string_t<UC> pns =
+      parse_number_string<UC>(first, last, options);
+  if (!pns.valid) {
+    if (uint64_t(fmt & chars_format::no_infnan)) {
+      answer.ec = std::errc::invalid_argument;
+      answer.ptr = first;
+      return answer;
+    } else {
+      return detail::parse_infnan(first, last, value, fmt);
+    }
+  }
+
+  // call overload that takes parsed_number_string_t directly.
+  return from_chars_advanced(pns, value);
+}
+
+template <typename T, typename UC, typename>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars(UC const *first, UC const *last, T &value, int base) noexcept {
+
+  static_assert(is_supported_integer_type<T>::value,
+                "only integer types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  parse_options_t<UC> options;
+  options.base = base;
+  return from_chars_advanced(first, last, value, options);
+}
+
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_int_advanced(UC const *first, UC const *last, T &value,
+                        parse_options_t<UC> options) noexcept {
+
+  static_assert(is_supported_integer_type<T>::value,
+                "only integer types are supported");
+  static_assert(is_supported_char_type<UC>::value,
+                "only char, wchar_t, char16_t and char32_t are supported");
+
+  chars_format const fmt = detail::adjust_for_feature_macros(options.format);
+  int const base = options.base;
+
+  from_chars_result_t<UC> answer;
+  if (uint64_t(fmt & chars_format::skip_white_space)) {
+    while ((first != last) && fast_float::is_space(*first)) {
+      first++;
+    }
+  }
+  if (first == last || base < 2 || base > 36) {
+    answer.ec = std::errc::invalid_argument;
+    answer.ptr = first;
+    return answer;
+  }
+
+  return parse_int_string(first, last, value, options);
+}
+
+template <size_t TypeIx> struct from_chars_advanced_caller {
+  static_assert(TypeIx > 0, "unsupported type");
+};
+
+template <> struct from_chars_advanced_caller<1> {
+  template <typename T, typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_float_advanced(first, last, value, options);
+  }
+};
+
+template <> struct from_chars_advanced_caller<2> {
+  template <typename T, typename UC>
+  FASTFLOAT_CONSTEXPR20 static from_chars_result_t<UC>
+  call(UC const *first, UC const *last, T &value,
+       parse_options_t<UC> options) noexcept {
+    return from_chars_int_advanced(first, last, value, options);
+  }
+};
+
+template <typename T, typename UC>
+FASTFLOAT_CONSTEXPR20 from_chars_result_t<UC>
+from_chars_advanced(UC const *first, UC const *last, T &value,
+                    parse_options_t<UC> options) noexcept {
+  return from_chars_advanced_caller<
+      size_t(is_supported_float_type<T>::value) +
+      2 * size_t(is_supported_integer_type<T>::value)>::call(first, last, value,
+                                                             options);
+}
+
+} // 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>
+
+// NOLINTBEGIN(cert-dcl58-cpp)
+
+// forward declarations for std::vector
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__) || defined(_MSC_VER)
+#if defined(_MSC_VER)
+__pragma(warning(push))
+__pragma(warning(disable : 4643))
+#endif
+namespace std {
+template<typename> class allocator;
+#ifdef _GLIBCXX_DEBUG
+inline namespace __debug {
+template<typename T, typename Alloc> class vector;
+}
+#else
+template<typename T, typename Alloc> class vector;
+#endif
+} // namespace std
+#if defined(_MSC_VER)
+__pragma(warning(pop))
+#endif
+#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
+
+// NOLINTEND(cert-dcl58-cpp)
+
+#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)
+// 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_ */
+
+//! @todo is there a fwd header in msvc?
+namespace std {
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4643) // Forward declaring 'char_traits' in namespace std is not permitted by the C++ Standard.
+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>>;
+C4_SUPPRESS_WARNING_MSVC_POP
+} /* namespace std */
+#else
+#error "unknown standard library"
+#endif
+
+namespace c4 {
+
+c4::substr to_substr(std::string &s) noexcept;
+c4::csubstr to_csubstr(std::string const& s) noexcept;
+
+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)
+
+// (amalgamate) this include is needed to work around
+// conditional includes in charconv.hpp
+#if (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L)) || (__cplusplus >= 201703L)
+#include <charconv>
+#endif
+
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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.
+ */
+
+// 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
+#   if (C4_CPP >= 17)
+#       if defined(_MSC_VER)
+#           if (C4_MSVC_VERSION >= C4_MSVC_VERSION_2019) // VS2017 and lower do not have these macros
+//included above:
+//#               include <charconv>
+#               define C4CORE_HAVE_STD_TOCHARS 1
+#               define C4CORE_HAVE_STD_FROMCHARS 0 // prefer fast_float with MSVC
+#               define C4CORE_HAVE_FAST_FLOAT 1
+#           else
+#               define C4CORE_HAVE_STD_TOCHARS 0
+#               define C4CORE_HAVE_STD_FROMCHARS 0
+#               define C4CORE_HAVE_FAST_FLOAT 1
+#           endif
+#       else
+#           if __has_include(<charconv>)
+//included above:
+//#               include <charconv>
+#               if defined(__cpp_lib_to_chars)
+#                   define C4CORE_HAVE_STD_TOCHARS 1
+#                   define C4CORE_HAVE_STD_FROMCHARS 0 // glibc uses fast_float internally
+#                   define C4CORE_HAVE_FAST_FLOAT 1
+#               else
+#                   define C4CORE_HAVE_STD_TOCHARS 0
+#                   define C4CORE_HAVE_STD_FROMCHARS 0
+#                   define C4CORE_HAVE_FAST_FLOAT 1
+#               endif
+#           else
+#               define C4CORE_HAVE_STD_TOCHARS 0
+#               define C4CORE_HAVE_STD_FROMCHARS 0
+#               define C4CORE_HAVE_FAST_FLOAT 1
+#           endif
+#       endif
+#   else
+#       define C4CORE_HAVE_STD_TOCHARS 0
+#       define C4CORE_HAVE_STD_FROMCHARS 0
+#       define C4CORE_HAVE_FAST_FLOAT 1
+#   endif
+#   if C4CORE_HAVE_FAST_FLOAT
+// 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_ */
+
+#   endif
+#elif (C4_CPP >= 17)
+#   define C4CORE_HAVE_FAST_FLOAT 0
+#   if defined(_MSC_VER)
+#       if (C4_MSVC_VERSION >= C4_MSVC_VERSION_2019) // VS2017 and lower do not have these macros
+//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
+#       if __has_include(<charconv>)
+//included above:
+//#           include <charconv>
+#           if defined(__cpp_lib_to_chars)
+#               define C4CORE_HAVE_STD_TOCHARS 1
+#               define C4CORE_HAVE_STD_FROMCHARS 1 // glibc uses fast_float internally
+#           else
+#               define C4CORE_HAVE_STD_TOCHARS 0
+#               define C4CORE_HAVE_STD_FROMCHARS 0
+#           endif
+#       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
+#   define C4CORE_HAVE_FAST_FLOAT 0
+#endif
+
+
+#if !C4CORE_HAVE_STD_FROMCHARS
+#include <cstdio>
+#endif
+
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   pragma warning(push)
+#   pragma warning(disable: 4996) // snprintf/scanf: this function or variable may be unsafe
+#   if C4_MSVC_VERSION != C4_MSVC_VERSION_2017
+#       pragma warning(disable: 4800) //'int': forcing value to bool 'true' or 'false' (performance warning)
+#   endif
+#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
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#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"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+#if defined(__clang__)
+#define C4_NO_UBSAN_IOVRFLW __attribute__((no_sanitize("signed-integer-overflow")))
+#elif defined(__GNUC__)
+#if __GNUC__ > 7
+#define C4_NO_UBSAN_IOVRFLW __attribute__((no_sanitize("signed-integer-overflow")))
+#else
+#define C4_NO_UBSAN_IOVRFLW
+#endif
+#else
+#define C4_NO_UBSAN_IOVRFLW
+#endif
+
+// NOLINTBEGIN(hicpp-signed-bitwise)
+
+namespace c4 {
+
+/** @defgroup doc_charconv Charconv utilities
+ *
+ * Lightweight, very fast generic type-safe wrappers for converting
+ * individual values to/from strings. These are the main generic
+ * functions:
+ *   - @ref doc_to_chars and its alias @ref xtoa(): implemented by calling @ref itoa() / @ref utoa() / @ref ftoa() / @ref dtoa() (or generically @ref xtoa())
+ *   - @ref doc_from_chars and its alias @ref atox(): implemented by calling @ref atoi() / @ref atou() / @ref atof() / @ref atod() (or generically @ref atox())
+ *   - @ref to_chars_sub()
+ *   - @ref from_chars_first()
+ *   - @ref xtoa() and @ref atox() are implemented in terms of @ref write_dec() / @ref read_dec() et al (see @ref doc_write / @ref doc_read())
+ *
+ * And also some modest brag is in order: these functions are really
+ * fast: faster even than C++17 `std::to_chars()` and
+ * `std::to_chars()`, and many dozens of times faster than the
+ * iostream abominations.
+ *
+ * For example, here are some benchmark comparisons for @ref
+ * doc_from_chars (link leads to the main project README, where these
+ * results are shown more systematically).
+ *
+ * <table>
+ * <caption id="atox-i64-results">atox,int64_t</caption>
+ * <tr><th>g++12, linux <th>Visual Studio 2019
+ * <tr><td> \image html linux-x86_64-gxx12.1-Release-c4core-bm-charconv-atox-mega_bytes_per_second-i64.png <td> \image html windows-x86_64-vs2019-Release-c4core-bm-charconv-atox-mega_bytes_per_second-i64.png
+ * </table>
+ *
+ * <table>
+ * <caption id="xtoa-i64-results">xtoa,int64_t</caption>
+ * <tr><th>g++12, linux <th>Visual Studio 2019
+ * <tr><td> \image html linux-x86_64-gxx12.1-Release-c4core-bm-charconv-xtoa-mega_bytes_per_second-i64.png <td> \image html windows-x86_64-vs2019-Release-c4core-bm-charconv-xtoa-mega_bytes_per_second-i64.png
+ * </table>
+ *
+ * To parse floating point, c4core uses
+ * [fastfloat](https://github.com/fastfloat/fast_float), which is
+ * extremely fast, by an even larger factor:
+ *
+ * <table>
+ * <caption id="atox-float-results">atox,float</caption>
+ * <tr><th>g++12, linux <th>Visual Studio 2019
+ * <tr><td> \image html linux-x86_64-gxx12.1-Release-c4core-bm-charconv-atof-mega_bytes_per_second-float.png <td> \image html windows-x86_64-vs2019-Release-c4core-bm-charconv-atof-mega_bytes_per_second-float.png
+ * </table>
+ *
+ * @{
+ */
+
+#if C4CORE_HAVE_STD_TOCHARS
+/** @warning Use only the symbol. Do not rely on the type or naked value of this enum. */
+typedef enum : std::underlying_type<std::chars_format>::type {
+    /** print the real number in floating point format (like %f) */
+    FTOA_FLOAT = static_cast<std::underlying_type<std::chars_format>::type>(std::chars_format::fixed),
+    /** print the real number in scientific format (like %e) */
+    FTOA_SCIENT = static_cast<std::underlying_type<std::chars_format>::type>(std::chars_format::scientific),
+    /** print the real number in flexible format (like %g) */
+    FTOA_FLEX = static_cast<std::underlying_type<std::chars_format>::type>(std::chars_format::general),
+    /** print the real number in hexadecimal format (like %a) */
+    FTOA_HEXA = static_cast<std::underlying_type<std::chars_format>::type>(std::chars_format::hex),
+} RealFormat_e;
+#else
+/** @warning Use only the symbol. Do not rely on the type or naked value of this enum. */
+typedef enum : char {
+    /** print the real number in floating point format (like %f) */
+    FTOA_FLOAT = 'f',
+    /** print the real number in scientific format (like %e) */
+    FTOA_SCIENT = 'e',
+    /** print the real number in flexible format (like %g) */
+    FTOA_FLEX = 'g',
+    /** print the real number in hexadecimal format (like %a) */
+    FTOA_HEXA = 'a',
+} RealFormat_e;
+#endif
+
+/** @cond dev */
+/** 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
+    };
+};
+/** @endcond */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   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
+
+/** @cond dev */
+namespace detail {
+
+/* python command to get the values below:
+def dec(v):
+    return str(v)
+for bits in (8, 16, 32, 64):
+    imin, imax, umax = (-(1 << (bits - 1))), (1 << (bits - 1)) - 1, (1 << bits) - 1
+    for vname, v in (("imin", imin), ("imax", imax), ("umax", umax)):
+        for f in (bin, oct, dec, hex):
+            print(f"{bits}b: {vname}={v} {f.__name__}: len={len(f(v)):2d}: {v} {f(v)}")
+*/
+
+// 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 num_bytes, bool is_signed> struct charconv_digits_;
+template<class T> using charconv_digits = charconv_digits_<sizeof(T), std::is_signed<T>::value>;
+
+template<> struct charconv_digits_<1u, true> // int8_t
+{
+    enum : size_t {
+        maxdigits_bin       = 1 + 2 + 8, // -128==-0b10000000
+        maxdigits_oct       = 1 + 2 + 3, // -128==-0o200
+        maxdigits_dec       = 1     + 3, // -128
+        maxdigits_hex       = 1 + 2 + 2, // -128==-0x80
+        maxdigits_bin_nopfx =         8, // -128==-0b10000000
+        maxdigits_oct_nopfx =         3, // -128==-0o200
+        maxdigits_dec_nopfx =         3, // -128
+        maxdigits_hex_nopfx =         2, // -128==-0x80
+    };
+    // min values without sign!
+    static constexpr csubstr min_value_dec() noexcept { return csubstr("128"); }
+    static constexpr csubstr min_value_hex() noexcept { return csubstr("80"); }
+    static constexpr csubstr min_value_oct() noexcept { return csubstr("200"); }
+    static constexpr csubstr min_value_bin() noexcept { return csubstr("10000000"); }
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("127"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 3) || (str.len == 3 && str[0] <= '1')); }
+};
+template<> struct charconv_digits_<1u, false> // uint8_t
+{
+    enum : size_t {
+        maxdigits_bin       = 2 + 8, // 255 0b11111111
+        maxdigits_oct       = 2 + 3, // 255 0o377
+        maxdigits_dec       =     3, // 255
+        maxdigits_hex       = 2 + 2, // 255 0xff
+        maxdigits_bin_nopfx =     8, // 255 0b11111111
+        maxdigits_oct_nopfx =     3, // 255 0o377
+        maxdigits_dec_nopfx =     3, // 255
+        maxdigits_hex_nopfx =     2, // 255 0xff
+    };
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("255"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 3) || (str.len == 3 && str[0] <= '3')); }
+};
+template<> struct charconv_digits_<2u, true> // int16_t
+{
+    enum : size_t {
+        maxdigits_bin       = 1 + 2 + 16, // -32768 -0b1000000000000000
+        maxdigits_oct       = 1 + 2 +  6, // -32768 -0o100000
+        maxdigits_dec       = 1     +  5, // -32768 -32768
+        maxdigits_hex       = 1 + 2 +  4, // -32768 -0x8000
+        maxdigits_bin_nopfx =         16, // -32768 -0b1000000000000000
+        maxdigits_oct_nopfx =          6, // -32768 -0o100000
+        maxdigits_dec_nopfx =          5, // -32768 -32768
+        maxdigits_hex_nopfx =          4, // -32768 -0x8000
+    };
+    // min values without sign!
+    static constexpr csubstr min_value_dec() noexcept { return csubstr("32768"); }
+    static constexpr csubstr min_value_hex() noexcept { return csubstr("8000"); }
+    static constexpr csubstr min_value_oct() noexcept { return csubstr("100000"); }
+    static constexpr csubstr min_value_bin() noexcept { return csubstr("1000000000000000"); }
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("32767"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 6)); }
+};
+template<> struct charconv_digits_<2u, false> // uint16_t
+{
+    enum : size_t {
+        maxdigits_bin       = 2 + 16, // 65535 0b1111111111111111
+        maxdigits_oct       = 2 +  6, // 65535 0o177777
+        maxdigits_dec       =      6, // 65535 65535
+        maxdigits_hex       = 2 +  4, // 65535 0xffff
+        maxdigits_bin_nopfx =     16, // 65535 0b1111111111111111
+        maxdigits_oct_nopfx =      6, // 65535 0o177777
+        maxdigits_dec_nopfx =      6, // 65535 65535
+        maxdigits_hex_nopfx =      4, // 65535 0xffff
+    };
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("65535"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 6) || (str.len == 6 && str[0] <= '1')); }
+};
+template<> struct charconv_digits_<4u, true> // int32_t
+{
+    enum : size_t {
+        maxdigits_bin       = 1 + 2 + 32, // len=35: -2147483648 -0b10000000000000000000000000000000
+        maxdigits_oct       = 1 + 2 + 11, // len=14: -2147483648 -0o20000000000
+        maxdigits_dec       = 1     + 10, // len=11: -2147483648 -2147483648
+        maxdigits_hex       = 1 + 2 +  8, // len=11: -2147483648 -0x80000000
+        maxdigits_bin_nopfx =         32, // len=35: -2147483648 -0b10000000000000000000000000000000
+        maxdigits_oct_nopfx =         11, // len=14: -2147483648 -0o20000000000
+        maxdigits_dec_nopfx =         10, // len=11: -2147483648 -2147483648
+        maxdigits_hex_nopfx =          8, // len=11: -2147483648 -0x80000000
+    };
+    // min values without sign!
+    static constexpr csubstr min_value_dec() noexcept { return csubstr("2147483648"); }
+    static constexpr csubstr min_value_hex() noexcept { return csubstr("80000000"); }
+    static constexpr csubstr min_value_oct() noexcept { return csubstr("20000000000"); }
+    static constexpr csubstr min_value_bin() noexcept { return csubstr("10000000000000000000000000000000"); }
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("2147483647"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 11) || (str.len == 11 && str[0] <= '1')); }
+};
+template<> struct charconv_digits_<4u, false> // uint32_t
+{
+    enum : size_t {
+        maxdigits_bin       = 2 + 32, // len=34: 4294967295 0b11111111111111111111111111111111
+        maxdigits_oct       = 2 + 11, // len=13: 4294967295 0o37777777777
+        maxdigits_dec       =     10, // len=10: 4294967295 4294967295
+        maxdigits_hex       = 2 +  8, // len=10: 4294967295 0xffffffff
+        maxdigits_bin_nopfx =     32, // len=34: 4294967295 0b11111111111111111111111111111111
+        maxdigits_oct_nopfx =     11, // len=13: 4294967295 0o37777777777
+        maxdigits_dec_nopfx =     10, // len=10: 4294967295 4294967295
+        maxdigits_hex_nopfx =      8, // len=10: 4294967295 0xffffffff
+    };
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("4294967295"); }
+    static constexpr bool is_oct_overflow(csubstr str) noexcept { return !((str.len < 11) || (str.len == 11 && str[0] <= '3')); }
+};
+template<> struct charconv_digits_<8u, true> // int64_t
+{
+    enum : size_t {
+        maxdigits_bin       = 1 + 2 + 64, // len=67: -9223372036854775808 -0b1000000000000000000000000000000000000000000000000000000000000000
+        maxdigits_oct       = 1 + 2 + 22, // len=25: -9223372036854775808 -0o1000000000000000000000
+        maxdigits_dec       = 1     + 19, // len=20: -9223372036854775808 -9223372036854775808
+        maxdigits_hex       = 1 + 2 + 16, // len=19: -9223372036854775808 -0x8000000000000000
+        maxdigits_bin_nopfx =         64, // len=67: -9223372036854775808 -0b1000000000000000000000000000000000000000000000000000000000000000
+        maxdigits_oct_nopfx =         22, // len=25: -9223372036854775808 -0o1000000000000000000000
+        maxdigits_dec_nopfx =         19, // len=20: -9223372036854775808 -9223372036854775808
+        maxdigits_hex_nopfx =         16, // len=19: -9223372036854775808 -0x8000000000000000
+    };
+    static constexpr csubstr min_value_dec() noexcept { return csubstr("9223372036854775808"); }
+    static constexpr csubstr min_value_hex() noexcept { return csubstr("8000000000000000"); }
+    static constexpr csubstr min_value_oct() noexcept { return csubstr("1000000000000000000000"); }
+    static constexpr csubstr min_value_bin() noexcept { return csubstr("1000000000000000000000000000000000000000000000000000000000000000"); }
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("9223372036854775807"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 22)); }
+};
+template<> struct charconv_digits_<8u, false> // uint64_t
+{
+    enum : size_t {
+        maxdigits_bin       = 2 + 64, // len=66: 18446744073709551615 0b1111111111111111111111111111111111111111111111111111111111111111
+        maxdigits_oct       = 2 + 22, // len=24: 18446744073709551615 0o1777777777777777777777
+        maxdigits_dec       =     20, // len=20: 18446744073709551615 18446744073709551615
+        maxdigits_hex       = 2 + 16, // len=18: 18446744073709551615 0xffffffffffffffff
+        maxdigits_bin_nopfx =     64, // len=66: 18446744073709551615 0b1111111111111111111111111111111111111111111111111111111111111111
+        maxdigits_oct_nopfx =     22, // len=24: 18446744073709551615 0o1777777777777777777777
+        maxdigits_dec_nopfx =     20, // len=20: 18446744073709551615 18446744073709551615
+        maxdigits_hex_nopfx =     16, // len=18: 18446744073709551615 0xffffffffffffffff
+    };
+    static constexpr csubstr max_value_dec() noexcept { return csubstr("18446744073709551615"); }
+    static constexpr bool    is_oct_overflow(csubstr str) noexcept { return !((str.len < 22) || (str.len == 22 && str[0] <= '1')); }
+};
+} // namespace detail
+
+// 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; } }
+
+/** @endcond */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_digits Get number of digits
+ *
+ * @note At first sight this code may look heavily branchy and
+ * therefore inefficient. However, measurements revealed this to be
+ * the fastest among the alternatives.
+ *
+ * @see https://github.com/biojppm/c4core/pull/77
+ *
+ * @{
+ */
+
+/** decimal digits for 8 bit integers */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE
+auto digits_dec(T v) noexcept
+    -> typename std::enable_if<sizeof(T) == 1u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    return ((v >= 100) ? 3u : ((v >= 10) ? 2u : 1u));
+}
+
+/** decimal digits for 16 bit integers */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE
+auto digits_dec(T v) noexcept
+    -> typename std::enable_if<sizeof(T) == 2u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    return ((v >= 10000) ? 5u : (v >= 1000) ? 4u : (v >= 100) ? 3u : (v >= 10) ? 2u : 1u);
+}
+
+/** decimal digits for 32 bit integers */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE
+auto digits_dec(T v) noexcept
+    -> typename std::enable_if<sizeof(T) == 4u, unsigned>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    return ((v >= 1000000000) ? 10u : (v >= 100000000) ? 9u : (v >= 10000000) ? 8u :
+            (v >= 1000000) ? 7u : (v >= 100000) ? 6u : (v >= 10000) ? 5u :
+            (v >= 1000) ? 4u : (v >= 100) ? 3u : (v >= 10) ? 2u : 1u);
+}
+
+/** decimal digits for 64 bit integers */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE
+auto digits_dec(T v) noexcept
+    -> typename std::enable_if<sizeof(T) == 8u, unsigned>::type
+{
+    // thanks @fargies!!!
+    // https://github.com/biojppm/c4core/pull/77#issuecomment-1063753568
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    if(v >= 1000000000) // 10
+    {
+        if(v >= 100000000000000) // 15 [15-20] range
+        {
+            if(v >= 100000000000000000) // 18 (15 + (20 - 15) / 2)
+            {
+                if((typename std::make_unsigned<T>::type)v >= 10000000000000000000u) // 20
+                    return 20u;
+                else
+                    return (v >= 1000000000000000000) ? 19u : 18u;
+            }
+            else if(v >= 10000000000000000) // 17
+                return 17u;
+            else
+                return(v >= 1000000000000000) ? 16u : 15u;
+        }
+        else if(v >= 1000000000000) // 13
+            return (v >= 10000000000000) ? 14u : 13u;
+        else if(v >= 100000000000) // 12
+            return 12;
+        else
+            return(v >= 10000000000) ? 11u : 10u;
+    }
+    else if(v >= 10000) // 5 [5-9] range
+    {
+        if(v >= 10000000) // 8
+            return (v >= 100000000) ? 9u : 8u;
+        else if(v >= 1000000) // 7
+            return 7;
+        else
+            return (v >= 100000) ? 6u : 5u;
+    }
+    else if(v >= 100)
+        return (v >= 1000) ? 4u : 3u;
+    else
+        return (v >= 10) ? 2u : 1u;
+}
+
+
+/** return the number of digits required to encode an hexadecimal number. */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE unsigned digits_hex(T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    return v ? 1u + (msb((typename std::make_unsigned<T>::type)v) >> 2u) : 1u;
+}
+
+/** return the number of digits required to encode a binary number. */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE unsigned digits_bin(T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    return v ? 1u + msb((typename std::make_unsigned<T>::type)v) : 1u;
+}
+
+/** return the number of digits required to encode an octal number. */
+template<class T>
+C4_CONSTEXPR14 C4_ALWAYS_INLINE unsigned digits_oct(T v_) noexcept
+{
+    // TODO: is there a better way?
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v_ >= 0);
+    using U = typename std::conditional<sizeof(T) <= sizeof(unsigned),
+                                        unsigned,
+                                        typename std::make_unsigned<T>::type>::type;
+    U v = (U) v_;  // safe because we require v_ >= 0 // NOLINT
+    uint32_t __n = 1;
+    enum : U {
+        __b2 = 64u,
+        __b3 = 64u * 8u,
+        __b4 = 64u * 8u * 8u,
+    };
+    while(true)
+	{
+        if(v < 8u)
+            return __n;
+        else if(v < __b2)
+            return __n + 1;
+        else if(v < __b3)
+            return __n + 2;
+        else if(v < __b4)
+            return __n + 3;
+        v /= (U) __b4;
+        __n += 4;
+	}
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+namespace detail {
+C4_INLINE_CONSTEXPR const char hexchars[] = "0123456789abcdef";
+C4_INLINE_CONSTEXPR const char digits0099[] =
+    "0001020304050607080910111213141516171819"
+    "2021222324252627282930313233343536373839"
+    "4041424344454647484950515253545556575859"
+    "6061626364656667686970717273747576777879"
+    "8081828384858687888990919293949596979899";
+} // namespace detail
+/** @endcond */
+
+C4_SUPPRESS_WARNING_GCC_PUSH
+C4_SUPPRESS_WARNING_GCC("-Warray-bounds")  // gcc has false positives here
+#if (defined(__GNUC__) && (__GNUC__ >= 7))
+C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc has false positives here
+#endif
+
+/** @defgroup doc_write_unchecked Write with known number of digits
+ *
+ * Writes a value without checking the buffer length with regards to
+ * the required number of digits to encode the value. It is the
+ * responsibility of the caller to ensure that the provided number of
+ * digits is enough to write the given value. Notwithstanding the
+ * name, assertions are liberally performed, so this code is safe.
+ *
+ * @{ */
+
+template<class T>
+C4_HOT C4_ALWAYS_INLINE
+void write_dec_unchecked(substr buf, T v, unsigned digits_v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    C4_ASSERT(buf.len >= digits_v);
+    C4_XASSERT(digits_v == digits_dec(v));
+    // in bm_xtoa: checkoncelog_singlediv_write2
+    while(v >= T(100))
+    {
+        T quo = v;
+        quo /= T(100);
+        const auto num = (v - quo * T(100)) << 1u; // NOLINT
+        v = quo;
+        buf.str[--digits_v] = detail::digits0099[num + 1];
+        buf.str[--digits_v] = detail::digits0099[num];
+    }
+    if(v >= T(10))
+    {
+        C4_ASSERT(digits_v == 2);
+        const auto num = v << 1u;
+        buf.str[1] = detail::digits0099[num + 1];
+        buf.str[0] = detail::digits0099[num];
+    }
+    else
+    {
+        C4_ASSERT(digits_v == 1);
+        buf.str[0] = (char)('0' + v);
+    }
+}
+
+
+template<class T>
+C4_HOT C4_ALWAYS_INLINE
+void write_hex_unchecked(substr buf, T v, unsigned digits_v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    C4_ASSERT(buf.len >= digits_v);
+    C4_XASSERT(digits_v == digits_hex(v));
+    do {
+        buf.str[--digits_v] = detail::hexchars[v & T(15)];
+        v >>= 4;
+    } while(v);
+    C4_ASSERT(digits_v == 0);
+}
+
+
+template<class T>
+C4_HOT C4_ALWAYS_INLINE
+void write_oct_unchecked(substr buf, T v, unsigned digits_v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    C4_ASSERT(buf.len >= digits_v);
+    C4_XASSERT(digits_v == digits_oct(v));
+    do {
+        buf.str[--digits_v] = (char)('0' + (v & T(7)));
+        v >>= 3;
+    } while(v);
+    C4_ASSERT(digits_v == 0);
+}
+
+
+template<class T>
+C4_HOT C4_ALWAYS_INLINE
+void write_bin_unchecked(substr buf, T v, unsigned digits_v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    C4_ASSERT(buf.len >= digits_v);
+    C4_XASSERT(digits_v == digits_bin(v));
+    do {
+        buf.str[--digits_v] = (char)('0' + (v & T(1)));
+        v >>= 1;
+    } while(v);
+    C4_ASSERT(digits_v == 0);
+}
+
+/** @} */ // write_unchecked
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_write Write a value
+ *
+ * Writes a value without checking the buffer length
+ * decimal number -- but asserting.
+ *
+ * @{ */
+
+/** 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
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the required size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_dec(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    unsigned digits = digits_dec(v);
+    if(C4_LIKELY(buf.len >= digits))
+        write_dec_unchecked(buf, v, digits);
+    return digits;
+}
+
+/** 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
+ * @note does not prefix with 0x
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the required size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_hex(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    unsigned digits = digits_hex(v);
+    if(C4_LIKELY(buf.len >= digits))
+        write_hex_unchecked(buf, v, digits);
+    return digits;
+}
+
+/** 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
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the required size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_oct(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    unsigned digits = digits_oct(v);
+    if(C4_LIKELY(buf.len >= digits))
+        write_oct_unchecked(buf, v, digits);
+    return digits;
+}
+
+/** 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
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the required size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_bin(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_ASSERT(v >= 0);
+    unsigned digits = digits_bin(v);
+    C4_ASSERT(digits > 0);
+    if(C4_LIKELY(buf.len >= digits))
+        write_bin_unchecked(buf, v, digits);
+    return digits;
+}
+
+
+/** @cond dev */
+namespace detail {
+template<class U> using NumberWriter = size_t (*)(substr, U);
+template<class T, NumberWriter<T> writer>
+size_t write_num_digits(substr buf, T v, size_t num_digits) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    const 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);
+    const size_t delta = static_cast<size_t>(num_digits - ret); // NOLINT
+    C4_ASSERT(ret + delta <= buf.len);
+    if(ret)
+        memmove(buf.str + delta, buf.str, ret);
+    if(delta)
+        memset(buf.str, '0', delta);
+    return num_digits;
+}
+} // namespace detail
+/** @endcond */
+
+
+/** 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 requires more than num_digits, then the number prevails. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_dec(substr buf, T val, size_t num_digits) noexcept
+{
+    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 requires more than num_digits, then the number prevails. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_hex(substr buf, T val, size_t num_digits) noexcept
+{
+    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 requires more than num_digits, then the number prevails. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_bin(substr buf, T val, size_t num_digits) noexcept
+{
+    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 requires more than num_digits, then the number prevails. */
+template<class T>
+C4_ALWAYS_INLINE size_t write_oct(substr buf, T val, size_t num_digits) noexcept
+{
+    return detail::write_num_digits<T, &write_oct<T>>(buf, val, num_digits);
+}
+
+/** @} */ // write
+
+C4_SUPPRESS_WARNING_GCC_POP
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+C4_SUPPRESS_WARNING_MSVC_PUSH
+C4_SUPPRESS_WARNING_MSVC(4365) // '=': conversion from 'int' to 'I', signed/unsigned mismatch
+
+/** @defgroup doc_read Read a value
+ *
+ * @{ */
+
+/** 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.
+ * @note the string must not be empty
+ * @note there is no check for overflow; the value wraps around
+ * in a way similar to the standard C/C++ overflow behavior.
+ * For example, `read_dec<int8_t>("128", &val)` returns true
+ * and val will be set to 0 because 127 is the max i8 value.
+ * @see overflows<T>() to find out if a number string overflows a type range
+ * @return true if the conversion was successful (no overflow check) */
+template<class I>
+C4_NO_UBSAN_IOVRFLW
+C4_ALWAYS_INLINE bool read_dec(csubstr s, I *C4_RESTRICT v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    C4_ASSERT(!s.empty());
+    *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 not be empty
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @note there is no check for overflow; the value wraps around
+ * in a way similar to the standard C/C++ overflow behavior.
+ * For example, `read_hex<int8_t>("80", &val)` returns true
+ * and val will be set to 0 because 7f is the max i8 value.
+ * @see overflows<T>() to find out if a number string overflows a type range
+ * @return true if the conversion was successful (no overflow check) */
+template<class I>
+C4_NO_UBSAN_IOVRFLW
+C4_ALWAYS_INLINE bool read_hex(csubstr s, I *C4_RESTRICT v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    C4_ASSERT(!s.empty());
+    *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 not be empty
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @note there is no check for overflow; the value wraps around
+ * in a way similar to the standard C/C++ overflow behavior.
+ * For example, `read_bin<int8_t>("10000000", &val)` returns true
+ * and val will be set to 0 because 1111111 is the max i8 value.
+ * @see overflows<T>() to find out if a number string overflows a type range
+ * @return true if the conversion was successful (no overflow check) */
+template<class I>
+C4_NO_UBSAN_IOVRFLW
+C4_ALWAYS_INLINE bool read_bin(csubstr s, I *C4_RESTRICT v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    C4_ASSERT(!s.empty());
+    *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 not be empty
+ * @note the string must be trimmed. Whitespace is not accepted.
+ * @note there is no check for overflow; the value wraps around
+ * in a way similar to the standard C/C++ overflow behavior.
+ * For example, `read_oct<int8_t>("200", &val)` returns true
+ * and val will be set to 0 because 177 is the max i8 value.
+ * @see overflows<T>() to find out if a number string overflows a type range
+ * @return true if the conversion was successful (no overflow check) */
+template<class I>
+C4_NO_UBSAN_IOVRFLW
+C4_ALWAYS_INLINE bool read_oct(csubstr s, I *C4_RESTRICT v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<I>::value);
+    C4_ASSERT(!s.empty());
+    *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;
+}
+
+/** @} */
+
+C4_SUPPRESS_WARNING_MSVC_POP
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wswitch-default")
+
+/** @cond dev */
+namespace detail {
+inline size_t _itoa2buf(substr buf, size_t pos, csubstr val) noexcept
+{
+    C4_ASSERT(pos < buf.len);
+    C4_ASSERT(pos + val.len <= buf.len);
+    C4_ASSERT(val.len > 0);
+    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) noexcept
+{
+    num_digits = num_digits > val.len ? num_digits - val.len : 0;
+    C4_ASSERT(num_digits + val.len <= buf.len);
+    for(size_t i = 0; i < num_digits; ++i)
+        _c4append('0');
+    return detail::_itoa2buf(buf, pos, val);
+}
+template<class I>
+C4_NO_INLINE size_t _itoadec2buf(substr buf) noexcept
+{
+    using digits_type = detail::charconv_digits<I>;
+    if(C4_UNLIKELY(buf.len < digits_type::maxdigits_dec))
+        return digits_type::maxdigits_dec;
+    buf.str[0] = '-';
+    return detail::_itoa2buf(buf, 1, digits_type::min_value_dec());
+}
+template<class I>
+C4_NO_INLINE size_t _itoa2buf(substr buf, I radix) noexcept
+{
+    using digits_type = detail::charconv_digits<I>;
+    size_t pos = 0;
+    if(C4_LIKELY(buf.len > 0))
+        buf.str[pos++] = '-';
+    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+    {
+    case I(10):
+        if(C4_UNLIKELY(buf.len < digits_type::maxdigits_dec))
+            return digits_type::maxdigits_dec;
+        pos =_itoa2buf(buf, pos, digits_type::min_value_dec());
+        break;
+    case I(16):
+        if(C4_UNLIKELY(buf.len < digits_type::maxdigits_hex))
+            return digits_type::maxdigits_hex;
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'x';
+        pos = _itoa2buf(buf, pos, digits_type::min_value_hex());
+        break;
+    case I( 2):
+        if(C4_UNLIKELY(buf.len < digits_type::maxdigits_bin))
+            return digits_type::maxdigits_bin;
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'b';
+        pos = _itoa2buf(buf, pos, digits_type::min_value_bin());
+        break;
+    case I( 8):
+        if(C4_UNLIKELY(buf.len < digits_type::maxdigits_oct))
+            return digits_type::maxdigits_oct;
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'o';
+        pos = _itoa2buf(buf, pos, digits_type::min_value_oct());
+        break;
+    }
+    return pos;
+}
+template<class I>
+C4_NO_INLINE size_t _itoa2buf(substr buf, I radix, size_t num_digits) noexcept
+{
+    using digits_type = detail::charconv_digits<I>;
+    size_t pos = 0;
+    size_t needed_digits = 0;
+    if(C4_LIKELY(buf.len > 0))
+        buf.str[pos++] = '-';
+    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+    {
+    case I(10):
+        // add 1 to account for -
+        needed_digits = num_digits+1 > digits_type::maxdigits_dec ? num_digits+1 : digits_type::maxdigits_dec;
+        if(C4_UNLIKELY(buf.len < needed_digits))
+            return needed_digits;
+        pos = _itoa2bufwithdigits(buf, pos, num_digits, digits_type::min_value_dec());
+        break;
+    case I(16):
+        // add 3 to account for -0x
+        needed_digits = num_digits+3 > digits_type::maxdigits_hex ? num_digits+3 : digits_type::maxdigits_hex;
+        if(C4_UNLIKELY(buf.len < needed_digits))
+            return needed_digits;
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'x';
+        pos = _itoa2bufwithdigits(buf, pos, num_digits, digits_type::min_value_hex());
+        break;
+    case I(2):
+        // add 3 to account for -0b
+        needed_digits = num_digits+3 > digits_type::maxdigits_bin ? num_digits+3 : digits_type::maxdigits_bin;
+        if(C4_UNLIKELY(buf.len < needed_digits))
+            return needed_digits;
+        C4_ASSERT(buf.len >= digits_type::maxdigits_bin);
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'b';
+        pos = _itoa2bufwithdigits(buf, pos, num_digits, digits_type::min_value_bin());
+        break;
+    case I(8):
+        // add 3 to account for -0o
+        needed_digits = num_digits+3 > digits_type::maxdigits_oct ? num_digits+3 : digits_type::maxdigits_oct;
+        if(C4_UNLIKELY(buf.len < needed_digits))
+            return needed_digits;
+        C4_ASSERT(buf.len >= digits_type::maxdigits_oct);
+        buf.str[pos++] = '0';
+        buf.str[pos++] = 'o';
+        pos = _itoa2bufwithdigits(buf, pos, num_digits, digits_type::min_value_oct());
+        break;
+    }
+    return pos;
+}
+} // namespace detail
+/** @endcond */
+
+
+/** @defgroup doc_itoa itoa: signed to chars
+ *
+ * @{ */
+
+/** convert an integral signed decimal to a string.
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t itoa(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    if(v >= T(0))
+    {
+        // write_dec() checks the buffer size, so no need to check here
+        return write_dec(buf, v);
+    }
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow, so treat the min as a special case
+    if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+    {
+        v = -v;
+        unsigned digits = digits_dec(v);
+        if(C4_LIKELY(buf.len >= digits + 1u))
+        {
+            buf.str[0] = '-';
+            write_dec_unchecked(buf.sub(1), v, digits);
+        }
+        return digits + 1u;
+    }
+    return detail::_itoadec2buf<T>(buf);
+}
+
+/** convert an integral signed integer to a string, using a specific
+ * radix. The radix must be 2, 8, 10 or 16.
+ *
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t itoa(substr buf, T v, T radix) noexcept
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
+    C4_SUPPRESS_WARNING_GCC_PUSH
+    #if (defined(__GNUC__) && (__GNUC__ >= 7))
+        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc has a false positive here
+    #endif
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow, so treat the min as a special case
+    if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+    {
+        unsigned pos = 0;
+        if(v < 0)
+        {
+            v = -v;
+            if(C4_LIKELY(buf.len > 0))
+                buf.str[pos] = '-';
+            ++pos;
+        }
+        unsigned digits = 0;
+        switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+        {
+        case T(10):
+            digits = digits_dec(v);
+            if(C4_LIKELY(buf.len >= pos + digits))
+                write_dec_unchecked(buf.sub(pos), v, digits);
+            break;
+        case T(16):
+            digits = digits_hex(v);
+            if(C4_LIKELY(buf.len >= pos + 2u + digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'x';
+                write_hex_unchecked(buf.sub(pos + 2), v, digits);
+            }
+            digits += 2u;
+            break;
+        case T(2):
+            digits = digits_bin(v);
+            if(C4_LIKELY(buf.len >= pos + 2u + digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'b';
+                write_bin_unchecked(buf.sub(pos + 2), v, digits);
+            }
+            digits += 2u;
+            break;
+        case T(8):
+            digits = digits_oct(v);
+            if(C4_LIKELY(buf.len >= pos + 2u + digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'o';
+                write_oct_unchecked(buf.sub(pos + 2), v, digits);
+            }
+            digits += 2u;
+            break;
+        }
+        return pos + digits;
+    }
+    C4_SUPPRESS_WARNING_GCC_POP
+    // 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, not accounting for radix
+ * prefix (0x,0o,0b). The @p radix must be 2, 8, 10 or 16.
+ *
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t itoa(substr buf, T v, T radix, size_t num_digits) noexcept
+{
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+    C4_ASSERT(radix == 2 || radix == 8 || radix == 10 || radix == 16);
+    C4_SUPPRESS_WARNING_GCC_PUSH
+    #if (defined(__GNUC__) && (__GNUC__ >= 7))
+        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc has a false positive here
+    #endif
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow, so treat the min as a special case
+    if(C4_LIKELY(v != std::numeric_limits<T>::min()))
+    {
+        unsigned pos = 0;
+        if(v < 0)
+        {
+            v = -v;
+            if(C4_LIKELY(buf.len > 0))
+                buf.str[pos] = '-';
+            ++pos;
+        }
+        unsigned total_digits = 0;
+        switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+        {
+        case T(10):
+            total_digits = digits_dec(v);
+            total_digits = pos + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+            if(C4_LIKELY(buf.len >= total_digits))
+                write_dec(buf.sub(pos), v, num_digits);
+            break;
+        case T(16):
+            total_digits = digits_hex(v);
+            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+            if(C4_LIKELY(buf.len >= total_digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'x';
+                write_hex(buf.sub(pos + 2), v, num_digits);
+            }
+            break;
+        case T(2):
+            total_digits = digits_bin(v);
+            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+            if(C4_LIKELY(buf.len >= total_digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'b';
+                write_bin(buf.sub(pos + 2), v, num_digits);
+            }
+            break;
+        case T(8):
+            total_digits = digits_oct(v);
+            total_digits = pos + 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+            if(C4_LIKELY(buf.len >= total_digits))
+            {
+                buf.str[pos + 0] = '0';
+                buf.str[pos + 1] = 'o';
+                write_oct(buf.sub(pos + 2), v, num_digits);
+            }
+            break;
+        }
+        return total_digits;
+    }
+    C4_SUPPRESS_WARNING_GCC_POP
+    // when T is the min value (eg i8: -128), negating it
+    // will overflow
+    return detail::_itoa2buf<T>(buf, radix, num_digits);
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_utoa utoa: unsigned to chars
+ *
+ * @{ */
+
+/** convert an integral unsigned decimal to a string.
+ *
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t utoa(substr buf, T v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    // write_dec() does the buffer length check, so no need to check here
+    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.
+ *
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t utoa(substr buf, T v, T radix) noexcept
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
+    unsigned digits = 0;
+    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+    {
+    case T(10):
+        digits = digits_dec(v);
+        if(C4_LIKELY(buf.len >= digits))
+            write_dec_unchecked(buf, v, digits);
+        break;
+    case T(16):
+        digits = digits_hex(v);
+        if(C4_LIKELY(buf.len >= digits+2u))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'x';
+            write_hex_unchecked(buf.sub(2), v, digits);
+        }
+        digits += 2u;
+        break;
+    case T(2):
+        digits = digits_bin(v);
+        if(C4_LIKELY(buf.len >= digits+2u))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'b';
+            write_bin_unchecked(buf.sub(2), v, digits);
+        }
+        digits += 2u;
+        break;
+    case T(8):
+        digits = digits_oct(v);
+        if(C4_LIKELY(buf.len >= digits+2u))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'o';
+            write_oct_unchecked(buf.sub(2), v, digits);
+        }
+        digits += 2u;
+        break;
+    }
+    return digits;
+}
+
+/** 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.
+ *
+ * @note the resulting string is NOT zero-terminated.
+ * @note it is ok to call this with an empty or too-small buffer;
+ * no writes will occur, and the needed size will be returned
+ * @return the number of characters required for the buffer. */
+template<class T>
+C4_ALWAYS_INLINE size_t utoa(substr buf, T v, T radix, size_t num_digits) noexcept
+{
+    C4_STATIC_ASSERT(std::is_unsigned<T>::value);
+    C4_ASSERT(radix == 10 || radix == 16 || radix == 2 || radix == 8);
+    unsigned total_digits = 0;
+    switch(radix) // NOLINT(hicpp-multiway-paths-covered)
+    {
+    case T(10):
+        total_digits = digits_dec(v);
+        total_digits = (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+        if(C4_LIKELY(buf.len >= total_digits))
+            write_dec(buf, v, num_digits);
+        break;
+    case T(16):
+        total_digits = digits_hex(v);
+        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+        if(C4_LIKELY(buf.len >= total_digits))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'x';
+            write_hex(buf.sub(2), v, num_digits);
+        }
+        break;
+    case T(2):
+        total_digits = digits_bin(v);
+        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+        if(C4_LIKELY(buf.len >= total_digits))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'b';
+            write_bin(buf.sub(2), v, num_digits);
+        }
+        break;
+    case T(8):
+        total_digits = digits_oct(v);
+        total_digits = 2u + (unsigned)(num_digits > total_digits ? num_digits : total_digits);
+        if(C4_LIKELY(buf.len >= total_digits))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'o';
+            write_oct(buf.sub(2), v, num_digits);
+        }
+        break;
+    }
+    return total_digits;
+}
+C4_SUPPRESS_WARNING_GCC_POP
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_atoi atoi: chars to signed
+ *
+ * @{ */
+
+/** Convert a trimmed string to a signed integral value. The input
+ * 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 and not octal (unlike the
+ * C/C++ convention). Every character in the input string is read for
+ * the conversion; the input string must not contain any leading or
+ * trailing whitespace.
+ *
+ * @return true if the conversion was successful.
+ *
+ * @note a positive sign is not accepted. ie, the string must not
+ * start with '+'
+ *
+ * @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 @ref doc_overflows and @ref
+ * doc_overflow_checked for overflow checking utilities.
+ *
+ * @see atoi_first() if the string is not trimmed to the value to read. */
+template<class T>
+C4_NO_UBSAN_IOVRFLW
+C4_ALWAYS_INLINE bool atoi(csubstr str, T * C4_RESTRICT v) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    C4_STATIC_ASSERT(std::is_signed<T>::value);
+
+    if(C4_UNLIKELY(str.len == 0))
+        return false;
+
+    C4_ASSERT(str.str[0] != '+');
+
+    T sign = 1;
+    size_t start = 0;
+    if(str.str[0] == '-')
+    {
+        if(C4_UNLIKELY(str.len == ++start))
+            return false;
+        sign = -1;
+    }
+
+    bool parsed_ok = true;
+    if(str.str[start] != '0') // this should be the common case, so put it first
+    {
+        parsed_ok = read_dec(str.sub(start), v);
+    }
+    else if(str.len > start + 1)
+    {
+        // starts with 0: is it 0x, 0o, 0b?
+        const char pfx = str.str[start + 1];
+        if(pfx == 'x' || pfx == 'X')
+            parsed_ok = str.len > start + 2 && read_hex(str.sub(start + 2), v);
+        else if(pfx == 'b' || pfx == 'B')
+            parsed_ok = str.len > start + 2 && read_bin(str.sub(start + 2), v);
+        else if(pfx == 'o' || pfx == 'O')
+            parsed_ok = str.len > start + 2 && read_oct(str.sub(start + 2), v);
+        else
+            parsed_ok = read_dec(str.sub(start + 1), v);
+    }
+    else
+    {
+        parsed_ok = read_dec(str.sub(start), v);
+    }
+    if(C4_LIKELY(parsed_ok))
+        *v *= sign;
+    return parsed_ok;
+}
+
+
+/** 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>
+C4_ALWAYS_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;
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_atou atou: chars to unsigned
+ *
+ * @{ */
+
+/** 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. See @ref
+ * doc_overflows and @ref doc_overflow_checked for overflow checking
+ * utilities.
+ *
+ * @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) noexcept
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+
+    if(C4_UNLIKELY(str.len == 0 || str.front() == '-'))
+        return false;
+
+    bool parsed_ok = true;
+    if(str.str[0] != '0')
+    {
+        parsed_ok = read_dec(str, v);
+    }
+    else
+    {
+        if(str.len > 1)
+        {
+            const char pfx = str.str[1];
+            if(pfx == 'x' || pfx == 'X')
+                parsed_ok = str.len > 2 && read_hex(str.sub(2), v);
+            else if(pfx == 'b' || pfx == 'B')
+                parsed_ok = str.len > 2 && read_bin(str.sub(2), v);
+            else if(pfx == 'o' || pfx == 'O')
+                parsed_ok = str.len > 2 && read_oct(str.sub(2), v);
+            else
+                parsed_ok = read_dec(str, v);
+        }
+        else
+        {
+            *v = 0; // we know the first character is 0
+        }
+    }
+    return parsed_ok;
+}
+
+
+/** 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>
+C4_ALWAYS_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;
+}
+
+
+/** @} */
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+namespace detail {
+inline bool check_overflow(csubstr str, csubstr limit) noexcept
+{
+    if(str.len != limit.len)
+        return str.len > limit.len;
+    for(size_t i = 0; i < limit.len; ++i)
+    {
+        if(str[i] < limit[i])
+            return false;
+        else if(str[i] > limit[i])
+            return true;
+    }
+    return false;
+}
+} // namespace detail
+/** @endcond */
+
+
+/** @defgroup doc_overflows overflows: does a number string overflow a type
+ *
+ * @{ */
+
+/** Test if the following string would overflow when converted to
+ * associated integral types; this function is dispatched with SFINAE
+ * to handle differently signed and unsigned types.
+ * @return true if number will overflow, false if it fits (or doesn't parse)
+ * @see doc_overflow_checked for format specifiers to enforce no-overflow reads
+ */
+template<class T>
+auto overflows(csubstr str) noexcept
+    -> typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+
+    if(C4_UNLIKELY(str.len == 0))
+    {
+        return false;
+    }
+    else if(str.str[0] == '0')
+    {
+        if (str.len == 1)
+            return false;
+        switch (str.str[1])
+        {
+            case 'x':
+            case 'X':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if (fno == csubstr::npos)
+                    return false;
+                return !(str.len <= fno + (sizeof(T) * 2));
+            }
+            case 'b':
+            case 'B':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if (fno == csubstr::npos)
+                    return false;
+                return !(str.len <= fno +(sizeof(T) * 8));
+            }
+            case 'o':
+            case 'O':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if(fno == csubstr::npos)
+                    return false;
+                return detail::charconv_digits<T>::is_oct_overflow(str.sub(fno));
+            }
+            default:
+            {
+                size_t fno = str.first_not_of('0', 1);
+                if(fno == csubstr::npos)
+                    return false;
+                return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::max_value_dec());
+            }
+        }
+    }
+    else if(C4_UNLIKELY(str[0] == '-'))
+    {
+        return true;
+    }
+    else
+    {
+        return detail::check_overflow(str, detail::charconv_digits<T>::max_value_dec());
+    }
+}
+
+
+/** Test if the following string would overflow when converted to
+ * associated integral types; this function is dispatched with SFINAE
+ * to handle differently signed and unsigned types.
+ *
+ * @return true if number will overflow, false if it fits (or doesn't parse)
+ * @see doc_overflow_checked for format specifiers to enforce no-overflow reads
+ */
+template<class T>
+auto overflows(csubstr str) noexcept
+    -> typename std::enable_if<std::is_signed<T>::value, bool>::type
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    if(C4_UNLIKELY(str.len == 0))
+        return false;
+    if(str.str[0] == '-')
+    {
+        if(str.str[1] == '0')
+        {
+            if(str.len == 2)
+                return false;
+            switch(str.str[2])
+            {
+                case 'x':
+                case 'X':
+                {
+                    size_t fno = str.first_not_of('0', 3);
+                    if (fno == csubstr::npos)
+                        return false;
+                    return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::min_value_hex());
+                }
+                case 'b':
+                case 'B':
+                {
+                    size_t fno = str.first_not_of('0', 3);
+                    if (fno == csubstr::npos)
+                        return false;
+                    return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::min_value_bin());
+                }
+                case 'o':
+                case 'O':
+                {
+                    size_t fno = str.first_not_of('0', 3);
+                    if(fno == csubstr::npos)
+                        return false;
+                    return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::min_value_oct());
+                }
+                default:
+                {
+                    size_t fno = str.first_not_of('0', 2);
+                    if(fno == csubstr::npos)
+                        return false;
+                    return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::min_value_dec());
+                }
+            }
+        }
+        else
+        {
+            return detail::check_overflow(str.sub(1), detail::charconv_digits<T>::min_value_dec());
+        }
+    }
+    else if(str.str[0] == '0')
+    {
+        if (str.len == 1)
+            return false;
+        switch(str.str[1])
+        {
+            case 'x':
+            case 'X':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if (fno == csubstr::npos)
+                    return false;
+                const size_t len = str.len - fno;
+                return !((len < sizeof (T) * 2) || (len == sizeof(T) * 2 && str[fno] <= '7'));
+            }
+            case 'b':
+            case 'B':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if (fno == csubstr::npos)
+                    return false;
+                return !(str.len <= fno + (sizeof(T) * 8 - 1));
+            }
+            case 'o':
+            case 'O':
+            {
+                size_t fno = str.first_not_of('0', 2);
+                if(fno == csubstr::npos)
+                    return false;
+                return detail::charconv_digits<T>::is_oct_overflow(str.sub(fno));
+            }
+            default:
+            {
+                size_t fno = str.first_not_of('0', 1);
+                if(fno == csubstr::npos)
+                    return false;
+                return detail::check_overflow(str.sub(fno), detail::charconv_digits<T>::max_value_dec());
+            }
+        }
+    }
+    else
+    {
+        return detail::check_overflow(str, detail::charconv_digits<T>::max_value_dec());
+    }
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+namespace detail {
+
+
+#if (!C4CORE_HAVE_STD_FROMCHARS)
+/** @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, formatting);
+    else if(precision == 0)
+        iret = snprintf(fmt, sizeof(fmt), "%%.%s%c", length_modifier, formatting);
+    else
+        iret = snprintf(fmt, sizeof(fmt), "%%.%d%s%c", precision, length_modifier, 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
+}
+#endif // (!C4CORE_HAVE_STD_FROMCHARS)
+
+
+#if (!C4CORE_HAVE_STD_FROMCHARS) && (!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 // (!C4CORE_HAVE_STD_FROMCHARS) && (!C4CORE_HAVE_FAST_FLOAT)
+
+
+#if C4CORE_HAVE_STD_TOCHARS
+template<class T>
+C4_ALWAYS_INLINE size_t rtoa(substr buf, T v, int precision=-1, RealFormat_e formatting=FTOA_FLEX) noexcept
+{
+    std::to_chars_result result;
+    size_t pos = 0;
+    if(formatting == FTOA_HEXA)
+    {
+        if(buf.len > size_t(2))
+        {
+            buf.str[0] = '0';
+            buf.str[1] = 'x';
+        }
+        pos += size_t(2);
+    }
+    if(precision == -1)
+        result = std::to_chars(buf.str + pos, buf.str + buf.len, v, (std::chars_format)formatting);
+    else
+        result = std::to_chars(buf.str + pos, buf.str + buf.len, v, (std::chars_format)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
+
+
+#if C4CORE_HAVE_FAST_FLOAT
+template<class T>
+C4_ALWAYS_INLINE bool scan_rhex(csubstr s, T *C4_RESTRICT val) noexcept
+{
+    C4_ASSERT(s.len > 0);
+    C4_ASSERT(s.str[0] != '-');
+    C4_ASSERT(s.str[0] != '+');
+    C4_ASSERT(!s.begins_with("0x"));
+    C4_ASSERT(!s.begins_with("0X"));
+    size_t pos = 0;
+    // integer part
+    for( ; pos < s.len; ++pos)
+    {
+        const char c = s.str[pos];
+        if(c >= '0' && c <= '9')
+            *val = *val * T(16) + T(c - '0');
+        else if(c >= 'a' && c <= 'f')
+            *val = *val * T(16) + T(c - 'a');
+        else if(c >= 'A' && c <= 'F')
+            *val = *val * T(16) + T(c - 'A');
+        else if(c == '.')
+        {
+            ++pos;
+            break; // follow on to mantissa
+        }
+        else if(c == 'p' || c == 'P')
+        {
+            ++pos;
+            goto power; // no mantissa given, jump to power // NOLINT
+        }
+        else
+        {
+            return false;
+        }
+    }
+    // mantissa
+    {
+        // 0.0625 == 1/16 == value of first digit after the comma
+        for(T digit = T(0.0625); pos < s.len; ++pos, digit /= T(16)) // NOLINT
+        {
+            const char c = s.str[pos];
+            if(c >= '0' && c <= '9')
+                *val += digit * T(c - '0');
+            else if(c >= 'a' && c <= 'f')
+                *val += digit * T(c - 'a');
+            else if(c >= 'A' && c <= 'F')
+                *val += digit * T(c - 'A');
+            else if(c == 'p' || c == 'P')
+            {
+                ++pos;
+                goto power; // mantissa finished, jump to power // NOLINT
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+power:
+    if(C4_LIKELY(pos < s.len))
+    {
+        if(s.str[pos] == '+') // atoi() cannot handle a leading '+'
+            ++pos;
+        if(C4_LIKELY(pos < s.len))
+        {
+            int16_t powval = {};
+            if(C4_LIKELY(atoi(s.sub(pos), &powval)))
+            {
+                *val *= ipow<T, int16_t, 16>(powval);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+#endif
+
+} // namespace detail
+/** @endcond */
+
+
+#undef _c4appendhex
+#undef _c4append
+
+
+/** @defgroup doc_ftoa ftoa: float32 to chars
+ *
+ * @{ */
+
+/** 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. It is safe to call this function with an empty
+ * or too-small buffer.
+ *
+ * @return the size of the buffer needed to write the number
+ */
+C4_ALWAYS_INLINE size_t ftoa(substr str, float v, int precision=-1, RealFormat_e formatting=FTOA_FLEX) noexcept
+{
+#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
+}
+
+/** @} */
+
+
+/** @defgroup doc_dtoa dtoa: float64 to chars
+ *
+ * @{ */
+
+/** 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. It is safe to call this function with an empty
+ * or too-small buffer.
+ *
+ * @return the size of the buffer needed to write the number
+ */
+C4_ALWAYS_INLINE size_t dtoa(substr str, double v, int precision=-1, RealFormat_e formatting=FTOA_FLEX) noexcept
+{
+#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
+}
+
+/** @} */
+
+
+/** @defgroup doc_atof atof: chars to float32
+ *
+ * @{ */
+
+/** 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
+ */
+C4_ALWAYS_INLINE bool atof(csubstr str, float * C4_RESTRICT v) noexcept
+{
+    C4_ASSERT(str.len > 0);
+    C4_ASSERT(str.triml(" \r\t\n").len == str.len);
+#if C4CORE_HAVE_FAST_FLOAT
+    // fastfloat cannot parse hexadecimal floats
+    bool isneg = (str.str[0] == '-');
+    csubstr rem = str.sub(isneg || str.str[0] == '+');
+    if(!(rem.len >= 2 && (rem.str[0] == '0' && (rem.str[1] == 'x' || rem.str[1] == 'X'))))
+    {
+        fast_float::from_chars_result result;
+        result = fast_float::from_chars(str.str, str.str + str.len, *v);
+        return result.ec == std::errc();
+    }
+    else if(detail::scan_rhex(rem.sub(2), v))
+    {
+        *v *= isneg ? -1.f : 1.f;
+        return true;
+    }
+    return false;
+#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
+    csubstr rem = str.sub(str.str[0] == '-' || str.str[0] == '+');
+    if(!(rem.len >= 2 && (rem.str[0] == '0' && (rem.str[1] == 'x' || rem.str[1] == 'X'))))
+        return detail::scan_one(str, "f", v) != csubstr::npos;
+    else
+        return detail::scan_one(str, "a", v) != 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) noexcept
+{
+    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;
+}
+
+/** @} */
+
+
+/** @defgroup doc_atod atod: chars to float64
+ *
+ * @{ */
+
+/** 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
+ */
+C4_ALWAYS_INLINE bool atod(csubstr str, double * C4_RESTRICT v) noexcept
+{
+    C4_ASSERT(str.len > 0);
+    C4_ASSERT(str.triml(" \r\t\n").len == str.len);
+#if C4CORE_HAVE_FAST_FLOAT
+    // fastfloat cannot parse hexadecimal floats
+    bool isneg = (str.str[0] == '-');
+    csubstr rem = str.sub(isneg || str.str[0] == '+');
+    if(!(rem.len >= 2 && (rem.str[0] == '0' && (rem.str[1] == 'x' || rem.str[1] == 'X'))))
+    {
+        fast_float::from_chars_result result;
+        result = fast_float::from_chars(str.str, str.str + str.len, *v);
+        return result.ec == std::errc();
+    }
+    else if(detail::scan_rhex(rem.sub(2), v))
+    {
+        *v *= isneg ? -1. : 1.;
+        return true;
+    }
+    return false;
+#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
+    csubstr rem = str.sub(str.str[0] == '-' || str.str[0] == '+');
+    if(!(rem.len >= 2 && (rem.str[0] == '0' && (rem.str[1] == 'x' || rem.str[1] == 'X'))))
+        return detail::scan_one(str, "lf", v) != csubstr::npos;
+    else
+        return detail::scan_one(str, "la", v) != csubstr::npos;
+#endif
+}
+
+
+/** 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) noexcept
+{
+    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
+
+/** @cond dev */
+// 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) 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) typename std::enable_if<std::is_unsigned<T>::value && !is_fixed_length<T>::value_u, ty>
+/** @endcond*/
+
+
+/** @defgroup doc_xtoa xtoa: generic value to chars
+ *
+ * Dispatches to the most appropriate and efficient conversion
+ * function
+ *
+ * @{ */
+C4_ALWAYS_INLINE size_t xtoa(substr s,  uint8_t v) noexcept { return write_dec(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint16_t v) noexcept { return write_dec(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint32_t v) noexcept { return write_dec(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint64_t v) noexcept { return write_dec(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   int8_t v) noexcept { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int16_t v) noexcept { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int32_t v) noexcept { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int64_t v) noexcept { return itoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,    float v) noexcept { return ftoa(s, v); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   double v) noexcept { return dtoa(s, v); }
+
+C4_ALWAYS_INLINE size_t xtoa(substr s,  uint8_t v,  uint8_t radix) noexcept { return utoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint16_t v, uint16_t radix) noexcept { return utoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint32_t v, uint32_t radix) noexcept { return utoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint64_t v, uint64_t radix) noexcept { return utoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   int8_t v,   int8_t radix) noexcept { return itoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int16_t v,  int16_t radix) noexcept { return itoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int32_t v,  int32_t radix) noexcept { return itoa(s, v, radix); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int64_t v,  int64_t radix) noexcept { return itoa(s, v, radix); }
+
+C4_ALWAYS_INLINE size_t xtoa(substr s,  uint8_t v,  uint8_t radix, size_t num_digits) noexcept { return utoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint16_t v, uint16_t radix, size_t num_digits) noexcept { return utoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint32_t v, uint32_t radix, size_t num_digits) noexcept { return utoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, uint64_t v, uint64_t radix, size_t num_digits) noexcept { return utoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,   int8_t v,   int8_t radix, size_t num_digits) noexcept { return itoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int16_t v,  int16_t radix, size_t num_digits) noexcept { return itoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int32_t v,  int32_t radix, size_t num_digits) noexcept { return itoa(s, v, radix, num_digits); }
+C4_ALWAYS_INLINE size_t xtoa(substr s,  int64_t v,  int64_t radix, size_t num_digits) noexcept { return itoa(s, v, radix, num_digits); }
+
+C4_ALWAYS_INLINE size_t xtoa(substr s,  float v, int precision, RealFormat_e formatting=FTOA_FLEX) noexcept { return ftoa(s, v, precision, formatting); }
+C4_ALWAYS_INLINE size_t xtoa(substr s, double v, int precision, RealFormat_e formatting=FTOA_FLEX) noexcept { return dtoa(s, v, precision, formatting); }
+
+template <class T> C4_ALWAYS_INLINE auto xtoa(substr buf, T v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type { return itoa(buf, v); }
+template <class T> C4_ALWAYS_INLINE auto xtoa(substr buf, T v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type { return write_dec(buf, v); }
+template <class T>
+C4_ALWAYS_INLINE size_t xtoa(substr s, T *v) noexcept { return itoa(s, (intptr_t)v, (intptr_t)16); }
+
+/** @} */
+
+/** @defgroup doc_atox atox: generic chars to value
+ *
+ * Dispatches to the most appropriate and efficient conversion
+ * function
+ *
+ * @{ */
+
+C4_ALWAYS_INLINE bool atox(csubstr s,  uint8_t *C4_RESTRICT v) noexcept { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint16_t *C4_RESTRICT v) noexcept { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint32_t *C4_RESTRICT v) noexcept { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s, uint64_t *C4_RESTRICT v) noexcept { return atou(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,   int8_t *C4_RESTRICT v) noexcept { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int16_t *C4_RESTRICT v) noexcept { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int32_t *C4_RESTRICT v) noexcept { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,  int64_t *C4_RESTRICT v) noexcept { return atoi(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,    float *C4_RESTRICT v) noexcept { return atof(s, v); }
+C4_ALWAYS_INLINE bool atox(csubstr s,   double *C4_RESTRICT v) noexcept { return atod(s, v); }
+
+template <class T> C4_ALWAYS_INLINE auto atox(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_I(T, bool)::type { return atoi(buf, v); }
+template <class T> C4_ALWAYS_INLINE auto atox(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_U(T, bool)::type { return atou(buf, v); }
+template <class T>
+C4_ALWAYS_INLINE bool atox(csubstr s, T **v) noexcept { intptr_t tmp; bool ret = atox(s, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+
+/** @} */
+
+
+/** @defgroup doc_to_chars to_chars: generalized chars to value
+ *
+ * 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.
+ *
+ * Dispatches to the most appropriate and efficient conversion
+ * function.
+ *
+ * @see write_dec, doc_utoa, doc_itoa, doc_ftoa, doc_dtoa
+ *
+ * @warning When serializing floating point values (float or double),
+ * be aware that because it uses defaults, to_chars() may cause a
+ * truncation of the precision. To enforce a particular precision, use
+ * for example @ref c4::fmt::real, or call directly @ref c4::ftoa or
+ * @ref c4::dtoa.
+ *
+ * @{ */
+
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  uint8_t v) noexcept { return write_dec(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint16_t v) noexcept { return write_dec(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint32_t v) noexcept { return write_dec(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf, uint64_t v) noexcept { return write_dec(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,   int8_t v) noexcept { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int16_t v) noexcept { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int32_t v) noexcept { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,  int64_t v) noexcept { return itoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,    float v) noexcept { return ftoa(buf, v); }
+C4_ALWAYS_INLINE size_t to_chars(substr buf,   double v) noexcept { return dtoa(buf, v); }
+
+template <class T> C4_ALWAYS_INLINE auto to_chars(substr buf, T v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type { return itoa(buf, v); }
+template <class T> C4_ALWAYS_INLINE auto to_chars(substr buf, T v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type { return write_dec(buf, v); }
+template <class T>
+C4_ALWAYS_INLINE size_t to_chars(substr s, T *v) noexcept { return itoa(s, (intptr_t)v, (intptr_t)16); }
+
+/** @} */
+
+
+/** @defgroup doc_from_chars from_chars: generalized chars to value
+ *
+ * Read a value from the string, which must be trimmed to the value
+ * (ie, no leading/trailing whitespace).  return true if the
+ * conversion succeeded.  There is no check for overflow; the value
+ * wraps around in a way similar to the standard C/C++ overflow
+ * behavior. For example, from_chars<int8_t>("128", &val) returns true
+ * and val will be set tot 0. See @ref doc_overflows and @ref
+ * doc_overflow_checked for facilities enforcing no-overflow.
+ *
+ * Dispatches to the most appropriate and efficient conversion
+ * function
+ *
+ * @see doc_from_chars_first, atou, atoi, atof, atod
+ * @{ */
+
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  uint8_t *C4_RESTRICT v) noexcept { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint16_t *C4_RESTRICT v) noexcept { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint32_t *C4_RESTRICT v) noexcept { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, uint64_t *C4_RESTRICT v) noexcept { return atou(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,   int8_t *C4_RESTRICT v) noexcept { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int16_t *C4_RESTRICT v) noexcept { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int32_t *C4_RESTRICT v) noexcept { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,  int64_t *C4_RESTRICT v) noexcept { return atoi(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,    float *C4_RESTRICT v) noexcept { return atof(buf, v); }
+C4_ALWAYS_INLINE bool from_chars(csubstr buf,   double *C4_RESTRICT v) noexcept { return atod(buf, v); }
+
+template <class T> C4_ALWAYS_INLINE auto from_chars(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_I(T, bool)::type { return atoi(buf, v); }
+template <class T> C4_ALWAYS_INLINE auto from_chars(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_U(T, bool)::type { return atou(buf, v); }
+template <class T>
+C4_ALWAYS_INLINE bool from_chars(csubstr buf, T **v) noexcept { intptr_t tmp; bool ret = from_chars(buf, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+
+/** @defgroup doc_from_chars_first from_chars_first: generalized chars to value
+ *
+ * Read the first valid sequence of characters from the string,
+ * skipping leading whitespace, and convert it using @ref doc_from_chars .
+ * Return the number of characters read for converting.
+ *
+ * Dispatches to the most appropriate and efficient conversion
+ * function.
+ *
+ * @see atou_first, atoi_first, atof_first, atod_first
+ * @{ */
+
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  uint8_t *C4_RESTRICT v) noexcept { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint16_t *C4_RESTRICT v) noexcept { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint32_t *C4_RESTRICT v) noexcept { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, uint64_t *C4_RESTRICT v) noexcept { return atou_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,   int8_t *C4_RESTRICT v) noexcept { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int16_t *C4_RESTRICT v) noexcept { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int32_t *C4_RESTRICT v) noexcept { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,  int64_t *C4_RESTRICT v) noexcept { return atoi_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,    float *C4_RESTRICT v) noexcept { return atof_first(buf, v); }
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf,   double *C4_RESTRICT v) noexcept { return atod_first(buf, v); }
+
+template <class T> C4_ALWAYS_INLINE auto from_chars_first(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_I(T, size_t)::type { return atoi_first(buf, v); }
+template <class T> C4_ALWAYS_INLINE auto from_chars_first(csubstr buf, T *C4_RESTRICT v) noexcept -> _C4_IF_NOT_FIXED_LENGTH_U(T, size_t)::type { return atou_first(buf, v); }
+template <class T>
+C4_ALWAYS_INLINE size_t from_chars_first(csubstr buf, T **v) noexcept { intptr_t tmp; bool ret = from_chars_first(buf, &tmp); if(ret) { *v = (T*)tmp; } return ret; }
+
+/** @} */
+
+/** @} */
+
+#undef _C4_IF_NOT_FIXED_LENGTH_I
+#undef _C4_IF_NOT_FIXED_LENGTH_U
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** 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.
+ * Convert the given value to a string using to_chars(), and
+ * return the resulting string, up to and including the last
+ * written character.
+ * @ingroup doc_to_chars
+ * @see to_chars() */
+template<class T>
+C4_ALWAYS_INLINE substr to_chars_sub(substr buf, T const& C4_RESTRICT v) noexcept
+{
+    size_t sz = to_chars(buf, v);
+    return buf.left_of(sz <= buf.len ? sz : buf.len);
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// bool implementation
+
+/** @ingroup doc_to_chars */
+C4_ALWAYS_INLINE size_t to_chars(substr buf, bool v) noexcept
+{
+    int val = v;
+    return to_chars(buf, val);
+}
+
+/** @ingroup doc_from_chars */
+inline bool from_chars(csubstr buf, bool * C4_RESTRICT v) noexcept
+{
+    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;
+}
+
+/** @ingroup doc_from_chars_first */
+inline size_t from_chars_first(csubstr buf, bool * C4_RESTRICT v) noexcept
+{
+    csubstr trimmed = buf.first_non_empty_span();
+    if(trimmed.len == 0 || !from_chars(buf, v))
+        return csubstr::npos;
+    return trimmed.len;
+}
+
+
+//-----------------------------------------------------------------------------
+// single-char implementation
+
+/** @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, char v) noexcept
+{
+    if(buf.len > 0)
+    {
+        C4_XASSERT(buf.str);
+        buf.str[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
+ * @ingroup doc_from_chars
+ * */
+inline bool from_chars(csubstr buf, char * C4_RESTRICT v) noexcept
+{
+    if(buf.len != 1)
+        return false;
+    C4_XASSERT(buf.str);
+    *v = buf.str[0];
+    return true;
+}
+
+/** @ingroup doc_from_chars_first */
+inline size_t from_chars_first(csubstr buf, char * C4_RESTRICT v) noexcept
+{
+    if(buf.len < 1)
+        return csubstr::npos;
+    *v = buf.str[0];
+    return 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// csubstr implementation
+
+/** @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, csubstr v) noexcept
+{
+    C4_ASSERT(!buf.overlaps(v));
+    size_t len = buf.len < v.len ? buf.len : v.len;
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(buf.str != nullptr);
+        C4_ASSERT(v.str != nullptr);
+        memcpy(buf.str, v.str, len);
+    }
+    return v.len;
+}
+
+/** @ingroup doc_from_chars */
+inline bool from_chars(csubstr buf, csubstr *C4_RESTRICT v) noexcept
+{
+    *v = buf;
+    return true;
+}
+
+/** @ingroup doc_from_chars_first */
+inline size_t from_chars_first(substr buf, csubstr * C4_RESTRICT v) noexcept
+{
+    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
+
+/** @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, substr v) noexcept
+{
+    C4_ASSERT(!buf.overlaps(v));
+    size_t len = buf.len < v.len ? buf.len : v.len;
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(buf.str != nullptr);
+        C4_ASSERT(v.str != nullptr);
+        memcpy(buf.str, v.str, len);
+    }
+    return v.len;
+}
+
+/** @ingroup doc_from_chars */
+inline bool from_chars(csubstr buf, substr * C4_RESTRICT v) noexcept
+{
+    C4_ASSERT(!buf.overlaps(*v));
+    // is the destination buffer wide enough?
+    if(v->len >= buf.len)
+    {
+        // calling memcpy with null strings is undefined behavior
+        // and will wreak havoc in calling code's branches.
+        // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+        if(buf.len)
+        {
+            C4_ASSERT(buf.str != nullptr);
+            C4_ASSERT(v->str != nullptr);
+            memcpy(v->str, buf.str, buf.len);
+        }
+        v->len = buf.len;
+        return true;
+    }
+    return false;
+}
+
+/** @ingroup doc_from_chars_first */
+inline size_t from_chars_first(csubstr buf, substr * C4_RESTRICT v) noexcept
+{
+    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;
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(buf.str != nullptr);
+        C4_ASSERT(v->str != nullptr);
+        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());
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** @ingroup doc_to_chars */
+template<size_t N>
+inline size_t to_chars(substr buf, const char (& C4_RESTRICT v)[N]) noexcept
+{
+    csubstr sp(v);
+    return to_chars(buf, sp);
+}
+
+/** @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, const char * C4_RESTRICT v) noexcept
+{
+    return to_chars(buf, to_csubstr(v));
+}
+
+/** @} */
+
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   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>
+
+/** @file utf.hpp utilities for UTF and Byte Order Mark */
+
+namespace c4 {
+
+/** @defgroup doc_utf UTF utilities
+ * @{ */
+
+
+/** skip the Byte Order Mark, or get the full string if there is Byte Order Mark.
+ * @see Implements the Byte Order Marks as described in https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding */
+C4CORE_EXPORT substr skip_bom(substr s);
+/** skip the Byte Order Mark, or get the full string if there is Byte Order Mark
+ * @see Implements the Byte Order Marks as described in https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding */
+C4CORE_EXPORT csubstr skip_bom(csubstr s);
+
+
+/** get the Byte Order Mark, or an empty string if there is no Byte Order Mark
+ * @see Implements the Byte Order Marks as described in https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding */
+C4CORE_EXPORT substr get_bom(substr s);
+/** get the Byte Order Mark, or an empty string if there is no Byte Order Mark
+ * @see Implements the Byte Order Marks as described in https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding */
+C4CORE_EXPORT csubstr get_bom(csubstr s);
+
+
+/** return the position of the first character not belonging to the
+ * Byte Order Mark, or 0 if there is no Byte Order Mark.
+ * @see Implements the Byte Order Marks as described in https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding */
+C4CORE_EXPORT size_t first_non_bom(csubstr s);
+
+
+/** decode the given @p code_point, writing into the output string in
+ * @p out.
+ *
+ * @param out the output string. must have at least 4 bytes (this is
+ * asserted), and must not have a null string.
+ *
+ * @param code_point: must have length in ]0,8], and must not begin
+ * with any of `U+`,`\\x`,`\\u,`\\U`,`0` (asserted)
+ *
+ * @return the part of @p out that was written, which will always be
+ * at most 4 bytes.
+ */
+C4CORE_EXPORT substr decode_code_point(substr out, csubstr code_point);
+
+/** decode the given @p code point, writing into the output string @p
+ * buf, of size @p buflen
+ *
+ * @param buf the output string. must have at least 4 bytes (this is
+ * asserted), and must not be null
+ *
+ * @param buflen the length of the output string. must be at least 4
+ *
+ * @param code: the code point must have length in ]0,8], and must not begin
+ * with any of `U+`,`\\x`,`\\u,`\\U`,`0` (asserted)
+ *
+ * @return the part of @p out that was written, which will always be
+ * at most 4 bytes.
+ */
+size_t decode_code_point(uint8_t *C4_RESTRICT buf, size_t buflen, 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_ */
+
+
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   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
+// NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast,*avoid-goto*)
+
+/** @defgroup doc_format_utils Format utilities
+ *
+ * @brief Provides generic and type-safe formatting/scanning utilities
+ * built on top of @ref doc_to_chars() and @ref doc_from_chars,
+ * forwarding the arguments to these functions, which in turn use the
+ * @ref doc_charconv utilities. Like @ref doc_charconv, the formatting
+ * facilities are very efficient and many times faster than printf().
+ *
+ * @see [a formatting sample in rapidyaml's docs](https://rapidyaml.readthedocs.io/latest/doxygen/group__doc__quickstart.html#gac2425b515eb552589708cfff70c52b14)
+ * */
+
+/** @defgroup doc_format_specifiers Format specifiers
+ *
+ * @brief Format specifiers are tag types and functions that are used
+ * together with @ref doc_to_chars and @ref doc_from_chars
+ *
+ * @see [a formatting sample in rapidyaml's docs](https://rapidyaml.readthedocs.io/latest/doxygen/group__doc__quickstart.html#gac2425b515eb552589708cfff70c52b14)
+ * @ingroup doc_format_utils */
+
+namespace c4 {
+
+/** @addtogroup doc_format_utils
+ * @{ */
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting truthy types as booleans
+
+namespace fmt {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_boolean_specifiers boolean specifiers
+ * @{ */
+
+/** 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
+ * @ingroup doc_to_chars */
+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 {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_integer_specifiers Integer specifiers
+ * @{ */
+
+/** format an integral type with a custom radix */
+template<typename T>
+struct integral_
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    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_
+{
+    C4_STATIC_ASSERT(std::is_integral<T>::value);
+    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));
+}
+
+
+/** 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 raw memcpy-based binary dump instead of 0-1 formatting */
+template<class T>
+inline integral_<T> bin(T v)
+{
+    return integral_<T>(v, T(2));
+}
+
+/** @} */ // integer_specifiers
+
+
+/** @defgroup doc_zpad Pad the number with zeroes on the left
+ * @{ */
+
+/** 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);
+}
+
+/** @} */ // zpad
+
+
+/** @defgroup doc_overflow_checked Check read for overflow
+ * @{ */
+
+template<class T>
+struct overflow_checked_
+{
+    static_assert(std::is_integral<T>::value, "range checking only for integral types");
+    C4_ALWAYS_INLINE overflow_checked_(T &val_) : val(&val_) {}
+    T *val;
+};
+template<class T>
+C4_ALWAYS_INLINE overflow_checked_<T> overflow_checked(T &val)
+{
+   return overflow_checked_<T>(val);
+}
+
+/** @} */ // overflow_checked
+
+/** @} */ // format_specifiers
+
+
+} // namespace fmt
+
+/** format an integer signed type
+ * @ingroup doc_to_chars */
+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 integer signed type, pad with zeroes
+ * @ingroup doc_to_chars */
+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 integer unsigned type
+ * @ingroup doc_to_chars */
+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 integer unsigned type, pad with zeroes
+ * @ingroup doc_to_chars */
+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);
+}
+
+/** read an integer type, detecting overflow (returns false on overflow)
+ * @ingroup doc_from_chars */
+template<class T>
+C4_ALWAYS_INLINE bool from_chars(csubstr s, fmt::overflow_checked_<T> wrapper)
+{
+    if(C4_LIKELY(!overflows<T>(s)))
+        return atox(s, wrapper.val);
+    return false;
+}
+/** read an integer type, detecting overflow (returns false on overflow)
+ * @ingroup doc_from_chars */
+template<class T>
+C4_ALWAYS_INLINE bool from_chars(csubstr s, fmt::overflow_checked_<T> *wrapper)
+{
+    if(C4_LIKELY(!overflows<T>(s)))
+        return atox(s, wrapper->val);
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting real types
+
+namespace fmt {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_real_specifiers Real specifiers
+ * @{ */
+
+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);
+}
+
+/** @} */ // real_specifiers
+
+/** @} */ // format_specifiers
+
+} // namespace fmt
+
+/** @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, fmt::real_< float> fmt) { return ftoa(buf, fmt.val, fmt.precision, fmt.fmt); }
+/** @ingroup doc_to_chars */
+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 {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_raw_binary_specifiers Raw binary data
+ * @{ */
+
+/** @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);
+}
+
+/** @} */ // raw_binary_specifiers
+
+/** @} */ // format_specifiers
+
+} // namespace fmt
+
+
+/** write a variable in raw binary format, using memcpy
+ * @ingroup doc_to_chars */
+C4CORE_EXPORT size_t to_chars(substr buf, fmt::const_raw_wrapper r);
+
+/** read a variable in raw binary format, using memcpy
+ * @ingroup doc_from_chars */
+C4CORE_EXPORT bool from_chars(csubstr buf, fmt::raw_wrapper *r);
+/** read a variable in raw binary format, using memcpy
+ * @ingroup doc_from_chars */
+inline bool from_chars(csubstr buf, fmt::raw_wrapper r)
+{
+    return from_chars(buf, &r);
+}
+
+/** read a variable in raw binary format, using memcpy
+ * @ingroup doc_from_chars_first */
+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
+ * @ingroup doc_from_chars_first */
+inline size_t from_chars_first(csubstr buf, fmt::raw_wrapper r)
+{
+    return from_chars(buf, &r);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// formatting aligned to left/right
+
+namespace fmt {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_alignment_specifiers Alignment specifiers
+ * @{ */
+
+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);
+}
+
+/** @} */ // alignment_specifiers
+
+/** @} */ // format_specifiers
+
+} // namespace fmt
+
+
+/** @ingroup doc_to_chars */
+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;
+}
+
+/** @ingroup doc_to_chars */
+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;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_cat cat: concatenate arguments to string
+ * @{ */
+
+/** @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};
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_uncat uncat: read concatenated arguments from string
+ * @{ */
+
+/** @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;
+}
+
+/** @} */
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_catsep catsep: cat arguments to string with separator
+ * @{ */
+
+/** @cond dev */
+namespace detail {
+template<class Sep>
+C4_ALWAYS_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);
+    size_t 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);
+    size_t 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
+
+template<class Sep>
+size_t catsep(substr /*buf*/, Sep const& C4_RESTRICT /*sep*/)
+{
+    return 0;
+}
+/** @endcond */
+
+
+/** 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};
+}
+
+/** @} */
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_uncatsep uncatsep: deserialize the separated arguments from a string
+ * @{ */
+
+/** 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(). */
+
+/** 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;
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_format format: formatted string interpolation
+ * @{ */
+
+/// @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};
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_unformat unformat: formatted read from string
+ * @{ */
+
+/// @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;
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** cat+resize: 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()
+ * @ingroup doc_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;
+}
+
+/** cat+resize: like c4::cat(), but creates and returns a new
+ * container sized as needed to contain the result.
+ * @see c4::cat()
+ * @ingroup doc_cat */
+template<class CharOwningContainer, class... Args>
+inline CharOwningContainer catrs(Args const& C4_RESTRICT ...args)
+{
+    CharOwningContainer cont;
+    catrs(&cont, args...);
+    return cont;
+}
+
+/** cat+resize+append: 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()
+ * @ingroup doc_cat */
+template<class CharOwningContainer, class... Args>
+inline csubstr catrs_append(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());
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** catsep+resize: 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()
+ * @ingroup doc_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;
+}
+
+/** catsep+resize: like c4::catsep(), but create a new container with
+ * the result.
+ *
+ * @return the requested container
+ * @ingroup doc_catsep */
+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;
+}
+
+
+/** catsep+resize+append: 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 doc_catsep */
+template<class CharOwningContainer, class Sep, class... Args>
+inline csubstr catseprs_append(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());
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** format+resize: 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()
+ * @ingroup doc_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;
+}
+
+/** format+resize: like c4::format(), but create a new container with
+ * the result.
+ *
+ * @return the requested container
+ * @ingroup doc_format */
+template<class CharOwningContainer, class... Args>
+inline CharOwningContainer formatrs(csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+    CharOwningContainer cont;
+    formatrs(&cont, fmt, args...);
+    return cont;
+}
+
+/** format+resize+append: 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 doc_format */
+template<class CharOwningContainer, class... Args>
+inline csubstr formatrs_append(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
+
+// NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast,*avoid-goto*)
+#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_ */
+
+
+/** @file dump.hpp This file provides functions to dump several
+ * arguments as strings to a user-provided function sink, for example
+ * to implement a type-safe printf()-like function (where the sink
+ * would just be a plain call to putchars()). The function sink can be
+ * passed either by dynamic dispatching or by static dispatching (as a
+ * template argument). There are analogs to @ref c4::cat() (@ref
+ * c4::cat_dump() and @ref c4::cat_dump_resume()), @ref c4::catsep()
+ * (@ref catsetp_dump() and @ref catsep_dump_resume()) and @ref
+ * c4::format() (@ref c4::format_dump() and @ref
+ * c4::format_dump_resume()). The analogs have two types: immediate
+ * and resuming. An analog of immediate type cannot be retried when
+ * the work buffer is too small; this means that successful dumps in
+ * the first (successful) arguments will be dumped again in the
+ * subsequent attempt to call. An analog of resuming type will only
+ * ever dump as-yet-undumped arguments, through the use of @ref
+ * DumpResults return type. */
+
+namespace c4 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup dump_building_blocks Basic building blocks for dumping.
+ *
+ * The basic building block: given an argument and a
+ * buffer, serialize the argument to the buffer using @ref
+ * c4::to_chars(), and dump the buffer to the provided sink
+ * function. When the argument is a string, no serialization is
+ * performed, and the argument is dumped directly to the sink.
+ *
+ * @{ */
+
+
+/** Type of the function to be used as the sink. This function
+ * receives as its argument the string with characters to send to the
+ * sink.
+ *
+ * @warning the string passed to the sink may have zero length. If the
+ * user sink uses memcpy(), the call to memcpy() should be defended
+ * with a check for zero length (calling memcpy with zero length is
+ * undefined behavior).
+ * */
+using SinkPfn = void (*)(csubstr str);
+
+
+/** a traits class to use in SFINAE with @ref c4::dump() to select if
+ * a type is treated as string type (which is dumped directly to the
+ * sink, using to_csubstr()), or if the type is treated as a value,
+ * which is first serialized to a buffer using to_chars(), and then
+ * the serialization serialized as */
+template<class T> struct dump_directly : public std::false_type {};
+template<> struct dump_directly<csubstr> : public std::true_type {};
+template<> struct dump_directly< substr> : public std::true_type {};
+template<> struct dump_directly<const char*> : public std::true_type {};
+template<> struct dump_directly<      char*> : public std::true_type {};
+template<size_t N> struct dump_directly<const char (&)[N]> : public std::true_type {};
+template<size_t N> struct dump_directly<      char (&)[N]> : public std::true_type {};
+template<size_t N> struct dump_directly<const char[N]> : public std::true_type {};
+template<size_t N> struct dump_directly<      char[N]> : public std::true_type {};
+
+
+/** Dump a string-type object to the (statically dispatched) sink. The
+ * string is dumped directly, without any intermediate serialization.
+ *
+ * @return the number of bytes needed to serialize the string-type
+ * object, which is always 0 because there is no serialization
+ *
+ * @note the argument is considered a value when @ref
+ * dump_directly<Arg> is a false type, which is the default. To enable
+ * the argument to be treated as a string type, which is dumped
+ * directly to the sink without intermediate serialization, define
+ * dump_directly<T> to a true type.
+ *
+ * @warning the string passed to the sink may have zero length. If the
+ * user sink uses memcpy(), the call to memcpy() should be defended
+ * with a check for zero length (calling memcpy with zero length is
+ * undefined behavior).
+ *
+ * @see dump_directly<T>
+ */
+template<SinkPfn sinkfn, class Arg>
+inline auto dump(substr buf, Arg const& a)
+    -> typename std::enable_if<dump_directly<Arg>::value, size_t>::type
+{
+    C4_ASSERT(!buf.overlaps(a));
+    C4_UNUSED(buf);
+    // dump directly, no need to serialize to the buffer
+    sinkfn(to_csubstr(a));
+    return 0; // no space was used in the buffer
+}
+/** Dump a string-type object to the (dynamically dispatched)
+ * sink. The string is dumped directly, without any intermediate
+ * serialization to the buffer.
+ *
+ * @return the number of bytes needed to serialize the string-type
+ * object, which is always 0 because there is no serialization
+ *
+ * @note the argument is considered a value when @ref
+ * dump_directly<Arg> is a false type, which is the default. To enable
+ * the argument to be treated as a string type, which is dumped
+ * directly to the sink without intermediate serialization, define
+ * dump_directly<T> to a true type.
+ *
+ * @warning the string passed to the sink may have zero length. If the
+ * user sink uses memcpy(), the call to memcpy() should be defended
+ * with a check for zero length (calling memcpy with zero length is
+ * undefined behavior).
+ *
+ * @see dump_directly<T>
+ * */
+template<class SinkFn, class Arg>
+inline auto dump(SinkFn &&sinkfn, substr buf, Arg const& a)
+    -> typename std::enable_if<dump_directly<Arg>::value, size_t>::type
+{
+    C4_UNUSED(buf);
+    C4_ASSERT(!buf.overlaps(a));
+    // dump directly, no need to serialize to the buffer
+    std::forward<SinkFn>(sinkfn)(to_csubstr(a));
+    return 0; // no space was used in the buffer
+}
+
+
+/** Dump a value to the sink. Given an argument @p a and a buffer @p
+ * buf, serialize the argument to the buffer using @ref to_chars(),
+ * and then dump the buffer to the (statically dispatched) sink
+ * function passed as the template argument. If the buffer is too
+ * small to serialize the argument, the sink function is not called.
+ *
+ * @note the argument is considered a value when @ref
+ * dump_directly<Arg> is a false type, which is the default. To enable
+ * the argument to be treated as a string type, which is dumped
+ * directly to the sink without intermediate serialization, define
+ * dump_directly<T> to a true type.
+ *
+ * @see dump_directly<T>
+ *
+ * @return the number of characters required to serialize the
+ * argument. */
+template<SinkPfn sinkfn, class Arg>
+inline auto dump(substr buf, Arg const& a)
+    -> typename std::enable_if<!dump_directly<Arg>::value, size_t>::type
+{
+    // serialize to the buffer
+    const size_t sz = to_chars(buf, a);
+    // dump the buffer to the sink
+    if(C4_LIKELY(sz <= buf.len))
+    {
+        // NOTE: don't do this:
+        //sinkfn(buf.first(sz));
+        // ... but do this instead:
+        sinkfn({buf.str, sz});
+        // ... this is needed because Release builds for armv5 and
+        // armv6 were failing for the first call, with the wrong
+        // buffer being passed into the function (!)
+    }
+    return sz;
+}
+/** Dump a value to the sink. Given an argument @p a and a buffer @p
+ * buf, serialize the argument to the buffer using @ref
+ * c4::to_chars(), and then dump the buffer to the (dynamically
+ * dispatched) sink function, passed as @p sinkfn. If the buffer is too
+ * small to serialize the argument, the sink function is not called.
+ *
+ * @note the argument is considered a value when @ref
+ * dump_directly<Arg> is a false type, which is the default. To enable
+ * the argument to be treated as a string type, which is dumped
+ * directly to the sink without intermediate serialization, define
+ * dump_directly<T> to a true type.
+ *
+ * @see @ref dump_directly<T>
+ *
+ * @return the number of characters required to serialize the
+ * argument. */
+template<class SinkFn, class Arg>
+inline auto dump(SinkFn &&sinkfn, substr buf, Arg const& a)
+    -> typename std::enable_if<!dump_directly<Arg>::value, size_t>::type
+{
+    // serialize to the buffer
+    const size_t sz = to_chars(buf, a);
+    // dump the buffer to the sink
+    if(C4_LIKELY(sz <= buf.len))
+    {
+        // NOTE: don't do this:
+        //std::forward<SinkFn>(sinkfn)(buf.first(sz));
+        // ... but do this instead:
+        std::forward<SinkFn>(sinkfn)({buf.str, sz});
+        // ... this is needed because Release builds for armv5 and
+        // armv6 were failing for the first call, with the wrong
+        // buffer being passed into the function (!)
+    }
+    return sz;
+}
+
+
+/** An opaque type used by resumeable dump functions like @ref
+ * cat_dump_resume(), @ref catsep_dump_resume() or @ref
+ * format_dump_resume(). */
+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; }
+};
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup cat_dump Dump several arguments to a sink,
+ * concatenated. This is the analog to @ref c4::cat(), with the
+ * significant difference that each argument is immediately sent to
+ * the sink (resulting in multiple calls to the sink function, once
+ * per argument), whereas equivalent usage of c4::cat() would first
+ * serialize all the arguments to the buffer, and then call the sink
+ * once at the end. As a consequence, the size needed for the buffer
+ * is only the maximum of the size needed for the arguments, whereas
+ * with c4::cat(), the size needed for the buffer would be the sum of
+ * the size needed for the arguments. When the size of dump
+ *
+ * @{ */
+
+/// @cond dev
+// terminates the variadic recursion
+template<class SinkFn>
+size_t cat_dump(SinkFn &&, substr) // NOLINT
+{
+    return 0;
+}
+
+// terminates the variadic recursion
+template<SinkPfn sinkfn>
+size_t cat_dump(substr) // NOLINT
+{
+    return 0;
+}
+/// @endcond
+
+
+/** Dump several arguments to the (dynamically dispatched) sink
+ * function, as if through c4::cat(). For each argument, @ref dump()
+ * is called with the buffer and sink. If any of the arguments is too
+ * large for the buffer, no subsequent argument is sent to the sink,
+ * (but all the arguments are still processed to compute the size
+ * required for the buffer). This function can be safely called with an
+ * empty buffer.
+ *
+ * @return the size required for the buffer, which is the maximum size
+ * across all arguments
+ *
+ * @note subsequent calls with the same set of arguments will dump
+ * again the first successful arguments. If each argument must only be
+ * sent once to the sink (for example with printf-like behavior), use
+ * instead @ref cat_dump_resume(). */
+template<class SinkFn, class Arg, class... Args>
+size_t cat_dump(SinkFn &&sinkfn, substr buf, Arg const& a, Args const& ...more)
+{
+    const size_t size_for_a = dump(std::forward<SinkFn>(sinkfn), buf, a);
+    if(C4_UNLIKELY(size_for_a > buf.len))
+        buf.len = 0; // ensure no more calls to the sink
+    const size_t size_for_more = cat_dump(std::forward<SinkFn>(sinkfn), buf, more...);
+    return size_for_more > size_for_a ? size_for_more : size_for_a;
+}
+
+
+/** Dump several arguments to the (statically dispatched) sink
+ * function, as if through c4::cat(). For each argument, @ref dump()
+ * is called with the buffer and sink. If any of the arguments is too
+ * large for the buffer, no subsequent argument is sent to the sink,
+ * (but all the arguments are still processed to compute the size
+ * required for the buffer). This function can be safely called with an
+ * empty buffer.
+ *
+ * @return the size required for the buffer, which is the maximum size
+ * across all arguments
+ *
+ * @note subsequent calls with the same set of arguments will dump
+ * again the first successful arguments. If each argument must only be
+ * sent once to the sink (for example with printf-like behavior), use
+ * instead @ref cat_dump_resume(). */
+template<SinkPfn sinkfn, class Arg, class... Args>
+size_t cat_dump(substr buf, Arg const& a, Args const& ...more)
+{
+    const size_t size_for_a = dump<sinkfn>(buf, a);
+    if(C4_UNLIKELY(size_for_a > buf.len))
+        buf.len = 0; // ensure no more calls to the sink
+    const size_t size_for_more = cat_dump<sinkfn>(buf, more...);
+    return size_for_more > size_for_a ? size_for_more : size_for_a;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+
+// terminates the variadic recursion
+template<SinkPfn sinkfn>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(size_t, DumpResults results, substr)
+{
+    return results;
+}
+
+// terminates the variadic recursion
+template<class SinkFn>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(size_t, SinkFn &&, DumpResults results, substr) // NOLINT
+{
+    return results;
+}
+
+template<SinkPfn sinkfn, class Arg, class... Args>
+DumpResults cat_dump_resume(size_t currarg, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        size_t sz = dump<sinkfn>(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 detail::cat_dump_resume<sinkfn>(currarg + 1u, results, buf, more...);
+}
+
+template<class SinkFn, class Arg, class... Args>
+DumpResults cat_dump_resume(size_t currarg, SinkFn &&sinkfn, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        size_t sz = dump(std::forward<SinkFn>(sinkfn), 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 detail::cat_dump_resume(currarg + 1u, std::forward<SinkFn>(sinkfn), results, buf, more...);
+}
+} // namespace detail
+/// @endcond
+
+
+template<SinkPfn sinkfn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    return detail::cat_dump_resume<sinkfn>(0u, DumpResults{}, buf, a, more...);
+}
+
+template<class SinkFn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(SinkFn &&sinkfn, substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    return detail::cat_dump_resume(0u, std::forward<SinkFn>(sinkfn), DumpResults{}, buf, a, more...);
+}
+
+
+template<SinkPfn sinkfn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    if(results.bufsize > buf.len)
+        return results;
+    return detail::cat_dump_resume<sinkfn>(0u, results, buf, a, more...);
+}
+
+template<class SinkFn, class Arg, class... Args>
+C4_ALWAYS_INLINE DumpResults cat_dump_resume(SinkFn &&sinkfn, DumpResults results, substr buf, Arg const& C4_RESTRICT a, Args const& ...more)
+{
+    if(results.bufsize > buf.len)
+        return results;
+    return detail::cat_dump_resume(0u, std::forward<SinkFn>(sinkfn), results, buf, a, more...);
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+// terminate the recursion
+template<class SinkFn, class Sep>
+size_t catsep_dump(SinkFn &&, substr, Sep const& C4_RESTRICT) // NOLINT
+{
+    return 0;
+}
+
+// terminate the recursion
+template<SinkPfn sinkfn, class Sep>
+size_t catsep_dump(substr, Sep const& C4_RESTRICT) // NOLINT
+{
+    return 0;
+}
+/// @endcond
+
+/** take the function pointer as a function argument */
+template<class SinkFn, class Sep, class Arg, class... Args>
+size_t catsep_dump(SinkFn &&sinkfn, substr buf, Sep const& sep, Arg const& a, Args const& ...more)
+{
+    size_t sz = dump(std::forward<SinkFn>(sinkfn), buf, a);
+    if(C4_UNLIKELY(sz > buf.len))
+        buf.len = 0; // ensure no more calls
+    if C4_IF_CONSTEXPR (sizeof...(more) > 0)
+    {
+        size_t szsep = dump(std::forward<SinkFn>(sinkfn), buf, sep);
+        if(C4_UNLIKELY(szsep > buf.len))
+            buf.len = 0; // ensure no more calls
+        sz = sz > szsep ? sz : szsep;
+    }
+    size_t size_for_more = catsep_dump(std::forward<SinkFn>(sinkfn), buf, sep, more...);
+    return size_for_more > sz ? size_for_more : sz;
+}
+
+/** take the function pointer as a template argument */
+template<SinkPfn sinkfn, class Sep, class Arg, class... Args>
+size_t catsep_dump(substr buf, Sep const& sep, Arg const& a, Args const& ...more)
+{
+    size_t sz = dump<sinkfn>(buf, a);
+    if(C4_UNLIKELY(sz > buf.len))
+        buf.len = 0; // ensure no more calls
+    if C4_IF_CONSTEXPR (sizeof...(more) > 0)
+    {
+        size_t szsep = dump<sinkfn>(buf, sep);
+        if(C4_UNLIKELY(szsep > buf.len))
+            buf.len = 0; // ensure no more calls
+        sz = sz > szsep ? sz : szsep;
+    }
+    size_t size_for_more = catsep_dump<sinkfn>(buf, sep, more...);
+    return size_for_more > sz ? size_for_more : sz;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+template<SinkPfn sinkfn, class Arg>
+void catsep_dump_resume_(size_t currarg, DumpResults *C4_RESTRICT results, substr *buf, Arg const& a)
+{
+    if(C4_LIKELY(results->write_arg(currarg)))
+    {
+        size_t sz = dump<sinkfn>(*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 SinkFn, class Arg>
+void catsep_dump_resume_(size_t currarg, SinkFn &&sinkfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Arg const& C4_RESTRICT a)
+{
+    if(C4_LIKELY(results->write_arg(currarg)))
+    {
+        size_t sz = dump(std::forward<SinkFn>(sinkfn), *buf, a);
+        results->bufsize = sz > results->bufsize ? sz : results->bufsize;
+        if(C4_LIKELY(sz <= buf->len))
+            results->lastok = currarg;
+        else
+            buf->len = 0;
+    }
+}
+
+template<SinkPfn sinkfn, class Sep, class Arg>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const&, Arg const& a)
+{
+    detail::catsep_dump_resume_<sinkfn>(currarg, results, buf, a);
+}
+
+template<class SinkFn, class Sep, class Arg>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, SinkFn &&sinkfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const&, Arg const& a)
+{
+    detail::catsep_dump_resume_(currarg, std::forward<SinkFn>(sinkfn), results, buf, a);
+}
+
+template<SinkPfn sinkfn, 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& sep, Arg const& a, Args const& ...more)
+{
+    detail::catsep_dump_resume_<sinkfn>(currarg     , results, buf, a);
+    detail::catsep_dump_resume_<sinkfn>(currarg + 1u, results, buf, sep);
+    detail::catsep_dump_resume <sinkfn>(currarg + 2u, results, buf, sep, more...);
+}
+
+template<class SinkFn, class Sep, class Arg, class... Args>
+C4_ALWAYS_INLINE void catsep_dump_resume(size_t currarg, SinkFn &&sinkfn, DumpResults *C4_RESTRICT results, substr *C4_RESTRICT buf, Sep const& sep, Arg const& a, Args const& ...more)
+{
+    detail::catsep_dump_resume_(currarg     , std::forward<SinkFn>(sinkfn), results, buf, a);
+    detail::catsep_dump_resume_(currarg + 1u, std::forward<SinkFn>(sinkfn), results, buf, sep);
+    detail::catsep_dump_resume (currarg + 2u, std::forward<SinkFn>(sinkfn), results, buf, sep, more...);
+}
+} // namespace detail
+/// @endcond
+
+
+template<SinkPfn sinkfn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(substr buf, Sep const& sep, Args const& ...args)
+{
+    DumpResults results;
+    detail::catsep_dump_resume<sinkfn>(0u, &results, &buf, sep, args...);
+    return results;
+}
+
+template<class SinkFn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(SinkFn &&sinkfn, substr buf, Sep const& sep, Args const& ...args)
+{
+    DumpResults results;
+    detail::catsep_dump_resume(0u, std::forward<SinkFn>(sinkfn), &results, &buf, sep, args...);
+    return results;
+}
+
+
+template<SinkPfn sinkfn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(DumpResults results, substr buf, Sep const& sep, Args const& ...args)
+{
+    detail::catsep_dump_resume<sinkfn>(0u, &results, &buf, sep, args...);
+    return results;
+}
+
+template<class SinkFn, class Sep, class... Args>
+C4_ALWAYS_INLINE DumpResults catsep_dump_resume(SinkFn &&sinkfn, DumpResults results, substr buf, Sep const& sep, Args const& ...args)
+{
+    detail::catsep_dump_resume(0u, std::forward<SinkFn>(sinkfn), &results, &buf, sep, args...);
+    return results;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+// terminate the recursion
+C4_ALWAYS_INLINE size_t _format_dump_compute_size()
+{
+    return 0u;
+}
+template<class T>
+C4_ALWAYS_INLINE auto _format_dump_compute_size(T const&)
+    -> typename std::enable_if<dump_directly<T>::value, size_t>::type
+{
+    return 0u; // no buffer needed
+}
+template<class T>
+C4_ALWAYS_INLINE auto _format_dump_compute_size(T const& v)
+    -> typename std::enable_if<!dump_directly<T>::value, size_t>::type
+{
+    return to_chars({}, v);
+}
+template<class Arg, class... Args>
+size_t _format_dump_compute_size(Arg const& a, Args const& ...more)
+{
+    const size_t sz = _format_dump_compute_size(a); // don't call to_chars() directly
+    const size_t rest = _format_dump_compute_size(more...);
+    return sz > rest ? sz : rest;
+}
+} // namespace detail
+
+// terminate the recursion
+template<class SinkFn>
+C4_ALWAYS_INLINE size_t format_dump(SinkFn &&sinkfn, substr, csubstr fmt)
+{
+    // we can dump without using buf, so no need to check it
+    std::forward<SinkFn>(sinkfn)(fmt);
+    return 0u;
+}
+// terminate the recursion
+/** take the function pointer as a template argument */
+template<SinkPfn sinkfn>
+C4_ALWAYS_INLINE size_t format_dump(substr, csubstr fmt)
+{
+    // we can dump without using buf, so no need to check it
+    sinkfn(fmt);
+    return 0u;
+}
+/// @endcond
+
+
+/** take the function pointer as a function argument */
+template<class SinkFn, class Arg, class... Args>
+C4_NO_INLINE size_t format_dump(SinkFn &&sinkfn, substr buf, csubstr fmt, Arg const& a, Args const& ...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))
+    {
+        std::forward<SinkFn>(sinkfn)(fmt);
+        return 0u;
+    }
+    std::forward<SinkFn>(sinkfn)(fmt.first(pos)); // we can dump without using buf
+    fmt = fmt.sub(pos + 2); // skip {} do this before assigning to pos again
+    pos = dump(std::forward<SinkFn>(sinkfn), buf, a); // reuse pos to get needed_size
+    // dump no more if the buffer was exhausted
+    size_t size_for_more;
+    if(C4_LIKELY(pos <= buf.len))
+        size_for_more = format_dump(std::forward<SinkFn>(sinkfn), buf, fmt, more...);
+    else
+        size_for_more = detail::_format_dump_compute_size(more...);
+    return size_for_more > pos ? size_for_more : pos;
+}
+
+/** take the function pointer as a template argument */
+template<SinkPfn sinkfn, class Arg, class... Args>
+C4_NO_INLINE size_t format_dump(substr buf, csubstr fmt, Arg const& C4_RESTRICT a, Args const& ...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))
+    {
+        sinkfn(fmt);
+        return 0u;
+    }
+    sinkfn(fmt.first(pos)); // we can dump without using buf
+    fmt = fmt.sub(pos + 2); // skip {} do this before assigning to pos again
+    pos = dump<sinkfn>(buf, a); // reuse pos to get needed_size
+    // dump no more if the buffer was exhausted
+    size_t size_for_more;
+    if(C4_LIKELY(pos <= buf.len))
+        size_for_more = format_dump<sinkfn>(buf, fmt, more...);
+    else
+        size_for_more = detail::_format_dump_compute_size(more...);
+    return size_for_more > pos ? size_for_more : pos;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+namespace detail {
+// terminate the recursion
+template<SinkPfn sinkfn>
+DumpResults format_dump_resume(size_t currarg, DumpResults results, substr, csubstr fmt)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        // we can dump without using buf
+        sinkfn(fmt);
+        results.lastok = currarg;
+    }
+    return results;
+}
+
+// terminate the recursion
+template<class SinkFn>
+DumpResults format_dump_resume(size_t currarg, SinkFn &&sinkfn, DumpResults results, substr, csubstr fmt)
+{
+    if(C4_LIKELY(results.write_arg(currarg)))
+    {
+        // we can dump without using buf
+        std::forward<SinkFn>(sinkfn)(fmt);
+        results.lastok = currarg;
+    }
+    return results;
+}
+
+template<SinkPfn sinkfn, class Arg, class... Args>
+DumpResults format_dump_resume(size_t currarg, DumpResults results, substr buf, csubstr fmt, Arg const& a, Args const& ...more)
+{
+    // we need to process the format even if we're not
+    // going to print the first arguments because we're resuming
+    const size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    if(C4_LIKELY(pos != csubstr::npos))
+    {
+        if(C4_LIKELY(results.write_arg(currarg)))
+        {
+            sinkfn(fmt.first(pos));
+            results.lastok = currarg;
+        }
+        if(C4_LIKELY(results.write_arg(currarg + 1u)))
+        {
+            const size_t len = dump<sinkfn>(buf, a);
+            results.bufsize = len > results.bufsize ? len : results.bufsize;
+            if(C4_LIKELY(len <= buf.len))
+            {
+                results.lastok = currarg + 1u;
+            }
+            else
+            {
+                const size_t rest = _format_dump_compute_size(more...);
+                results.bufsize = rest > results.bufsize ? rest : results.bufsize;
+                return results;
+            }
+        }
+    }
+    else
+    {
+        if(C4_LIKELY(results.write_arg(currarg)))
+        {
+            sinkfn(fmt);
+            results.lastok = currarg;
+        }
+        return results;
+    }
+    // NOTE: sparc64 had trouble with reassignment to fmt, and
+    // was passing the original fmt to the recursion:
+    //fmt = fmt.sub(pos + 2); // DONT!
+    return detail::format_dump_resume<sinkfn>(currarg + 2u, results, buf, fmt.sub(pos + 2), more...);
+}
+
+
+template<class SinkFn, class Arg, class... Args>
+DumpResults format_dump_resume(size_t currarg, SinkFn &&sinkfn, DumpResults results, substr buf, csubstr fmt, Arg const& a, Args const& ...more)
+{
+    // we need to process the format even if we're not
+    // going to print the first arguments because we're resuming
+    const size_t pos = fmt.find("{}"); // @todo use _find_fmt()
+    if(C4_LIKELY(pos != csubstr::npos))
+    {
+        if(C4_LIKELY(results.write_arg(currarg)))
+        {
+            std::forward<SinkFn>(sinkfn)(fmt.first(pos));
+            results.lastok = currarg;
+        }
+        if(C4_LIKELY(results.write_arg(currarg + 1u)))
+        {
+            const size_t len = dump(std::forward<SinkFn>(sinkfn), buf, a);
+            results.bufsize = len > results.bufsize ? len : results.bufsize;
+            if(C4_LIKELY(len <= buf.len))
+            {
+                results.lastok = currarg + 1u;
+            }
+            else
+            {
+                const size_t rest = _format_dump_compute_size(more...);
+                results.bufsize = rest > results.bufsize ? rest : results.bufsize;
+                return results;
+            }
+        }
+    }
+    else
+    {
+        if(C4_LIKELY(results.write_arg(currarg)))
+        {
+            std::forward<SinkFn>(sinkfn)(fmt);
+            results.lastok = currarg;
+        }
+        return results;
+    }
+    // NOTE: sparc64 had trouble with reassignment to fmt, and
+    // was passing the original fmt to the recursion:
+    //fmt = fmt.sub(pos + 2); // DONT!
+    return detail::format_dump_resume(currarg + 2u, std::forward<SinkFn>(sinkfn), results, buf, fmt.sub(pos + 2), more...);
+}
+} // namespace detail
+/// @endcond
+
+
+template<SinkPfn sinkfn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(substr buf, csubstr fmt, Args const& ...args)
+{
+    return detail::format_dump_resume<sinkfn>(0u, DumpResults{}, buf, fmt, args...);
+}
+
+template<class SinkFn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(SinkFn &&sinkfn, substr buf, csubstr fmt, Args const& ...args)
+{
+    return detail::format_dump_resume(0u, std::forward<SinkFn>(sinkfn), DumpResults{}, buf, fmt, args...);
+}
+
+
+template<SinkPfn sinkfn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(DumpResults results, substr buf, csubstr fmt, Args const& ...args)
+{
+    return detail::format_dump_resume<sinkfn>(0u, results, buf, fmt, args...);
+}
+
+template<class SinkFn, class... Args>
+C4_ALWAYS_INLINE DumpResults format_dump_resume(SinkFn &&sinkfn, DumpResults results, substr buf, csubstr fmt, Args const& ...args)
+{
+    return detail::format_dump_resume(0u, std::forward<SinkFn>(sinkfn), results, buf, fmt, args...);
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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 <cstddef>
+//included above:
+//#include <string.h>
+
+/** @file enum.hpp utilities for enums: convert to/from string
+ */
+
+
+namespace c4 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+//! 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; // NOLINT(*avoid-const*)
+
+};
+
+//-----------------------------------------------------------------------------
+/** 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);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+/** 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);
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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_ */
+
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable : 4996) // 'strncpy', fopen, etc: This function or variable may be unsafe
+#endif
+
+#if defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#   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{0};
+    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)
+#endif
+
+#if defined(__clang__)
+#   pragma clang diagnostic pop
+#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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+// NOLINTBEGIN(misc-confusable-identifiers)
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** 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 + _c4csz); }
+    C4_ALWAYS_INLINE const_reverse_iterator crbegin() const noexcept { return reverse_iterator(_c4cptr + _c4csz); }
+
+    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
+};
+
+
+//-----------------------------------------------------------------------------
+// NOLINTBEGIN(*-redundant-inline*)
+
+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);
+}
+
+// NOLINTEND(*-redundant-inline*)
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** 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>> // NOLINT(*-special-member-functions)
+{
+    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>> // NOLINT(*-special-member-functions)
+{
+    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>> // NOLINT(*-special-member-functions)
+{
+    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>;
+
+// NOLINTEND(misc-confusable-identifiers)
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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_ */
+
+// 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_ */
+
+
+/// @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) // enable this to debug and find the offsets
+    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(" %2zu", index);
+    printf("\n");
+#endif
+
+#if defined(_MSC_VER)
+#   if defined(__clang__) // Visual Studio has the clang toolset
+#   if (_MSC_VER >= 1930) // do not use this: defined(C4_MSVC_2022)
+    // ..............................xxx.
+    // _c4t __cdecl _c4tn(void) [T = int]
+    enum : size_t { tstart = 30, tend = 1};
+#   else
+    // example:
+    // ..........................xxx.
+    // _c4t __cdecl _c4tn() [T = int]
+    enum : size_t { tstart = 26, tend = 1};
+#   endif
+#   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 *C4_RESTRICT 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 {
+
+/** @defgroup doc_base64 Base64 encoding/decoding
+ * @see https://en.wikipedia.org/wiki/Base64
+ * @see https://www.base64encode.org/
+ * @{ */
+
+/** check that the given buffer is a valid base64 encoding
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT 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 (ie the
+ * required size for @p encoded). No writes occur beyond the end of
+ * the output buffer, so it is safe to do a speculative call where the
+ * encoded buffer is empty, or maybe too small. The caller should
+ * ensure that the returned size is smaller than the size of the
+ * encoded buffer.
+ *
+ * @note the result depends on endianness. If transfer between
+ * little/big endian systems is desired, the caller should normalize
+ * @p data before encoding.
+ *
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT 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 (ie the
+ * required size for @p data). No writes occur beyond the end of the
+ * output buffer, so it is safe to do a speculative call where the
+ * data buffer is empty, or maybe too small. The caller should ensure
+ * that the returned size is smaller than the size of the data buffer.
+ *
+ * @note the result depends on endianness. If transfer between
+ * little/big endian systems is desired, the caller should normalize
+ * @p data after decoding.
+ *
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT size_t base64_decode(csubstr encoded, blob data);
+
+/** @} */ // base64
+
+namespace fmt {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_base64_fmt Base64
+ * @{ */
+
+template<typename CharOrConstChar>
+struct base64_wrapper_
+{
+    blob_<CharOrConstChar> data;
+    base64_wrapper_() : data() {}
+    base64_wrapper_(blob_<CharOrConstChar> blob) : data(blob) {}
+};
+/** a tag type to mark a payload as base64-encoded */
+using const_base64_wrapper = base64_wrapper_<cbyte>;
+/** a tag type to mark a payload to be encoded as base64 */
+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));
+}
+
+/** @} */ // base64_fmt
+
+/** @} */ // format_specifiers
+
+} // namespace fmt
+
+
+/** write a variable in base64 format
+ * @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, fmt::const_base64_wrapper b)
+{
+    return base64_encode(buf, b.data);
+}
+
+/** read a variable in base64 format
+ * @ingroup doc_from_chars */
+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.
+ * When the string is empty, the returned view will be pointing
+ * at the character with value '\0', but the size will be zero.
+ * @see https://en.cppreference.com/w/cpp/string/basic_string/operator_at
+ */
+C4_ALWAYS_INLINE c4::substr to_substr(std::string &s) noexcept
+{
+    #if C4_CPP < 11
+    #error this function will have undefined behavior
+    #endif
+    // since c++11 it is legal to call s[s.size()].
+    return c4::substr(&s[0], s.size()); // NOLINT(readability-container-data-pointer)
+}
+
+/** get a readonly view to an existing std::string.
+ * When the string is empty, the returned view will be pointing
+ * at the character with value '\0', but the size will be zero.
+ * @see https://en.cppreference.com/w/cpp/string/basic_string/operator_at
+ */
+C4_ALWAYS_INLINE c4::csubstr to_csubstr(std::string const& s) noexcept
+{
+    #if C4_CPP < 11
+    #error this function will have undefined behavior
+    #endif
+    // since c++11 it is legal to call s[s.size()].
+    return c4::csubstr(&s[0], s.size()); // NOLINT(readability-container-data-pointer)
+}
+
+//-----------------------------------------------------------------------------
+
+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();
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(s.data() != nullptr);
+        C4_ASSERT(buf.str != nullptr);
+        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)));
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(buf.len)
+    {
+        C4_ASSERT(buf.str != nullptr);
+        memcpy(&(*s)[0], buf.str, buf.len); // NOLINT(readability-container-data-pointer)
+    }
+    return true;
+}
+
+} // namespace c4
+
+#endif // _C4_STD_STRING_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/string.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/std/string_view.hpp
+// https://github.com/biojppm/c4core/src/c4/std/string_view.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_STD_STRING_VIEW_HPP_
+#define _C4_STD_STRING_VIEW_HPP_
+
+/** @file string_view.hpp */
+
+#ifndef C4CORE_SINGLE_HEADER
+// 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_ */
+
+#endif
+
+#if (C4_CPP >= 17 && defined(__cpp_lib_string_view)) || defined(__DOXYGEN__)
+
+#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 <string_view>
+
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+
+/** create a csubstr from an existing std::string_view. */
+C4_ALWAYS_INLINE c4::csubstr to_csubstr(std::string_view s) noexcept
+{
+    return c4::csubstr(s.data(), s.size());
+}
+
+
+//-----------------------------------------------------------------------------
+
+C4_ALWAYS_INLINE bool operator== (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) == 0; }
+C4_ALWAYS_INLINE bool operator!= (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) != 0; }
+C4_ALWAYS_INLINE bool operator>= (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) >= 0; }
+C4_ALWAYS_INLINE bool operator>  (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) >  0; }
+C4_ALWAYS_INLINE bool operator<= (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) <= 0; }
+C4_ALWAYS_INLINE bool operator<  (c4::csubstr ss, std::string_view s) { return ss.compare(s.data(), s.size()) <  0; }
+
+C4_ALWAYS_INLINE bool operator== (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) == 0; }
+C4_ALWAYS_INLINE bool operator!= (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) != 0; }
+C4_ALWAYS_INLINE bool operator<= (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) >= 0; }
+C4_ALWAYS_INLINE bool operator<  (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) >  0; }
+C4_ALWAYS_INLINE bool operator>= (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) <= 0; }
+C4_ALWAYS_INLINE bool operator>  (std::string_view s, c4::csubstr ss) { return ss.compare(s.data(), s.size()) <  0; }
+
+
+//-----------------------------------------------------------------------------
+
+/** copy an std::string_view to a writeable substr */
+inline size_t to_chars(c4::substr buf, std::string_view s)
+{
+    C4_ASSERT(!buf.overlaps(to_csubstr(s)));
+    size_t sz = s.size();
+    size_t len = buf.len < sz ? buf.len : sz;
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(s.data() != nullptr);
+        C4_ASSERT(buf.str != nullptr);
+        memcpy(buf.str, s.data(), len);
+    }
+    return sz; // return the number of needed chars
+}
+
+} // namespace c4
+
+#endif // C4_STRING_VIEW_AVAILABLE
+
+#endif // _C4_STD_STRING_VIEW_HPP_
+
+
+// (end https://github.com/biojppm/c4core/src/c4/std/string_view.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();
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len > 0)
+    {
+        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)));
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(buf.len > 0)
+    {
+        memcpy(&(*s)[0], buf.str, buf.len); // NOLINT(readability-container-data-pointer)
+    }
+    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>
+
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+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(uint64_t s) : m_seed(s) {}
+    explicit splitmix(std::random_device &rd)
+    {
+        seed(rd);
+    }
+
+    void seed(uint64_t s) { m_seed = s; }
+    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(uint64_t s) { m_seed = s; }
+    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(uint64_t s) { m_state = s; m_inc = m_state << 1; }
+    explicit pcg(std::random_device &rd)
+    {
+        seed(rd);
+    }
+
+    void seed(uint64_t s) { m_state = s; }
+    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
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#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>
+//included above:
+//#include <cstdlib>
+
+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
+            {
+                #if (defined(_MSC_VER) && (defined(_CPPUNWIND) && (__CPPUNWIND == 1)))  \
+                    ||                                                  \
+                    (defined(__EXCEPTIONS) || defined(__cpp_exceptions))
+                throw std::bad_function_call();
+                #else
+                std::abort();
+                #endif
+            }
+        },
+        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/version.cpp
+// https://github.com/biojppm/c4core/src/c4/version.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef C4CORE_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/c4core/src/c4/version.hpp
+//#include "c4/version.hpp"
+#if !defined(C4_VERSION_HPP_) && !defined(_C4_VERSION_HPP_)
+#error "amalgamate: file c4/version.hpp must have been included at this point"
+#endif /* C4_VERSION_HPP_ */
+
+
+namespace c4 {
+
+const char* version()
+{
+  return C4CORE_VERSION;
+}
+
+int version_major()
+{
+  return C4CORE_VERSION_MAJOR;
+}
+
+int version_minor()
+{
+  return C4CORE_VERSION_MINOR;
+}
+
+int version_patch()
+{
+  return C4CORE_VERSION_PATCH;
+}
+
+} // namespace c4
+
+#endif /* C4CORE_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/c4core/src/c4/version.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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"
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+namespace c4 {
+
+
+size_t to_chars(substr buf, fmt::const_raw_wrapper r)
+{
+    void * vptr = buf.str;
+    size_t space = buf.len;
+    char * ptr = (char*) 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)
+{
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wcast-qual")
+    void * vptr = (void*)buf.str;
+    C4_SUPPRESS_WARNING_GCC_POP
+    size_t space = buf.len;
+    char * ptr = (char*) std::align(r->alignment, r->len, vptr, space);
+    C4_CHECK(ptr != nullptr);
+    C4_CHECK(ptr >= buf.begin() && ptr <= buf.end());
+    C4_SUPPRESS_WARNING_GCC_PUSH
+    #if defined(__GNUC__) && __GNUC__ > 9
+    C4_SUPPRESS_WARNING_GCC("-Wanalyzer-null-argument")
+    #endif
+    memcpy(r->buf, ptr, r->len);
+    C4_SUPPRESS_WARNING_GCC_POP
+    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 {
+
+
+/** 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 = static_cast<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 <<= 1u; // 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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+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)
+{
+    // alignment must be nonzero and a power of 2
+    C4_CHECK(alignment > 0 && (alignment & (alignment - 1u)) == 0);
+    // NOTE: alignment needs to be sized in multiples of sizeof(void*)
+    if(C4_UNLIKELY(alignment < sizeof(void*)))
+        alignment = sizeof(void*);
+    static_assert((sizeof(void*) & (sizeof(void*)-1u)) == 0, "sizeof(void*) must be a power of 2");
+    C4_CHECK(((alignment & (sizeof(void*) - 1u))) == 0u);
+    void *mem;
+#if defined(C4_WIN) || defined(C4_XBOX)
+    mem = ::_aligned_malloc(size, alignment);
+    C4_CHECK(mem != nullptr || size == 0);
+#elif defined(C4_POSIX) || defined(C4_IOS) || defined(C4_MACOS)
+    int ret = ::posix_memalign(&mem, alignment, size);
+    if(C4_UNLIKELY(ret))
+    {
+        C4_ASSERT(ret != EINVAL); // this was already handled above
+        if(ret == ENOMEM)
+        {
+            C4_ERROR("There was insufficient memory to fulfill the "
+                     "allocation request of %zu bytes (alignment=%lu)", size, size);
+        }
+        return nullptr;
+    }
+#elif defined(C4_ARM) || defined(C4_ANDROID)
+    // 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);
+#else
+    (void)size;
+    (void)alignment;
+    mem = nullptr;
+    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");
+    }
+    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");
+    }
+    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
+ *
+ * */
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+size_t decode_code_point(uint8_t *C4_RESTRICT buf, size_t buflen, const uint32_t code)
+{
+    C4_ASSERT(buf);
+    C4_ASSERT(buflen >= 4);
+    C4_UNUSED(buflen);
+    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 >> 6u));            /* 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 >> 12u)));                  /* 1110xxxx */
+        buf[1] = (uint8_t)(UINT32_C(0x80) | ((code >>  6u) & 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 >> 18u)));                  /* 11110xxx */
+        buf[1] = (uint8_t)(UINT32_C(0x80) | ((code >> 12u) & UINT32_C(0x3f))); /* 10xxxxxx */
+        buf[2] = (uint8_t)(UINT32_C(0x80) | ((code >>  6u) & 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);
+    C4_ASSERT(code_point.len > 0);
+    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);
+}
+
+size_t first_non_bom(csubstr s)
+{
+    #define c4check2_(s, c0, c1)         ((s).len >= 2) && (((s).str[0] == (c0)) && ((s).str[1] == (c1)))
+    #define c4check3_(s, c0, c1, c2)     ((s).len >= 3) && (((s).str[0] == (c0)) && ((s).str[1] == (c1)) && ((s).str[2] == (c2)))
+    #define c4check4_(s, c0, c1, c2, c3) ((s).len >= 4) && (((s).str[0] == (c0)) && ((s).str[1] == (c1)) && ((s).str[2] == (c2)) && ((s).str[3] == (c3)))
+    // see https://en.wikipedia.org/wiki/Byte_order_mark#Byte-order_marks_by_encoding
+    if(s.len < 2u)
+        return false;
+    else if(c4check3_(s, '\xef', '\xbb', '\xbf')) // UTF-8
+        return 3u;
+    else if(c4check4_(s, '\x00', '\x00', '\xfe', '\xff')) // UTF-32BE
+        return 4u;
+    else if(c4check4_(s, '\xff', '\xfe', '\x00', '\x00')) // UTF-32LE
+        return 4u;
+    else if(c4check2_(s, '\xfe', '\xff')) // UTF-16BE
+        return 2u;
+    else if(c4check2_(s, '\xff', '\xfe')) // UTF-16BE
+        return 2u;
+    else if(c4check3_(s, '\x2b', '\x2f', '\x76')) // UTF-7
+        return 3u;
+    else if(c4check3_(s, '\xf7', '\x64', '\x4c')) // UTF-1
+        return 3u;
+    else if(c4check4_(s, '\xdd', '\x73', '\x66', '\x73')) // UTF-EBCDIC
+        return 4u;
+    else if(c4check3_(s, '\x0e', '\xfe', '\xff')) // SCSU
+        return 3u;
+    else if(c4check3_(s, '\xfb', '\xee', '\x28')) // BOCU-1
+        return 3u;
+    else if(c4check4_(s, '\x84', '\x31', '\x95', '\x33')) // GB18030
+        return 4u;
+    return 0u;
+    #undef c4check2_
+    #undef c4check3_
+    #undef c4check4_
+}
+
+substr get_bom(substr s)
+{
+    return s.first(first_non_bom(s));
+}
+csubstr get_bom(csubstr s)
+{
+    return s.first(first_non_bom(s));
+}
+substr skip_bom(substr s)
+{
+    return s.sub(first_non_bom(s));
+}
+csubstr skip_bom(csubstr s)
+{
+    return s.sub(first_non_bom(s));
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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'
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#   pragma GCC diagnostic ignored "-Wchar-subscripts"
+#   pragma GCC diagnostic ignored "-Wtype-limits"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+// NOLINTBEGIN(bugprone-signed-char-misuse,cert-str34-c,hicpp-signed-bitwise)
+
+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_[(unsigned)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_[(unsigned)c2s];
+        C4_CHECK((size_t)s2c == i);
+    }
+}
+#endif
+} // namespace detail
+
+
+bool base64_valid(csubstr encoded)
+{
+    if((encoded.len & size_t(3u)) != size_t(0)) // (encoded.len % 4u)
+        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 = (const 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 & 3u) == 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
+
+// NOLINTEND(bugprone-signed-char-misuse,cert-str34-c,hicpp-signed-bitwise)
+
+#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(...) (void)fprintf(stderr, __VA_ARGS__); (void)fflush(stderr)
+#define C4_LOGF_WARN(...) (void)fprintf(stderr, __VA_ARGS__); (void)fflush(stderr)
+#define C4_LOGP(msg, ...) (void)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"
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wformat-nonliteral"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+// NOLINTBEGIN(*use-anonymous-namespace*,cert-dcl50-cpp)
+
+
+//-----------------------------------------------------------------------------
+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); // NOLINT(clang-analyzer-valist.Uninitialized)
+        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);
+        }
+    }
+
+    if(s_error_flags & ON_ERROR_THROW)
+    {
+#if defined(C4_EXCEPTIONS_ENABLED) && defined(C4_ERROR_THROWS_EXCEPTION)
+        throw std::runtime_error(buf);
+#endif
+    }
+
+    if(s_error_flags & ON_ERROR_ABORT)
+    {
+        abort();
+    }
+
+    abort(); // abort anyway, in case nothing was set
+    C4_UNREACHABLE_AFTER_ERR();
+}
+
+//-----------------------------------------------------------------------------
+
+void handle_warning(srcloc where, const char *fmt, ...)
+{
+    va_list args;
+    char buf[1024];
+    va_start(args, fmt);
+    int ret = vsnprintf(buf, sizeof(buf), fmt, args); // NOLINT(clang-analyzer-valist.Uninitialized)
+    if(ret+1 > (int)sizeof(buf))
+        buf[sizeof(buf) - 1] = '\0'; // truncate
+    else if(ret < 0)
+        buf[0] = '\0'; // output/format error
+    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);
+    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);
+#elif ! defined(C4_ERROR_SHOWS_FUNC)
+    C4_LOGF_WARN("WARNING: %s\n", buf);
+#endif
+}
+
+//-----------------------------------------------------------------------------
+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;
+        C4_SUPPRESS_WARNING_GCC_PUSH
+        #if defined(__GNUC__) && __GNUC__ > 9
+        C4_SUPPRESS_WARNING_GCC("-Wanalyzer-fd-leak")
+        #endif
+        //! @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); // NOLINT
+        if (status_fd == -1)
+            return false;
+        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); // NOLINT
+        }
+        close(status_fd);
+        C4_SUPPRESS_WARNING_GCC_POP
+    }
+    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);
+    (void)junk;
+
+    // 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
+
+// NOLINTEND(*use-anonymous-namespace*,cert-dcl50-cpp)
+
+#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/fwd.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/fwd.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_FWD_HPP_
+#define _C4_YML_FWD_HPP_
+
+/** @file fwd.hpp forward declarations */
+
+namespace c4 {
+namespace yml {
+
+struct NodeScalar;
+struct NodeInit;
+struct NodeData;
+struct NodeType;
+class NodeRef;
+class ConstNodeRef;
+class Tree;
+struct ReferenceResolver;
+template<class EventHandler> class ParseEngine;
+struct EventHandlerTree;
+using Parser = ParseEngine<EventHandlerTree>;
+
+} // namespace c4
+} // namespace yml
+
+#endif /* _C4_YML_FWD_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/fwd.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/version.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/version.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_VERSION_HPP_
+#define _C4_YML_VERSION_HPP_
+
+/** @file version.hpp */
+
+#define RYML_VERSION "0.9.0"
+#define RYML_VERSION_MAJOR 0
+#define RYML_VERSION_MINOR 9
+#define RYML_VERSION_PATCH 0
+
+// 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_ */
+
+
+namespace c4 {
+namespace yml {
+
+RYML_EXPORT csubstr version();
+RYML_EXPORT int version_major();
+RYML_EXPORT int version_minor();
+RYML_EXPORT int version_patch();
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_VERSION_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/version.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_
+
+/** @file common.hpp Common utilities and infrastructure used by ryml. */
+
+//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/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/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_ */
+
+// 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_ */
+
+
+#if defined(C4_MSVC) || defined(C4_MINGW)
+//included above:
+//#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+
+
+
+//-----------------------------------------------------------------------------
+
+#ifndef RYML_ERRMSG_SIZE
+/// size for the error message buffer
+#define RYML_ERRMSG_SIZE (1024)
+#endif
+
+#ifndef RYML_LOGBUF_SIZE
+/// size for the buffer used to format individual values to string
+/// while preparing an error message. This is only used for formatting
+/// individual values in the message; final messages will be larger
+/// than this value (see @ref RYML_ERRMSG_SIZE). This is also used for
+/// the detailed debug log messages when RYML_DBG is defined.
+#define RYML_LOGBUF_SIZE (256)
+#endif
+
+#ifndef RYML_LOGBUF_SIZE_MAX
+/// size for the fallback larger log buffer. When @ref
+/// RYML_LOGBUF_SIZE is not large enough to convert a value to string,
+/// then temporary stack memory is allocated up to
+/// RYML_LOGBUF_SIZE_MAX. This limit is in place to prevent a stack
+/// overflow. If the printed value requires more than
+/// RYML_LOGBUF_SIZE_MAX, the value is silently skipped.
+#define RYML_LOGBUF_SIZE_MAX (1024)
+#endif
+
+#ifndef RYML_LOCATIONS_SMALL_THRESHOLD
+/// threshold at which a location search will revert from linear to
+/// binary search.
+#define RYML_LOCATIONS_SMALL_THRESHOLD (30)
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Specify groups to have a predefined topic order in doxygen:
+
+/** @defgroup doc_quickstart Quickstart
+ *
+ * Example code for every feature.
+ */
+
+/** @defgroup doc_parse Parse utilities
+ * @see sample::sample_parse_in_place
+ * @see sample::sample_parse_in_arena
+ * @see sample::sample_parse_file
+ * @see sample::sample_parse_reuse_tree
+ * @see sample::sample_parse_reuse_parser
+ * @see sample::sample_parse_reuse_tree_and_parser
+ * @see sample::sample_location_tracking
+ */
+
+/** @defgroup doc_emit Emit utilities
+ *
+ * Utilities to emit YAML and JSON, either to a memory buffer or to a
+ * file or ostream-like class.
+ *
+ * @see sample::sample_emit_to_container
+ * @see sample::sample_emit_to_stream
+ * @see sample::sample_emit_to_file
+ * @see sample::sample_emit_nested_node
+ * @see sample::sample_emit_style
+ */
+
+/** @defgroup doc_node_type Node types
+ */
+
+/** @defgroup doc_tree Tree utilities
+ * @see sample::sample_quick_overview
+ * @see sample::sample_iterate_trees
+ * @see sample::sample_create_trees
+ * @see sample::sample_tree_arena
+ *
+ * @see sample::sample_static_trees
+ * @see sample::sample_location_tracking
+ *
+ * @see sample::sample_docs
+ * @see sample::sample_anchors_and_aliases
+ * @see sample::sample_tags
+ */
+
+/** @defgroup doc_node_classes Node classes
+ *
+ * High-level node classes.
+ *
+ * @see sample::sample_quick_overview
+ * @see sample::sample_iterate_trees
+ * @see sample::sample_create_trees
+ * @see sample::sample_tree_arena
+ */
+
+/** @defgroup doc_callbacks Callbacks for errors and allocation
+ *
+ * Functions called by ryml to allocate/free memory and to report
+ * errors.
+ *
+ * @see sample::sample_error_handler
+ * @see sample::sample_global_allocator
+ * @see sample::sample_per_tree_allocator
+ */
+
+/** @defgroup doc_serialization Serialization/deserialization
+ *
+ * Contains information on how to serialize and deserialize
+ * fundamental types, user scalar types, user container types and
+ * interop with std scalar/container types.
+ *
+ */
+
+/** @defgroup doc_ref_utils Anchor/Reference utilities
+ *
+ * @see sample::sample_anchors_and_aliases
+ * */
+
+/** @defgroup doc_tag_utils Tag utilities
+ * @see sample::sample_tags
+ */
+
+/** @defgroup doc_preprocessors Preprocessors
+ *
+ * Functions for preprocessing YAML prior to parsing.
+ */
+
+
+//-----------------------------------------------------------------------------
+
+// document macros for doxygen
+#ifdef __DOXYGEN__ // defined in Doxyfile::PREDEFINED
+
+/** define this macro with a boolean value to enable/disable
+ * assertions to check preconditions and assumptions throughout the
+ * codebase; this causes a slowdown of the code, and larger code
+ * size. By default, this macro is defined unless NDEBUG is defined
+ * (see C4_USE_ASSERT); as a result, by default this macro is truthy
+ * only in debug builds. */
+#   define RYML_USE_ASSERT
+
+/** (Undefined by default) Define this macro to disable ryml's default
+ * implementation of the callback functions; see @ref c4::yml::Callbacks  */
+#   define RYML_NO_DEFAULT_CALLBACKS
+
+/** (Undefined by default) When this macro is defined (and
+ * @ref RYML_NO_DEFAULT_CALLBACKS is not defined), the default error
+ * handler will throw C++ exceptions of type `std::runtime_error`. */
+#   define RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS
+
+/** Conditionally expands to `noexcept` when @ref RYML_USE_ASSERT is 0 and
+ * is empty otherwise. The user is unable to override this macro. */
+#   define RYML_NOEXCEPT
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @cond dev*/
+#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)
+#   define _RYML_CB_ASSERT(cb, cond) _RYML_CB_CHECK((cb), (cond))
+#   define _RYML_CB_ASSERT_(cb, cond, loc) _RYML_CB_CHECK((cb), (cond), (loc))
+#   define RYML_NOEXCEPT
+#else
+#   define RYML_ASSERT(cond)
+#   define RYML_ASSERT_MSG(cond, msg)
+#   define _RYML_CB_ASSERT(cb, cond)
+#   define _RYML_CB_ASSERT_(cb, cond, loc)
+#   define RYML_NOEXCEPT noexcept
+#endif
+
+#define RYML_DEPRECATED(msg) C4_DEPRECATED(msg)
+
+#define RYML_CHECK(cond)                                                \
+    do {                                                                \
+        if(C4_UNLIKELY(!(cond)))                                        \
+        {                                                               \
+            RYML_DEBUG_BREAK();                                         \
+            c4::yml::error("check failed: " #cond, c4::yml::Location(__FILE__, __LINE__, 0)); \
+            C4_UNREACHABLE_AFTER_ERR();                                 \
+        }                                                               \
+    } while(0)
+
+#define RYML_CHECK_MSG(cond, msg)                                       \
+    do                                                                  \
+    {                                                                   \
+        if(C4_UNLIKELY(!(cond)))                                        \
+        {                                                               \
+            RYML_DEBUG_BREAK();                                         \
+            c4::yml::error(msg ": check failed: " #cond, c4::yml::Location(__FILE__, __LINE__, 0)); \
+            C4_UNREACHABLE_AFTER_ERR();                                 \
+        }                                                               \
+    } while(0)
+
+#if defined(RYML_DBG) && !defined(NDEBUG) && !defined(C4_NO_DEBUG_BREAK)
+#   define RYML_DEBUG_BREAK()                               \
+    do {                                                    \
+        if(c4::get_error_flags() & c4::ON_ERROR_DEBUGBREAK) \
+        {                                                   \
+            C4_DEBUG_BREAK();                               \
+        }                                                   \
+    } while(0)
+#else
+#   define RYML_DEBUG_BREAK()
+#endif
+
+/** @endcond */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+namespace yml {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+
+#ifndef RYML_ID_TYPE
+/** The type of a node id in the YAML tree. In the future, the default
+ * will likely change to int32_t, which was observed to be faster.
+ * @see id_type */
+#define RYML_ID_TYPE size_t
+#endif
+
+
+/** The type of a node id in the YAML tree; to override the default
+ * type, define the macro @ref RYML_ID_TYPE to a suitable integer
+ * type. */
+using id_type = RYML_ID_TYPE;
+static_assert(std::is_integral<id_type>::value, "id_type must be an integer type");
+
+
+C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wuseless-cast")
+enum : id_type {
+    /** an index to none */
+    NONE = id_type(-1),
+};
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+
+enum : size_t {
+    /** a null string position */
+    npos = 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() = default;
+    //! 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) {}
+};
+static_assert(std::is_trivial<LineCol>::value, "LineCol not trivial");
+static_assert(std::is_standard_layout<LineCol>::value, "Location not trivial");
+
+
+//! a source file position
+struct RYML_EXPORT Location
+{
+    //! number of bytes from the beginning of the source buffer
+    size_t offset;
+    //! line
+    size_t line;
+    //! column
+    size_t col;
+    //! file name
+    csubstr name;
+
+    operator bool () const { return !name.empty() || line != 0 || offset != 0 || col != 0; }
+    operator LineCol const& () const { return reinterpret_cast<LineCol const&>(*this); } // NOLINT
+
+    Location() = default;
+    Location(                         size_t l, size_t c) : offset( ), line(l), col(c), name( ) {}
+    Location(               size_t b, size_t l, size_t c) : offset(b), line(l), col(c), name( ) {}
+    Location(    csubstr n,           size_t l, size_t c) : offset( ), line(l), col(c), name(n) {}
+    Location(    csubstr n, size_t b, size_t l, size_t c) : offset(b), line(l), col(c), name(n) {}
+    Location(const char *n,           size_t l, size_t c) : offset( ), line(l), col(c), name(to_csubstr(n)) {}
+    Location(const char *n, size_t b, size_t l, size_t c) : offset(b), line(l), col(c), name(to_csubstr(n)) {}
+};
+static_assert(std::is_standard_layout<Location>::value, "Location not trivial");
+
+
+//-----------------------------------------------------------------------------
+
+/** @addtogroup doc_callbacks
+ *
+ * @{ */
+
+struct Callbacks;
+
+
+/** set the global callbacks for the library; after a call to this
+ * function, these callbacks will be used by newly created objects
+ * (unless they are copying older objects with different
+ * callbacks). If @ref RYML_NO_DEFAULT_CALLBACKS is defined, it is
+ * mandatory to call this function prior to using any other library
+ * facility.
+ *
+ * @warning This function is NOT thread-safe.
+ *
+ * @warning the error callback must never return: see @ref pfn_error
+ * for more details */
+RYML_EXPORT void set_callbacks(Callbacks const& c);
+
+/** get the global callbacks
+ * @warning This function is not thread-safe. */
+RYML_EXPORT Callbacks const& get_callbacks();
+
+/** set the global callbacks back to their defaults ()
+ * @warning This function is not thread-safe. */
+RYML_EXPORT void reset_callbacks();
+
+
+/** the type of the function used to report errors
+ *
+ * @warning When given by the user, this function MUST interrupt
+ * execution, typically by either throwing an exception, or using
+ * `std::longjmp()` ([see
+ * documentation](https://en.cppreference.com/w/cpp/utility/program/setjmp))
+ * or by calling `std::abort()`. If the function returned, the parser
+ * would enter into an infinite loop, or the program may crash. */
+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; ryml will only
+ * allocate memory through this callback. */
+using pfn_allocate = void* (*)(size_t len, void* hint, void *user_data);
+
+
+/** the type of the function used to free memory; ryml will only free
+ * memory through this callback. */
+using pfn_free = void (*)(void* mem, size_t size, void *user_data);
+
+
+/** a c-style callbacks class. Can be used globally by the library
+ * and/or locally by @ref Tree and @ref Parser objects. */
+struct RYML_EXPORT Callbacks
+{
+    void *       m_user_data;
+    pfn_allocate m_allocate;
+    pfn_free     m_free;
+    pfn_error    m_error;
+
+    /** Construct an object with the default callbacks. If
+     * @ref RYML_NO_DEFAULT_CALLBACKS is defined, the object will have null
+     * members.*/
+    Callbacks() noexcept;
+
+    /** Construct an object with the given callbacks.
+     *
+     * @param user_data Data to be forwarded in every call to a callback.
+     *
+     * @param alloc A pointer to an allocate function. Unless
+     *        @ref RYML_NO_DEFAULT_CALLBACKS is defined, when this
+     *        parameter is null, will fall back to ryml's default
+     *        alloc implementation.
+     *
+     * @param free A pointer to a free function. Unless
+     *        @ref RYML_NO_DEFAULT_CALLBACKS is defined, when this
+     *        parameter is null, will fall back to ryml's default free
+     *        implementation.
+     *
+     * @param error A pointer to an error function, which must never
+     *        return (see @ref pfn_error). Unless
+     *        @ref RYML_NO_DEFAULT_CALLBACKS is defined, when this
+     *        parameter is null, will fall back to ryml's default
+     *        error implementation.
+     */
+    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);
+    }
+};
+
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+typedef enum {
+    NOBOM,
+    UTF8,
+    UTF16LE,
+    UTF16BE,
+    UTF32LE,
+    UTF32BE,
+} Encoding_e;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/// @cond dev
+
+// BEWARE! MSVC requires that [[noreturn]] appears before RYML_EXPORT
+[[noreturn]] RYML_EXPORT void error(Callbacks const& cb, const char *msg, size_t msg_len, Location loc);
+[[noreturn]] RYML_EXPORT void error(const char *msg, size_t msg_len, Location loc);
+
+[[noreturn]] inline void error(const char *msg, size_t msg_len)
+{
+    error(msg, msg_len, Location{});
+}
+template<size_t N>
+[[noreturn]] inline void error(const char (&msg)[N], Location loc)
+{
+    error(msg, N-1, loc);
+}
+template<size_t N>
+[[noreturn]] inline void error(const char (&msg)[N])
+{
+    error(msg, N-1, Location{});
+}
+
+#define _RYML_CB_ERR(cb, msg_literal)                                   \
+    _RYML_CB_ERR_(cb, msg_literal, c4::yml::Location(__FILE__, 0, __LINE__, 0))
+#define _RYML_CB_CHECK(cb, cond)                                        \
+    _RYML_CB_CHECK_(cb, cond, c4::yml::Location(__FILE__, 0, __LINE__, 0))
+#define _RYML_CB_ERR_(cb, msg_literal, loc)                             \
+do                                                                      \
+{                                                                       \
+    const char msg[] = msg_literal;                                     \
+    RYML_DEBUG_BREAK();                                                 \
+    c4::yml::error((cb), msg, sizeof(msg)-1, loc);                      \
+    C4_UNREACHABLE_AFTER_ERR();                                         \
+} while(0)
+#define _RYML_CB_CHECK_(cb, cond, loc)                                  \
+    do                                                                  \
+    {                                                                   \
+        if(C4_UNLIKELY(!(cond)))                                        \
+        {                                                               \
+            const char msg[] = "check failed: " #cond;                  \
+            RYML_DEBUG_BREAK();                                         \
+            c4::yml::error((cb), msg, sizeof(msg)-1, loc);              \
+            C4_UNREACHABLE_AFTER_ERR();                                 \
+        }                                                               \
+    } while(0)
+#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)
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+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;
+
+
+/** Abstracts the fact that a scalar filter result may not fit in the
+ * intended memory. */
+struct FilterResult
+{
+    C4_ALWAYS_INLINE bool valid() const noexcept { return str.str != nullptr; }
+    C4_ALWAYS_INLINE size_t required_len() const noexcept { return str.len; }
+    C4_ALWAYS_INLINE csubstr get() const { RYML_ASSERT(valid()); return str; }
+    csubstr str;
+};
+/** Abstracts the fact that a scalar filter result may not fit in the
+ * intended memory. */
+struct FilterResultExtending
+{
+    C4_ALWAYS_INLINE bool valid() const noexcept { return str.str != nullptr; }
+    C4_ALWAYS_INLINE size_t required_len() const noexcept { return reqlen; }
+    C4_ALWAYS_INLINE csubstr get() const { RYML_ASSERT(valid()); return str; }
+    csubstr str;
+    size_t reqlen;
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+namespace detail {
+// is there a better way to do this?
+template<int8_t signedval, uint8_t unsignedval>
+struct _charconstant_t
+    : public std::conditional<std::is_signed<char>::value,
+                              std::integral_constant<int8_t, static_cast<int8_t>(unsignedval)>,
+                              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_) { C4_ASSERT(buf.str); }
+    void append(csubstr s)
+    {
+        C4_ASSERT(!s.overlaps(buf));
+        C4_ASSERT(s.str || !s.len);
+        if(s.len && pos + s.len <= buf.len)
+        {
+            C4_ASSERT(s.str);
+            memcpy(buf.str + pos, s.str, s.len);
+        }
+        pos += s.len;
+    }
+    void append(char c)
+    {
+        C4_ASSERT(buf.str);
+        if(pos < buf.len)
+            buf.str[pos] = c;
+        ++pos;
+    }
+    void append_n(char c, size_t numtimes)
+    {
+        C4_ASSERT(buf.str);
+        if(numtimes && 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() const { return pos < buf.len ? buf.sub(pos) : buf.last(0); }
+
+    size_t advance(size_t more) { pos += more; return pos; }
+};
+} // namespace detail
+
+
+namespace detail {
+// dumpfn is a function abstracting prints to terminal (or to string).
+template<class DumpFn, class ...Args>
+C4_NO_INLINE void _dump(DumpFn &&dumpfn, csubstr fmt, Args&& ...args)
+{
+    DumpResults results;
+    // try writing everything:
+    {
+        // buffer for converting individual arguments. it is defined
+        // in a child scope to free it in case the buffer is too small
+        // for any of the arguments.
+        char writebuf[RYML_LOGBUF_SIZE];
+        results = format_dump_resume(std::forward<DumpFn>(dumpfn), writebuf, fmt, std::forward<Args>(args)...);
+    }
+    // if any of the arguments failed to fit the buffer, allocate a
+    // larger buffer (up to a limit) and resume writing.
+    //
+    // results.bufsize is set to the size of the largest element
+    // serialized. Eg int(1) will require 1 byte.
+    if(C4_UNLIKELY(results.bufsize > RYML_LOGBUF_SIZE))
+    {
+        const size_t bufsize = results.bufsize <= RYML_LOGBUF_SIZE_MAX ? results.bufsize : RYML_LOGBUF_SIZE_MAX;
+        #ifdef C4_MSVC
+        substr largerbuf = {static_cast<char*>(_alloca(bufsize)), bufsize};
+        #else
+        substr largerbuf = {static_cast<char*>(alloca(bufsize)), bufsize};
+        #endif
+        results = format_dump_resume(std::forward<DumpFn>(dumpfn), results, largerbuf, fmt, std::forward<Args>(args)...);
+    }
+}
+template<class ...Args>
+C4_NORETURN C4_NO_INLINE void _report_err(Callbacks const& C4_RESTRICT callbacks, csubstr fmt, Args const& C4_RESTRICT ...args)
+{
+    char errmsg[RYML_ERRMSG_SIZE] = {0};
+    detail::_SubstrWriter writer(errmsg);
+    auto dumpfn = [&writer](csubstr s){ writer.append(s); };
+    _dump(dumpfn, fmt, args...);
+    writer.append('\n');
+    const size_t len = writer.pos < RYML_ERRMSG_SIZE ? writer.pos : RYML_ERRMSG_SIZE;
+    callbacks.m_error(errmsg, len, {}, callbacks.m_user_data);
+    C4_UNREACHABLE_AFTER_ERR();
+}
+} // namespace detail
+
+
+inline csubstr _c4prc(const char &C4_RESTRICT c) // pass by reference!
+{
+    switch(c)
+    {
+    case '\n': return csubstr("\\n");
+    case '\t': return csubstr("\\t");
+    case '\0': return csubstr("\\0");
+    case '\r': return csubstr("\\r");
+    case '\f': return csubstr("\\f");
+    case '\b': return csubstr("\\b");
+    case '\v': return csubstr("\\v");
+    case '\a': return csubstr("\\a");
+    default: return csubstr(&c, 1);
+    }
+}
+
+/// @endcond
+
+C4_SUPPRESS_WARNING_GCC_POP
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_COMMON_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/common.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/node_type.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef C4_YML_NODE_TYPE_HPP_
+#define C4_YML_NODE_TYPE_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
+
+C4_SUPPRESS_WARNING_MSVC_PUSH
+C4_SUPPRESS_WARNING_GCC_CLANG_PUSH
+C4_SUPPRESS_WARNING_GCC_CLANG("-Wold-style-cast")
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_node_type
+ *
+ * @{
+ */
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** the integral type necessary to cover all the bits for NodeType_e */
+using type_bits = uint32_t;
+
+
+/** a bit mask for marking node types and styles */
+typedef enum : type_bits {
+    #define __(v) (type_bits(1) << v) // a convenience define, undefined below // NOLINT
+    NOTYPE  = 0,         ///< no node type or style is set
+    KEY     = __(0),     ///< is member of a map
+    VAL     = __(1),     ///< a scalar: has a scalar (ie string) value, possibly empty. must be a leaf node, and cannot be MAP or SEQ
+    MAP     = __(2),     ///< a map: a parent of KEYVAL/KEYSEQ/KEYMAP nodes
+    SEQ     = __(3),     ///< a seq: a parent of VAL/SEQ/MAP nodes
+    DOC     = __(4),     ///< a document
+    STREAM  = __(5)|SEQ, ///< a stream: a seq of docs
+    KEYREF  = __(6),     ///< a *reference: the key references an &anchor
+    VALREF  = __(7),     ///< a *reference: the val references an &anchor
+    KEYANCH = __(8),     ///< the key has an &anchor
+    VALANCH = __(9),     ///< the val has an &anchor
+    KEYTAG  = __(10),    ///< the key has a tag
+    VALTAG  = __(11),    ///< the val has a tag
+    KEYNIL  = __(12),    ///< the key is null (eg `{ : b}` results in a null key)
+    VALNIL  = __(13),    ///< the val is null (eg `{a : }` results in a null val)
+    _TYMASK = __(14)-1,  ///< all the bits up to here
+    //
+    // unfiltered flags:
+    //
+    KEY_UNFILT  = __(14), ///< the key scalar was left unfiltered; the parser was set not to filter. @see ParserOptions
+    VAL_UNFILT  = __(15), ///< the val scalar was left unfiltered; the parser was set not to filter. @see ParserOptions
+    //
+    // style flags:
+    //
+    FLOW_SL     = __(16), ///< mark container with single-line flow style (seqs as '[val1,val2], maps as '{key: val,key2: val2}')
+    FLOW_ML     = __(17), ///< (NOT IMPLEMENTED, work in progress) mark container with multi-line flow style (seqs as '[\n  val1,\n  val2\n], maps as '{\n  key: val,\n  key2: val2\n}')
+    BLOCK       = __(18), ///< mark container with block style (seqs as '- val\n', maps as 'key: val')
+    KEY_LITERAL = __(19), ///< mark key scalar as multiline, block literal |
+    VAL_LITERAL = __(20), ///< mark val scalar as multiline, block literal |
+    KEY_FOLDED  = __(21), ///< mark key scalar as multiline, block folded >
+    VAL_FOLDED  = __(22), ///< mark val scalar as multiline, block folded >
+    KEY_SQUO    = __(23), ///< mark key scalar as single quoted '
+    VAL_SQUO    = __(24), ///< mark val scalar as single quoted '
+    KEY_DQUO    = __(25), ///< mark key scalar as double quoted "
+    VAL_DQUO    = __(26), ///< mark val scalar as double quoted "
+    KEY_PLAIN   = __(27), ///< mark key scalar as plain scalar (unquoted, even when multiline)
+    VAL_PLAIN   = __(28), ///< mark val scalar as plain scalar (unquoted, even when multiline)
+    //
+    // type combination masks:
+    //
+    KEYVAL  = KEY|VAL,
+    KEYSEQ  = KEY|SEQ,
+    KEYMAP  = KEY|MAP,
+    DOCMAP  = DOC|MAP,
+    DOCSEQ  = DOC|SEQ,
+    DOCVAL  = DOC|VAL,
+    //
+    // style combination masks:
+    //
+    SCALAR_LITERAL = KEY_LITERAL|VAL_LITERAL,
+    SCALAR_FOLDED  = KEY_FOLDED|VAL_FOLDED,
+    SCALAR_SQUO    = KEY_SQUO|VAL_SQUO,
+    SCALAR_DQUO    = KEY_DQUO|VAL_DQUO,
+    SCALAR_PLAIN   = KEY_PLAIN|VAL_PLAIN,
+    KEYQUO         = KEY_SQUO|KEY_DQUO|KEY_FOLDED|KEY_LITERAL, ///< key style is one of ', ", > or |
+    VALQUO         = VAL_SQUO|VAL_DQUO|VAL_FOLDED|VAL_LITERAL, ///< val style is one of ', ", > or |
+    KEY_STYLE      = KEY_LITERAL|KEY_FOLDED|KEY_SQUO|KEY_DQUO|KEY_PLAIN, ///< mask of all the scalar styles for key (not container styles!)
+    VAL_STYLE      = VAL_LITERAL|VAL_FOLDED|VAL_SQUO|VAL_DQUO|VAL_PLAIN, ///< mask of all the scalar styles for val (not container styles!)
+    SCALAR_STYLE   = KEY_STYLE|VAL_STYLE,
+    CONTAINER_STYLE_FLOW  = FLOW_SL|FLOW_ML,
+    CONTAINER_STYLE_BLOCK = BLOCK,
+    CONTAINER_STYLE       = FLOW_SL|FLOW_ML|BLOCK,
+    STYLE          = SCALAR_STYLE | CONTAINER_STYLE,
+    //
+    // mixed masks
+    _KEYMASK = KEY | KEYQUO | KEYANCH | KEYREF | KEYTAG,
+    _VALMASK = VAL | VALQUO | VALANCH | VALREF | VALTAG,
+    #undef __
+} NodeType_e;
+
+constexpr C4_ALWAYS_INLINE C4_CONST NodeType_e operator|  (NodeType_e lhs, NodeType_e rhs) noexcept { return (NodeType_e)(((type_bits)lhs) | ((type_bits)rhs)); }
+constexpr C4_ALWAYS_INLINE C4_CONST NodeType_e operator&  (NodeType_e lhs, NodeType_e rhs) noexcept { return (NodeType_e)(((type_bits)lhs) & ((type_bits)rhs)); }
+constexpr C4_ALWAYS_INLINE C4_CONST NodeType_e operator>> (NodeType_e bits, uint32_t n) noexcept { return (NodeType_e)(((type_bits)bits) >> n); }
+constexpr C4_ALWAYS_INLINE C4_CONST NodeType_e operator<< (NodeType_e bits, uint32_t n) noexcept { return (NodeType_e)(((type_bits)bits) << n); }
+constexpr C4_ALWAYS_INLINE C4_CONST NodeType_e operator~  (NodeType_e bits) noexcept { return (NodeType_e)(~(type_bits)bits); }
+C4_ALWAYS_INLINE NodeType_e& operator&= (NodeType_e &subject, NodeType_e bits) noexcept { subject = (NodeType_e)((type_bits)subject & (type_bits)bits); return subject; }
+C4_ALWAYS_INLINE NodeType_e& operator|= (NodeType_e &subject, NodeType_e bits) noexcept { subject = (NodeType_e)((type_bits)subject | (type_bits)bits); return subject; }
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** wraps a NodeType_e element with some syntactic sugar and predicates */
+struct RYML_EXPORT NodeType
+{
+public:
+
+    NodeType_e type;
+
+public:
+
+    C4_ALWAYS_INLINE NodeType() noexcept : type(NOTYPE) {}
+    C4_ALWAYS_INLINE NodeType(NodeType_e t) noexcept : type(t) {}
+    C4_ALWAYS_INLINE NodeType(type_bits t) noexcept : type((NodeType_e)t) {}
+
+    C4_ALWAYS_INLINE bool has_any(NodeType_e t) const noexcept { return (type & t) != 0u; }
+    C4_ALWAYS_INLINE bool has_all(NodeType_e t) const noexcept { return (type & t) == t; }
+    C4_ALWAYS_INLINE bool has_none(NodeType_e t) const noexcept { return (type & t) == 0; }
+
+    C4_ALWAYS_INLINE void set(NodeType_e t) noexcept { type = t; }
+    C4_ALWAYS_INLINE void add(NodeType_e t) noexcept { type = (type|t); }
+    C4_ALWAYS_INLINE void rem(NodeType_e t) noexcept { type = (type & ~t); }
+    C4_ALWAYS_INLINE void addrem(NodeType_e bits_to_add, NodeType_e bits_to_remove) noexcept { type |= bits_to_add; type &= ~bits_to_remove; }
+
+    C4_ALWAYS_INLINE void clear() noexcept { type = NOTYPE; }
+
+public:
+
+    C4_ALWAYS_INLINE operator NodeType_e      & C4_RESTRICT ()       noexcept { return type; }
+    C4_ALWAYS_INLINE operator NodeType_e const& C4_RESTRICT () const noexcept { return type; }
+
+public:
+
+    /** @name node type queries
+     * @{ */
+
+    /** return a preset string based on the node type */
+    C4_ALWAYS_INLINE const char *type_str() const noexcept { return type_str(type); }
+    /** return a preset string based on the node type */
+    static const char* type_str(NodeType_e t) noexcept;
+
+    /** fill a string with the node type flags. If the string is small, returns {null, len} */
+    C4_ALWAYS_INLINE csubstr type_str(substr buf) const noexcept { return type_str(buf, type); }
+    /** fill a string with the node type flags. If the string is small, returns {null, len}  */
+    static csubstr type_str(substr buf, NodeType_e t) noexcept;
+
+public:
+
+    /** @name node type queries
+     * @{ */
+
+    C4_ALWAYS_INLINE bool is_notype()         const noexcept { return type == NOTYPE; }
+    C4_ALWAYS_INLINE bool is_stream()         const noexcept { return ((type & STREAM) == STREAM) != 0; }
+    C4_ALWAYS_INLINE bool is_doc()            const noexcept { return (type & DOC) != 0; }
+    C4_ALWAYS_INLINE bool is_container()      const noexcept { return (type & (MAP|SEQ|STREAM)) != 0; }
+    C4_ALWAYS_INLINE bool is_map()            const noexcept { return (type & MAP) != 0; }
+    C4_ALWAYS_INLINE bool is_seq()            const noexcept { return (type & SEQ) != 0; }
+    C4_ALWAYS_INLINE bool has_key()           const noexcept { return (type & KEY) != 0; }
+    C4_ALWAYS_INLINE bool has_val()           const noexcept { return (type & VAL) != 0; }
+    C4_ALWAYS_INLINE bool is_val()            const noexcept { return (type & KEYVAL) == VAL; }
+    C4_ALWAYS_INLINE bool is_keyval()         const noexcept { return (type & KEYVAL) == KEYVAL; }
+    C4_ALWAYS_INLINE bool key_is_null()       const noexcept { return (type & KEYNIL) != 0; }
+    C4_ALWAYS_INLINE bool val_is_null()       const noexcept { return (type & VALNIL) != 0; }
+    C4_ALWAYS_INLINE bool has_key_tag()       const noexcept { return (type & KEYTAG) != 0; }
+    C4_ALWAYS_INLINE bool has_val_tag()       const noexcept { return (type & VALTAG) != 0; }
+    C4_ALWAYS_INLINE bool has_key_anchor()    const noexcept { return (type & KEYANCH) != 0; }
+    C4_ALWAYS_INLINE bool has_val_anchor()    const noexcept { return (type & VALANCH) != 0; }
+    C4_ALWAYS_INLINE bool has_anchor()        const noexcept { return (type & (KEYANCH|VALANCH)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_ref()        const noexcept { return (type & KEYREF) != 0; }
+    C4_ALWAYS_INLINE bool is_val_ref()        const noexcept { return (type & VALREF) != 0; }
+    C4_ALWAYS_INLINE bool is_ref()            const noexcept { return (type & (KEYREF|VALREF)) != 0; }
+
+    C4_ALWAYS_INLINE bool is_key_unfiltered() const noexcept { return (type & (KEY_UNFILT)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_unfiltered() const noexcept { return (type & (VAL_UNFILT)) != 0; }
+
+    RYML_DEPRECATED("use has_key_anchor()")    bool is_key_anchor() const noexcept { return has_key_anchor(); }
+    RYML_DEPRECATED("use has_val_anchor()")    bool is_val_anchor() const noexcept { return has_val_anchor(); }
+    RYML_DEPRECATED("use has_anchor()")        bool is_anchor() const noexcept { return has_anchor(); }
+    RYML_DEPRECATED("use has_anchor() || is_ref()") bool is_anchor_or_ref() const noexcept { return has_anchor() || is_ref(); }
+    /** @} */
+
+public:
+
+    /** @name container+scalar style queries
+     * @{ */
+
+    C4_ALWAYS_INLINE bool is_container_styled() const noexcept { return (type & (CONTAINER_STYLE)) != 0; }
+    C4_ALWAYS_INLINE bool is_block() const noexcept { return (type & (BLOCK)) != 0; }
+    C4_ALWAYS_INLINE bool is_flow_sl() const noexcept { return (type & (FLOW_SL)) != 0; }
+    C4_ALWAYS_INLINE bool is_flow_ml() const noexcept { return (type & (FLOW_ML)) != 0; }
+    C4_ALWAYS_INLINE bool is_flow() const noexcept { return (type & (FLOW_ML|FLOW_SL)) != 0; }
+
+    C4_ALWAYS_INLINE bool is_key_styled() const noexcept { return (type & (KEY_STYLE)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_styled() const noexcept { return (type & (VAL_STYLE)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_literal() const noexcept { return (type & (KEY_LITERAL)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_literal() const noexcept { return (type & (VAL_LITERAL)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_folded() const noexcept { return (type & (KEY_FOLDED)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_folded() const noexcept { return (type & (VAL_FOLDED)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_squo() const noexcept { return (type & (KEY_SQUO)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_squo() const noexcept { return (type & (VAL_SQUO)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_dquo() const noexcept { return (type & (KEY_DQUO)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_dquo() const noexcept { return (type & (VAL_DQUO)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_plain() const noexcept { return (type & (KEY_PLAIN)) != 0; }
+    C4_ALWAYS_INLINE bool is_val_plain() const noexcept { return (type & (VAL_PLAIN)) != 0; }
+    C4_ALWAYS_INLINE bool is_key_quoted() const noexcept { return (type & KEYQUO) != 0; }
+    C4_ALWAYS_INLINE bool is_val_quoted() const noexcept { return (type & VALQUO) != 0; }
+    C4_ALWAYS_INLINE bool is_quoted() const noexcept { return (type & (KEYQUO|VALQUO)) != 0; }
+
+    C4_ALWAYS_INLINE void set_container_style(NodeType_e style) noexcept { type = ((style & CONTAINER_STYLE) | (type & ~CONTAINER_STYLE)); }
+    C4_ALWAYS_INLINE void set_key_style(NodeType_e style) noexcept { type = ((style & KEY_STYLE) | (type & ~KEY_STYLE)); }
+    C4_ALWAYS_INLINE void set_val_style(NodeType_e style) noexcept { type = ((style & VAL_STYLE) | (type & ~VAL_STYLE)); }
+
+    /** @} */
+
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @name scalar style helpers
+ * @{ */
+
+/** choose a YAML emitting style based on the scalar's contents */
+RYML_EXPORT NodeType_e scalar_style_choose(csubstr scalar) noexcept;
+
+/** choose a json style based on the scalar's contents */
+RYML_EXPORT NodeType_e scalar_style_json_choose(csubstr scalar) noexcept;
+
+/** query whether a scalar can be encoded using single quotes.
+ * It may not be possible, notably when there is leading
+ * whitespace after a newline. */
+RYML_EXPORT bool scalar_style_query_squo(csubstr s) noexcept;
+
+/** query whether a scalar can be encoded using plain style (no
+ * quotes, not a literal/folded block scalar). */
+RYML_EXPORT bool scalar_style_query_plain(csubstr s) noexcept;
+
+/** YAML-sense query of nullity. returns true if the scalar points
+ * to `nullptr` or is otherwise equal to one of the strings
+ * `"~"`,`"null"`,`"Null"`,`"NULL"` */
+RYML_EXPORT inline C4_NO_INLINE bool scalar_is_null(csubstr s) noexcept
+{
+    return s.str == nullptr ||
+        s == "~" ||
+        s == "null" ||
+        s == "Null" ||
+        s == "NULL";
+}
+
+/** @} */
+
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+C4_SUPPRESS_WARNING_MSVC_POP
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+#endif /* C4_YML_NODE_TYPE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/tag.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tag.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_TAG_HPP_
+#define _C4_YML_TAG_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_ */
+
+
+namespace c4 {
+namespace yml {
+
+class Tree;
+
+/** @addtogroup doc_tag_utils
+ *
+ * @{
+ */
+
+
+#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 tags */
+using tag_bits = uint16_t;
+
+/** a bit mask for marking tags for types */
+typedef enum : tag_bits {
+    TAG_NONE      =  0,
+    // container types
+    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;
+
+RYML_EXPORT YamlTag_e to_tag(csubstr tag);
+RYML_EXPORT csubstr from_tag(YamlTag_e tag);
+RYML_EXPORT csubstr from_tag_long(YamlTag_e tag);
+RYML_EXPORT csubstr normalize_tag(csubstr tag);
+RYML_EXPORT csubstr normalize_tag_long(csubstr tag);
+RYML_EXPORT csubstr normalize_tag_long(csubstr tag, substr output);
+
+RYML_EXPORT bool is_custom_tag(csubstr tag);
+
+
+struct RYML_EXPORT TagDirective
+{
+    /** Eg <pre>!e!</pre> in <pre>%TAG !e! tag:example.com,2000:app/</pre> */
+    csubstr handle;
+    /** Eg <pre>tag:example.com,2000:app/</pre> in <pre>%TAG !e! tag:example.com,2000:app/</pre> */
+    csubstr prefix;
+    /** The next node to which this tag directive applies */
+    id_type next_node_id;
+
+    bool create_from_str(csubstr directive_); ///< leaves next_node_id unfilled
+    bool create_from_str(csubstr directive_, Tree *tree);
+    size_t transform(csubstr tag, substr output, Callbacks const& callbacks) const;
+};
+
+struct RYML_EXPORT TagDirectiveRange
+{
+    TagDirective const* C4_RESTRICT b;
+    TagDirective const* C4_RESTRICT e;
+    C4_ALWAYS_INLINE TagDirective const* begin() const noexcept { return b; }
+    C4_ALWAYS_INLINE TagDirective const* end() const noexcept { return e; }
+};
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_TAG_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/tag.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_
+
+/** @file 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_FWD_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/fwd.hpp
+//#include "c4/yml/fwd.hpp"
+#if !defined(C4_YML_FWD_HPP_) && !defined(_C4_YML_FWD_HPP_)
+#error "amalgamate: file c4/yml/fwd.hpp must have been included at this point"
+#endif /* C4_YML_FWD_HPP_ */
+
+#endif
+#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
+#ifndef C4_YML_NODE_TYPE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.hpp
+//#include "c4/yml/node_type.hpp"
+#if !defined(C4_YML_NODE_TYPE_HPP_) && !defined(_C4_YML_NODE_TYPE_HPP_)
+#error "amalgamate: file c4/yml/node_type.hpp must have been included at this point"
+#endif /* C4_YML_NODE_TYPE_HPP_ */
+
+#endif
+#ifndef _C4_YML_TAG_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tag.hpp
+//#include "c4/yml/tag.hpp"
+#if !defined(C4_YML_TAG_HPP_) && !defined(_C4_YML_TAG_HPP_)
+#error "amalgamate: file c4/yml/tag.hpp must have been included at this point"
+#endif /* C4_YML_TAG_HPP_ */
+
+#endif
+#ifndef _C4_CHARCONV_HPP_
+// 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_ */
+
+#endif
+
+//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_CLANG("-Wold-style-cast")
+C4_SUPPRESS_WARNING_GCC("-Wuseless-cast")
+C4_SUPPRESS_WARNING_GCC("-Wtype-limits")
+
+
+namespace c4 {
+namespace yml {
+
+template<class T> inline auto read(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<!std::is_arithmetic<T>::value, bool>::type;
+template<class T> inline auto read(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<std::is_arithmetic<T>::value && !std::is_floating_point<T>::value, bool>::type;
+template<class T> inline auto read(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<std::is_floating_point<T>::value, bool>::type;
+
+template<class T> inline auto readkey(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<!std::is_arithmetic<T>::value, bool>::type;
+template<class T> inline auto readkey(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<std::is_arithmetic<T>::value && !std::is_floating_point<T>::value, bool>::type;
+template<class T> inline auto readkey(Tree const* C4_RESTRICT tree, id_type id, T *v) -> typename std::enable_if<std::is_floating_point<T>::value, bool>::type;
+
+template<class T> size_t to_chars_float(substr buf, T val);
+template<class T> bool from_chars_float(csubstr buf, T *C4_RESTRICT val);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** @addtogroup doc_tree
+ *
+ * @{
+ */
+
+/** 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
+    NodeScalar() noexcept : tag(), scalar(), anchor() {} // NOLINT
+
+    /// initialize as an untagged scalar
+    template<size_t N>
+    NodeScalar(const char (&s)[N]) noexcept : tag(), scalar(s), anchor() {}
+    NodeScalar(csubstr      s    ) noexcept : tag(), scalar(s), anchor() {}
+
+    /// initialize as a tagged scalar
+    template<size_t N, size_t M>
+    NodeScalar(const char (&t)[N], const char (&s)[N]) noexcept : tag(t), scalar(s), anchor() {}
+    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) RYML_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 sequence member with explicit type
+    NodeInit(NodeScalar const& v, NodeType_e t) : type(t|VAL), key(), val(v) { _add_flags(); }
+    /// initialize as a mapping member
+    NodeInit(              NodeScalar const& k, NodeScalar const& v) : type(KEYVAL), key(k), val(v) { _add_flags(); }
+    /// initialize as a mapping member with explicit type
+    NodeInit(NodeType_e t, NodeScalar const& k, NodeScalar const& v) : type(t), key(k), val(v) { _add_flags(); }
+    /// initialize as a mapping member with explicit type (eg for SEQ or MAP)
+    NodeInit(NodeType_e t, NodeScalar const& k                     ) : type(t), key(k), 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;
+
+    id_type    m_parent;
+    id_type    m_first_child;
+    id_type    m_last_child;
+    id_type    m_next_sibling;
+    id_type    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(id_type node_capacity, size_t arena_capacity=0) : Tree(node_capacity, arena_capacity, get_callbacks()) {}
+    Tree(id_type node_capacity, size_t arena_capacity, Callbacks const& cb);
+
+    ~Tree();
+
+    Tree(Tree const& that);
+    Tree(Tree     && that) noexcept;
+
+    Tree& operator= (Tree const& that);
+    Tree& operator= (Tree     && that) noexcept;
+
+    /** @} */
+
+public:
+
+    /** @name memory and sizing */
+    /** @{ */
+
+    void reserve(id_type node_capacity);
+
+    /** clear the tree and zero every node
+     * @note does NOT clear the arena
+     * @see clear_arena() */
+    void clear();
+    void clear_arena() { m_arena_pos = 0; }
+
+    bool empty() const { return m_size == 0; }
+
+    id_type size() const { return m_size; }
+    id_type capacity() const { return m_cap; }
+    id_type slack() const { RYML_ASSERT(m_cap >= m_size); return m_cap - m_size; }
+
+    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 NONE is returned
+    id_type id(NodeData const* n) const
+    {
+        if( ! n)
+            return NONE;
+        _RYML_CB_ASSERT(m_callbacks, n >= m_buf && n < m_buf + m_cap);
+        return static_cast<id_type>(n - m_buf);
+    }
+
+    //! get a pointer to a node's NodeData.
+    //! i can be NONE, in which case a nullptr is returned
+    NodeData *get(id_type node) // NOLINT(readability-make-member-function-const)
+    {
+        if(node == NONE)
+            return nullptr;
+        _RYML_CB_ASSERT(m_callbacks, node >= 0 && node < m_cap);
+        return m_buf + node;
+    }
+    //! get a pointer to a node's NodeData.
+    //! i can be NONE, in which case a nullptr is returned.
+    NodeData const *get(id_type node) const
+    {
+        if(node == NONE)
+            return nullptr;
+        _RYML_CB_ASSERT(m_callbacks, node >= 0 && node < m_cap);
+        return m_buf + node;
+    }
+
+    //! An if-less form of get() that demands a valid node index.
+    //! This function is implementation only; use at your own risk.
+    NodeData       * _p(id_type node)       { _RYML_CB_ASSERT(m_callbacks, node != NONE && node >= 0 && node < m_cap); return m_buf + node; } // NOLINT(readability-make-member-function-const)
+    //! An if-less form of get() that demands a valid node index.
+    //! This function is implementation only; use at your own risk.
+    NodeData const * _p(id_type node) const { _RYML_CB_ASSERT(m_callbacks, node != NONE && node >= 0 && node < m_cap); return m_buf + node; }
+
+    //! Get the id of the root node
+    id_type root_id()       { if(m_cap == 0) { reserve(16); } _RYML_CB_ASSERT(m_callbacks, m_cap > 0 && m_size > 0); return 0; }
+    //! Get the id of the root node
+    id_type root_id() const {                                 _RYML_CB_ASSERT(m_callbacks, m_cap > 0 && m_size > 0); return 0; }
+
+    //! Get a NodeRef of a node by id
+    NodeRef      ref(id_type node);
+    //! Get a NodeRef of a node by id
+    ConstNodeRef ref(id_type node) const;
+    //! Get a NodeRef of a node by id
+    ConstNodeRef cref(id_type node) const;
+
+    //! Get the root as a NodeRef
+    NodeRef      rootref();
+    //! Get the root as a ConstNodeRef
+    ConstNodeRef rootref() const;
+    //! Get the root as a ConstNodeRef
+    ConstNodeRef crootref() const;
+
+    //! get the i-th document of the stream
+    //! @note @p i is NOT the node id, but the doc position within the stream
+    NodeRef      docref(id_type i);
+    //! get the i-th document of the stream
+    //! @note @p i is NOT the node id, but the doc position within the stream
+    ConstNodeRef docref(id_type i) const;
+    //! get the i-th document of the stream
+    //! @note @p i is NOT the node id, but the doc position within the stream
+    ConstNodeRef cdocref(id_type i) 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.
+    ConstNodeRef operator[] (csubstr key) const;
+
+    //! find a root child by index: return the root node's @p i-th child as a NodeRef
+    //! @note @p i is NOT the node id, but the child's position
+    NodeRef      operator[] (id_type i);
+    //! find a root child by index: return the root node's @p i-th child as a NodeRef
+    //! @note @p i is NOT the node id, but the child's position
+    ConstNodeRef operator[] (id_type i) const;
+
+    /** @} */
+
+public:
+
+    /** @name node property getters */
+    /** @{ */
+
+    NodeType type(id_type node) const { return _p(node)->m_type; }
+    const char* type_str(id_type node) const { return NodeType::type_str(_p(node)->m_type); }
+
+    csubstr    const& key       (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_key(node)); return _p(node)->m_key.scalar; }
+    csubstr    const& key_tag   (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_key_tag(node)); return _p(node)->m_key.tag; }
+    csubstr    const& key_ref   (id_type node) const { _RYML_CB_ASSERT(m_callbacks, is_key_ref(node)); return _p(node)->m_key.anchor; }
+    csubstr    const& key_anchor(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_key_anchor(node)); return _p(node)->m_key.anchor; }
+    NodeScalar const& keysc     (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_key(node)); return _p(node)->m_key; }
+
+    csubstr    const& val       (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_val(node)); return _p(node)->m_val.scalar; }
+    csubstr    const& val_tag   (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_val_tag(node)); return _p(node)->m_val.tag; }
+    csubstr    const& val_ref   (id_type node) const { _RYML_CB_ASSERT(m_callbacks, is_val_ref(node)); return _p(node)->m_val.anchor; }
+    csubstr    const& val_anchor(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_val_anchor(node)); return _p(node)->m_val.anchor; }
+    NodeScalar const& valsc     (id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_val(node)); return _p(node)->m_val; }
+
+    /** @} */
+
+public:
+
+    /** @name node type predicates */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool type_has_any(id_type node, NodeType_e bits) const { return _p(node)->m_type.has_any(bits); }
+    C4_ALWAYS_INLINE bool type_has_all(id_type node, NodeType_e bits) const { return _p(node)->m_type.has_all(bits); }
+    C4_ALWAYS_INLINE bool type_has_none(id_type node, NodeType_e bits) const { return _p(node)->m_type.has_none(bits); }
+
+    C4_ALWAYS_INLINE bool is_stream(id_type node) const { return _p(node)->m_type.is_stream(); }
+    C4_ALWAYS_INLINE bool is_doc(id_type node) const { return _p(node)->m_type.is_doc(); }
+    C4_ALWAYS_INLINE bool is_container(id_type node) const { return _p(node)->m_type.is_container(); }
+    C4_ALWAYS_INLINE bool is_map(id_type node) const { return _p(node)->m_type.is_map(); }
+    C4_ALWAYS_INLINE bool is_seq(id_type node) const { return _p(node)->m_type.is_seq(); }
+    C4_ALWAYS_INLINE bool has_key(id_type node) const { return _p(node)->m_type.has_key(); }
+    C4_ALWAYS_INLINE bool has_val(id_type node) const { return _p(node)->m_type.has_val(); }
+    C4_ALWAYS_INLINE bool is_val(id_type node) const { return _p(node)->m_type.is_val(); }
+    C4_ALWAYS_INLINE bool is_keyval(id_type node) const { return _p(node)->m_type.is_keyval(); }
+    C4_ALWAYS_INLINE bool has_key_tag(id_type node) const { return _p(node)->m_type.has_key_tag(); }
+    C4_ALWAYS_INLINE bool has_val_tag(id_type node) const { return _p(node)->m_type.has_val_tag(); }
+    C4_ALWAYS_INLINE bool has_key_anchor(id_type node) const { return _p(node)->m_type.has_key_anchor(); }
+    C4_ALWAYS_INLINE bool has_val_anchor(id_type node) const { return _p(node)->m_type.has_val_anchor(); }
+    C4_ALWAYS_INLINE bool has_anchor(id_type node) const { return _p(node)->m_type.has_anchor(); }
+    C4_ALWAYS_INLINE bool is_key_ref(id_type node) const { return _p(node)->m_type.is_key_ref(); }
+    C4_ALWAYS_INLINE bool is_val_ref(id_type node) const { return _p(node)->m_type.is_val_ref(); }
+    C4_ALWAYS_INLINE bool is_ref(id_type node) const { return _p(node)->m_type.is_ref(); }
+
+    C4_ALWAYS_INLINE bool parent_is_seq(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_parent(node)); return is_seq(_p(node)->m_parent); }
+    C4_ALWAYS_INLINE bool parent_is_map(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_parent(node)); return is_map(_p(node)->m_parent); }
+
+    /** true when the node has an anchor named a */
+    C4_ALWAYS_INLINE bool has_anchor(id_type node, csubstr a) const { return _p(node)->m_key.anchor == a || _p(node)->m_val.anchor == a; }
+
+    /** true if the node key is empty, or its scalar verifies @ref scalar_is_null().
+     * @warning the node must verify @ref Tree::has_key() (asserted) (ie must be a member of a map)
+     * @see https://github.com/biojppm/rapidyaml/issues/413 */
+    C4_ALWAYS_INLINE bool key_is_null(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_key(node)); NodeData const* C4_RESTRICT n = _p(node); return !n->m_type.is_key_quoted() && (n->m_type.key_is_null() || scalar_is_null(n->m_key.scalar)); }
+    /** true if the node val is empty, or its scalar verifies @ref scalar_is_null().
+     * @warning the node must verify @ref Tree::has_val() (asserted) (ie must be a scalar / must not be a container)
+     * @see https://github.com/biojppm/rapidyaml/issues/413 */
+    C4_ALWAYS_INLINE bool val_is_null(id_type node) const { _RYML_CB_ASSERT(m_callbacks, has_val(node)); NodeData const* C4_RESTRICT n = _p(node); return !n->m_type.is_val_quoted() && (n->m_type.val_is_null() || scalar_is_null(n->m_val.scalar)); }
+
+    /// true if the key was a scalar requiring filtering and was left
+    /// unfiltered during the parsing (see ParserOptions)
+    C4_ALWAYS_INLINE bool is_key_unfiltered(id_type node) const { return _p(node)->m_type.is_key_unfiltered(); }
+    /// true if the val was a scalar requiring filtering and was left
+    /// unfiltered during the parsing (see ParserOptions)
+    C4_ALWAYS_INLINE bool is_val_unfiltered(id_type node) const { return _p(node)->m_type.is_val_unfiltered(); }
+
+    RYML_DEPRECATED("use has_key_anchor()")    bool is_key_anchor(id_type node) const { return _p(node)->m_type.has_key_anchor(); }
+    RYML_DEPRECATED("use has_val_anchor()")    bool is_val_anchor(id_type node) const { return _p(node)->m_type.has_val_anchor(); }
+    RYML_DEPRECATED("use has_anchor()")        bool is_anchor(id_type node) const { return _p(node)->m_type.has_anchor(); }
+    RYML_DEPRECATED("use has_anchor_or_ref()") bool is_anchor_or_ref(id_type node) const { return _p(node)->m_type.has_anchor() || _p(node)->m_type.is_ref(); }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy predicates */
+    /** @{ */
+
+    bool is_root(id_type node) const { _RYML_CB_ASSERT(m_callbacks, _p(node)->m_parent != NONE || node == 0); return _p(node)->m_parent == NONE; }
+
+    bool has_parent(id_type node) const { return _p(node)->m_parent != NONE; }
+
+    /** true when ancestor is parent or parent of a parent of node */
+    bool is_ancestor(id_type node, id_type ancestor) const;
+
+    /** true when key and val are empty, and has no children */
+    bool empty(id_type node) const { return ! has_children(node) && _p(node)->m_key.empty() && (( ! (_p(node)->m_type & VAL)) || _p(node)->m_val.empty()); }
+
+    /** true if @p node has a child with id @p ch */
+    bool has_child(id_type node, id_type ch) const { return _p(ch)->m_parent == node; }
+    /** true if @p node has a child with key @p key */
+    bool has_child(id_type node, csubstr key) const { return find_child(node, key) != NONE; }
+    /** true if @p node has any children key */
+    bool has_children(id_type node) const { return _p(node)->m_first_child != NONE; }
+
+    /** true if @p node has a sibling with id @p sib */
+    bool has_sibling(id_type node, id_type sib) const { return _p(node)->m_parent == _p(sib)->m_parent; }
+    /** true if one of the node's siblings has the given key */
+    bool has_sibling(id_type node, csubstr key) const { return find_sibling(node, key) != NONE; }
+    /** true if node is not a single child */
+    bool has_other_siblings(id_type node) const
+    {
+        NodeData const *n = _p(node);
+        if(C4_LIKELY(n->m_parent != NONE))
+        {
+            n = _p(n->m_parent);
+            return n->m_first_child != n->m_last_child;
+        }
+        return false;
+    }
+
+    RYML_DEPRECATED("use has_other_siblings()") static bool has_siblings(id_type /*node*/) { return true; }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy getters */
+    /** @{ */
+
+    id_type parent(id_type node) const { return _p(node)->m_parent; }
+
+    id_type prev_sibling(id_type node) const { return _p(node)->m_prev_sibling; }
+    id_type next_sibling(id_type node) const { return _p(node)->m_next_sibling; }
+
+    /** O(#num_children) */
+    id_type num_children(id_type node) const;
+    id_type child_pos(id_type node, id_type ch) const;
+    id_type first_child(id_type node) const { return _p(node)->m_first_child; }
+    id_type last_child(id_type node) const { return _p(node)->m_last_child; }
+    id_type child(id_type node, id_type pos) const;
+    id_type find_child(id_type node, csubstr const& key) const;
+
+    /** O(#num_siblings) */
+    /** counts with this */
+    id_type num_siblings(id_type node) const { return is_root(node) ? 1 : num_children(_p(node)->m_parent); }
+    /** does not count with this */
+    id_type num_other_siblings(id_type node) const { id_type ns = num_siblings(node); _RYML_CB_ASSERT(m_callbacks, ns > 0); return ns-1; }
+    id_type sibling_pos(id_type node, id_type sib) const { _RYML_CB_ASSERT(m_callbacks,  ! is_root(node) || node == root_id()); return child_pos(_p(node)->m_parent, sib); }
+    id_type first_sibling(id_type node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_first_child; }
+    id_type last_sibling(id_type node) const { return is_root(node) ? node : _p(_p(node)->m_parent)->m_last_child; }
+    id_type sibling(id_type node, id_type pos) const { return child(_p(node)->m_parent, pos); }
+    id_type find_sibling(id_type node, csubstr const& key) const { return find_child(_p(node)->m_parent, key); }
+
+    id_type doc(id_type i) const { id_type rid = root_id(); _RYML_CB_ASSERT(m_callbacks, is_stream(rid)); return child(rid, i); } //!< gets the @p i document node index. requires that the root node is a stream.
+
+    id_type depth_asc(id_type node) const; /**< O(log(num_tree_nodes)) get the ascending depth of the node: number of levels between root and node */
+    id_type depth_desc(id_type node) const; /**< O(num_tree_nodes) get the descending depth of the node: number of levels between node and deepest child */
+
+    /** @} */
+
+public:
+
+    /** @name node style predicates and modifiers. see the corresponding predicate in NodeType */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool is_container_styled(id_type node) const { return _p(node)->m_type.is_container_styled(); }
+    C4_ALWAYS_INLINE bool is_block(id_type node) const { return _p(node)->m_type.is_block(); }
+    C4_ALWAYS_INLINE bool is_flow_sl(id_type node) const { return _p(node)->m_type.is_flow_sl(); }
+    C4_ALWAYS_INLINE bool is_flow_ml(id_type node) const { return _p(node)->m_type.is_flow_ml(); }
+    C4_ALWAYS_INLINE bool is_flow(id_type node) const { return _p(node)->m_type.is_flow(); }
+
+    C4_ALWAYS_INLINE bool is_key_styled(id_type node) const { return _p(node)->m_type.is_key_styled(); }
+    C4_ALWAYS_INLINE bool is_val_styled(id_type node) const { return _p(node)->m_type.is_val_styled(); }
+    C4_ALWAYS_INLINE bool is_key_literal(id_type node) const { return _p(node)->m_type.is_key_literal(); }
+    C4_ALWAYS_INLINE bool is_val_literal(id_type node) const { return _p(node)->m_type.is_val_literal(); }
+    C4_ALWAYS_INLINE bool is_key_folded(id_type node) const { return _p(node)->m_type.is_key_folded(); }
+    C4_ALWAYS_INLINE bool is_val_folded(id_type node) const { return _p(node)->m_type.is_val_folded(); }
+    C4_ALWAYS_INLINE bool is_key_squo(id_type node) const { return _p(node)->m_type.is_key_squo(); }
+    C4_ALWAYS_INLINE bool is_val_squo(id_type node) const { return _p(node)->m_type.is_val_squo(); }
+    C4_ALWAYS_INLINE bool is_key_dquo(id_type node) const { return _p(node)->m_type.is_key_dquo(); }
+    C4_ALWAYS_INLINE bool is_val_dquo(id_type node) const { return _p(node)->m_type.is_val_dquo(); }
+    C4_ALWAYS_INLINE bool is_key_plain(id_type node) const { return _p(node)->m_type.is_key_plain(); }
+    C4_ALWAYS_INLINE bool is_val_plain(id_type node) const { return _p(node)->m_type.is_val_plain(); }
+    C4_ALWAYS_INLINE bool is_key_quoted(id_type node) const { return _p(node)->m_type.is_key_quoted(); }
+    C4_ALWAYS_INLINE bool is_val_quoted(id_type node) const { return _p(node)->m_type.is_val_quoted(); }
+    C4_ALWAYS_INLINE bool is_quoted(id_type node) const { return _p(node)->m_type.is_quoted(); }
+
+    C4_ALWAYS_INLINE void set_container_style(id_type node, NodeType_e style) { _RYML_CB_ASSERT(m_callbacks, is_container(node)); _p(node)->m_type.set_container_style(style); }
+    C4_ALWAYS_INLINE void set_key_style(id_type node, NodeType_e style) { _RYML_CB_ASSERT(m_callbacks, has_key(node)); _p(node)->m_type.set_key_style(style); }
+    C4_ALWAYS_INLINE void set_val_style(id_type node, NodeType_e style) { _RYML_CB_ASSERT(m_callbacks, has_val(node)); _p(node)->m_type.set_val_style(style); }
+
+    /** @} */
+
+public:
+
+    /** @name node type modifiers */
+    /** @{ */
+
+    void to_keyval(id_type node, csubstr key, csubstr val, type_bits more_flags=0);
+    void to_map(id_type node, csubstr key, type_bits more_flags=0);
+    void to_seq(id_type node, csubstr key, type_bits more_flags=0);
+    void to_val(id_type node, csubstr val, type_bits more_flags=0);
+    void to_map(id_type node, type_bits more_flags=0);
+    void to_seq(id_type node, type_bits more_flags=0);
+    void to_doc(id_type node, type_bits more_flags=0);
+    void to_stream(id_type node, type_bits more_flags=0);
+
+    void set_key(id_type node, csubstr key) { _RYML_CB_ASSERT(m_callbacks, has_key(node)); _p(node)->m_key.scalar = key; }
+    void set_val(id_type node, csubstr val) { _RYML_CB_ASSERT(m_callbacks, has_val(node)); _p(node)->m_val.scalar = val; }
+
+    void set_key_tag(id_type node, csubstr tag) { _RYML_CB_ASSERT(m_callbacks, has_key(node)); _p(node)->m_key.tag = tag; _add_flags(node, KEYTAG); }
+    void set_val_tag(id_type node, csubstr tag) { _RYML_CB_ASSERT(m_callbacks, has_val(node) || is_container(node)); _p(node)->m_val.tag = tag; _add_flags(node, VALTAG); }
+
+    void set_key_anchor(id_type node, csubstr anchor) { _RYML_CB_ASSERT(m_callbacks,  ! is_key_ref(node)); _p(node)->m_key.anchor = anchor.triml('&'); _add_flags(node, KEYANCH); }
+    void set_val_anchor(id_type node, csubstr anchor) { _RYML_CB_ASSERT(m_callbacks,  ! is_val_ref(node)); _p(node)->m_val.anchor = anchor.triml('&'); _add_flags(node, VALANCH); }
+    void set_key_ref   (id_type node, csubstr ref   ) { _RYML_CB_ASSERT(m_callbacks,  ! 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   (id_type node, csubstr ref   ) { _RYML_CB_ASSERT(m_callbacks,  ! 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(id_type node) { _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYANCH); }
+    void rem_val_anchor(id_type node) { _p(node)->m_val.anchor.clear(); _rem_flags(node, VALANCH); }
+    void rem_key_ref   (id_type node) { _p(node)->m_key.anchor.clear(); _rem_flags(node, KEYREF); }
+    void rem_val_ref   (id_type node) { _p(node)->m_val.anchor.clear(); _rem_flags(node, VALREF); }
+    void rem_anchor_ref(id_type 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 tree's node array. */
+    void reorder();
+
+    /** @} */
+
+public:
+
+    /** @name anchors and references/aliases */
+    /** @{ */
+
+    /** Resolve references (aliases <- anchors), by forwarding to @ref
+     * ReferenceResolver::resolve(); refer to @ref
+     * ReferenceResolver::resolve() for further details. */
+    void resolve(ReferenceResolver *C4_RESTRICT rr, bool clear_anchors=true);
+
+    /** Resolve references (aliases <- anchors), by forwarding to @ref
+     * ReferenceResolver::resolve(); refer to @ref
+     * ReferenceResolver::resolve() for further details. This overload
+     * uses a throwaway resolver object. */
+    void resolve(bool clear_anchors=true);
+
+public:
+
+    /** @name tag directives */
+    /** @{ */
+
+    void resolve_tags();
+    void normalize_tags();
+    void normalize_tags_long();
+
+    id_type num_tag_directives() const;
+    bool add_tag_directive(csubstr directive);
+    id_type add_tag_directive(TagDirective const& td);
+    void clear_tag_directives();
+
+    /** resolve the given tag, appearing at node_id. Write the result into output.
+     * @return the number of characters required for the resolved tag */
+    size_t resolve_tag(substr output, csubstr tag, id_type node_id) const;
+    csubstr resolve_tag_sub(substr output, csubstr tag, id_type node_id) const
+    {
+        size_t needed = resolve_tag(output, tag, node_id);
+        return needed <= output.len ? output.first(needed) : output;
+    }
+
+    TagDirective const* begin_tag_directives() const { return m_tag_directives; }
+    TagDirective const* end_tag_directives() const { return m_tag_directives + num_tag_directives(); }
+    c4::yml::TagDirectiveRange tag_directives() const { return c4::yml::TagDirectiveRange{begin_tag_directives(), end_tag_directives()}; }
+
+    RYML_DEPRECATED("use c4::yml::tag_directive_const_iterator") typedef TagDirective const* tag_directive_const_iterator;
+    RYML_DEPRECATED("use c4::yml::TagDirectiveRange") typedef c4::yml::TagDirectiveRange TagDirectiveProxy;
+
+    /** @} */
+
+public:
+
+    /** @name modifying hierarchy */
+    /** @{ */
+
+    /** create and insert a new child of @p parent. insert after the (to-be)
+     * sibling @p after, which must be a child of @p parent. To insert as the
+     * first child, set after to NONE */
+    C4_ALWAYS_INLINE id_type insert_child(id_type parent, id_type after)
+    {
+        _RYML_CB_ASSERT(m_callbacks, parent != NONE);
+        _RYML_CB_ASSERT(m_callbacks, is_container(parent) || is_root(parent));
+        _RYML_CB_ASSERT(m_callbacks, after == NONE || (_p(after)->m_parent == parent));
+        id_type child = _claim();
+        _set_hierarchy(child, parent, after);
+        return child;
+    }
+    /** create and insert a node as the first child of @p parent */
+    C4_ALWAYS_INLINE id_type prepend_child(id_type parent) { return insert_child(parent, NONE); }
+    /** create and insert a node as the last child of @p parent */
+    C4_ALWAYS_INLINE id_type append_child(id_type parent) { return insert_child(parent, _p(parent)->m_last_child); }
+    C4_ALWAYS_INLINE id_type _append_child__unprotected(id_type parent)
+    {
+        id_type child = _claim();
+        _set_hierarchy(child, parent, _p(parent)->m_last_child);
+        return child;
+    }
+
+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"
+    C4_ALWAYS_INLINE id_type insert_sibling(id_type node, id_type after)
+    {
+        return insert_child(_p(node)->m_parent, after);
+    }
+    /** create and insert a node as the first node of @p parent */
+    C4_ALWAYS_INLINE id_type prepend_sibling(id_type node) { return prepend_child(_p(node)->m_parent); }
+    C4_ALWAYS_INLINE id_type  append_sibling(id_type node) { return append_child(_p(node)->m_parent); }
+
+public:
+
+    /** remove an entire branch at once: ie remove the children and the node itself */
+    void remove(id_type node)
+    {
+        remove_children(node);
+        _release(node);
+    }
+
+    /** remove all the node's children, but keep the node itself */
+    void remove_children(id_type 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(id_type node, NodeType type);
+
+    bool change_type(id_type 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(id_type node, id_type after);
+
+    /** change the node's parent and position */
+    void move(id_type node, id_type new_parent, id_type after);
+
+    /** change the node's parent and position to a different tree
+     * @return the index of the new node in the destination tree */
+    id_type move(Tree * src, id_type node, id_type new_parent, id_type 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 */
+    id_type duplicate(id_type node, id_type new_parent, id_type 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 */
+    id_type duplicate(Tree const* src, id_type node, id_type new_parent, id_type after);
+
+    /** recursively duplicate the node's children (but not the node)
+     * @return the index of the last duplicated child */
+    id_type duplicate_children(id_type node, id_type parent, id_type 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 */
+    id_type duplicate_children(Tree const* src, id_type node, id_type parent, id_type after);
+
+    /** 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. */
+    id_type duplicate_children_no_rep(id_type node, id_type parent, id_type after);
+    id_type duplicate_children_no_rep(Tree const* src, id_type node, id_type parent, id_type after);
+
+    void duplicate_contents(id_type node, id_type where);
+    void duplicate_contents(Tree const* src, id_type node, id_type where);
+
+public:
+
+    void merge_with(Tree const* src, id_type src_node=NONE, id_type dst_root=NONE);
+
+    /** @} */
+
+public:
+
+    /** @name internal string arena */
+    /** @{ */
+
+    /** get the current size of the tree's internal arena */
+    RYML_DEPRECATED("use arena_size() instead") size_t arena_pos() const { return m_arena_pos; }
+    /** get the current size of the tree's internal arena */
+    size_t arena_size() const { return m_arena_pos; }
+    /** get the current capacity of the tree's internal arena */
+    size_t arena_capacity() const { return m_arena.len; }
+    /** get the current slack of the tree's internal arena */
+    size_t arena_slack() const { _RYML_CB_ASSERT(m_callbacks, m_arena.len >= m_arena_pos); return m_arena.len - m_arena_pos; }
+
+    /** get the current arena */
+    csubstr arena() const { return m_arena.first(m_arena_pos); }
+    /** get the current arena */
+    substr arena() { return m_arena.first(m_arena_pos); } // NOLINT(readability-make-member-function-const)
+
+    /** 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 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, and thus cost O(numnodes)+O(arenasize). To avoid this
+     * cost, ensure that the arena is reserved to an appropriate size
+     * using @ref Tree::reserve_arena().
+     *
+     * @see alloc_arena() */
+    template<class T>
+    auto to_arena(T const& C4_RESTRICT a)
+        -> typename std::enable_if<std::is_floating_point<T>::value, csubstr>::type
+    {
+        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_CB_ASSERT(m_callbacks, num <= rem.len);
+        }
+        rem = _request_span(num);
+        return rem;
+    }
+
+    /** 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, and thus cost O(numnodes)+O(arenasize). To avoid this
+     * cost, ensure that the arena is reserved to an appropriate size
+     * using @ref Tree::reserve_arena().
+     *
+     * @see alloc_arena() */
+    template<class T>
+    auto to_arena(T const& C4_RESTRICT a)
+        -> typename std::enable_if<!std::is_floating_point<T>::value, csubstr>::type
+    {
+        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_CB_ASSERT(m_callbacks, num <= rem.len);
+        }
+        rem = _request_span(num);
+        return rem;
+    }
+
+    /** serialize the given csubstr to the tree's arena, growing the
+     * arena 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, and thus cost O(numnodes)+O(arenasize). To avoid this
+     * cost, ensure that the arena is reserved to an appropriate size
+     * using @ref Tree::reserve_arena().
+     *
+     * @see alloc_arena() */
+    csubstr to_arena(csubstr a)
+    {
+        if(a.len > 0)
+        {
+            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_CB_ASSERT(m_callbacks, num <= rem.len);
+            }
+            return _request_span(num);
+        }
+        else
+        {
+            if(a.str == nullptr)
+            {
+                return csubstr{};
+            }
+            else if(m_arena.str == nullptr)
+            {
+                // Arena is empty and we want to store a non-null
+                // zero-length string.
+                // Even though the string has zero length, we need
+                // some "memory" to store a non-nullptr string
+                _grow_arena(1);
+            }
+            return _request_span(0);
+        }
+    }
+    C4_ALWAYS_INLINE csubstr to_arena(const char *s)
+    {
+        return to_arena(to_csubstr(s));
+    }
+    C4_ALWAYS_INLINE static csubstr to_arena(std::nullptr_t)
+    {
+        return csubstr{};
+    }
+
+    /** 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, and thus cost O(numnodes)+O(arenasize). To avoid this
+     * cost, ensure that the arena is reserved to an appropriate size
+     * before using @ref Tree::reserve_arena()
+     *
+     * @see reserve_arena()
+     * @see alloc_arena()
+     */
+    substr copy_to_arena(csubstr s)
+    {
+        substr cp = alloc_arena(s.len);
+        _RYML_CB_ASSERT(m_callbacks, cp.len == s.len);
+        _RYML_CB_ASSERT(m_callbacks, !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
+        if(s.len)
+            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, and thus cost O(numnodes)+O(arenasize). To avoid this
+     * cost, ensure that the arena is reserved to an appropriate size
+     * using .reserve_arena().
+     *
+     * @see reserve_arena() */
+    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
+     * @warning This operation may be expensive, with a potential complexity of O(numNodes)+O(arenasize).
+     * @warning 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_CB_ASSERT(m_callbacks, 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.len + 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)
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_arena_pos + sz <= m_arena.len);
+        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_CB_ASSERT(m_callbacks, m_arena.is_super(s));
+        _RYML_CB_ASSERT(m_callbacks, m_arena.sub(0, m_arena_pos).is_super(s));
+        auto pos = (s.str - m_arena.str); // this is larger than 0 based on the assertions above
+        substr r(next_arena.str + pos, s.len);
+        _RYML_CB_ASSERT(m_callbacks, r.str - next_arena.str == pos);
+        _RYML_CB_ASSERT(m_callbacks, next_arena.sub(0, m_arena_pos).is_super(r));
+        return r;
+    }
+
+public:
+
+    /** @name lookup */
+    /** @{ */
+
+    struct lookup_result
+    {
+        id_type  target;
+        id_type  closest;
+        size_t  path_pos;
+        csubstr path;
+
+        operator bool() const { return target != NONE; }
+
+        lookup_result() : target(NONE), closest(NONE), path_pos(0), path() {}
+        lookup_result(csubstr path_, id_type 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, id_type 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() */
+    id_type lookup_path_or_modify(csubstr default_value, csubstr path, id_type 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() */
+    id_type lookup_path_or_modify(Tree const *src, id_type src_node, csubstr path, id_type 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) {}
+        operator bool() const { return type != NOTYPE; }
+        bool is_index() const { return value.begins_with('[') && value.ends_with(']'); }
+    };
+
+    id_type _lookup_path_or_create(csubstr path, id_type start);
+
+    void   _lookup_path       (lookup_result *r) const;
+    void   _lookup_path_modify(lookup_result *r);
+
+    id_type _next_node       (lookup_result *r, _lookup_path_token *parent) const;
+    id_type _next_node_modify(lookup_result *r, _lookup_path_token *parent);
+
+    static void _advance(lookup_result *r, size_t more);
+
+    _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) noexcept;
+
+    void _relocate(substr next_arena);
+
+public:
+
+    /** @cond dev*/
+
+    #if ! RYML_USE_ASSERT
+    C4_ALWAYS_INLINE void _check_next_flags(id_type, type_bits) {}
+    #else
+    void _check_next_flags(id_type node, type_bits f)
+    {
+        NodeData *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_CB_ASSERT(m_callbacks, !is_root(node));
+            auto pid = parent(node); C4_UNUSED(pid);
+            _RYML_CB_ASSERT(m_callbacks, is_map(pid));
+        }
+        if((f & VAL) && !is_root(node))
+        {
+            auto pid = parent(node); C4_UNUSED(pid);
+            _RYML_CB_ASSERT(m_callbacks, is_map(pid) || is_seq(pid));
+        }
+    }
+    #endif
+
+    void _set_flags(id_type node, NodeType_e f) { _check_next_flags(node, f); _p(node)->m_type = f; }
+    void _set_flags(id_type node, type_bits  f) { _check_next_flags(node, f); _p(node)->m_type = f; }
+
+    void _add_flags(id_type 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; }
+    void _add_flags(id_type node, type_bits  f) { NodeData *d = _p(node);                f |= d->m_type; _check_next_flags(node,  f); d->m_type = f; }
+
+    void _rem_flags(id_type 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; }
+    void _rem_flags(id_type 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(id_type node, csubstr key, type_bits more_flags=0)
+    {
+        _p(node)->m_key.scalar = key;
+        _add_flags(node, KEY|more_flags);
+    }
+    void _set_key(id_type node, NodeScalar const& key, type_bits more_flags=0)
+    {
+        _p(node)->m_key = key;
+        _add_flags(node, KEY|more_flags);
+    }
+
+    void _set_val(id_type node, csubstr val, type_bits more_flags=0)
+    {
+        _RYML_CB_ASSERT(m_callbacks, num_children(node) == 0);
+        _RYML_CB_ASSERT(m_callbacks, !is_seq(node) && !is_map(node));
+        _p(node)->m_val.scalar = val;
+        _add_flags(node, VAL|more_flags);
+    }
+    void _set_val(id_type node, NodeScalar const& val, type_bits more_flags=0)
+    {
+        _RYML_CB_ASSERT(m_callbacks, num_children(node) == 0);
+        _RYML_CB_ASSERT(m_callbacks,  ! is_container(node));
+        _p(node)->m_val = val;
+        _add_flags(node, VAL|more_flags);
+    }
+
+    void _set(id_type node, NodeInit const& i)
+    {
+        _RYML_CB_ASSERT(m_callbacks, i._check());
+        NodeData *n = _p(node);
+        _RYML_CB_ASSERT(m_callbacks, 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(id_type in)
+    {
+        NodeData const* n = _p(in);
+        id_type 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(id_type node)
+    {
+        _RYML_CB_ASSERT(m_callbacks, is_seq(node));
+        for(id_type 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);
+    }
+
+    id_type _do_reorder(id_type *node, id_type count);
+
+    void _swap(id_type n_, id_type m_);
+    void _swap_props(id_type n_, id_type m_);
+    void _swap_hierarchy(id_type n_, id_type m_);
+    void _copy_hierarchy(id_type dst_, id_type src_);
+
+    void _copy_props(id_type dst_, id_type src_)
+    {
+        _copy_props(dst_, this, src_);
+    }
+
+    void _copy_props_wo_key(id_type dst_, id_type src_)
+    {
+        _copy_props_wo_key(dst_, this, src_);
+    }
+
+    void _copy_props(id_type dst_, Tree const* that_tree, id_type 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(id_type dst_, Tree const* that_tree, id_type src_, type_bits src_mask)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *that_tree->_p(src_);
+        dst.m_type = (src.m_type & src_mask) | (dst.m_type & ~src_mask);
+        dst.m_key  = src.m_key;
+        dst.m_val  = src.m_val;
+    }
+
+    void _copy_props_wo_key(id_type dst_, Tree const* that_tree, id_type src_)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *that_tree->_p(src_);
+        dst.m_type = (src.m_type & ~_KEYMASK) | (dst.m_type & _KEYMASK);
+        dst.m_val  = src.m_val;
+    }
+
+    void _copy_props_wo_key(id_type dst_, Tree const* that_tree, id_type src_, type_bits src_mask)
+    {
+        auto      & C4_RESTRICT dst = *_p(dst_);
+        auto const& C4_RESTRICT src = *that_tree->_p(src_);
+        dst.m_type = (src.m_type & ((~_KEYMASK)|src_mask)) | (dst.m_type & (_KEYMASK|~src_mask));
+        dst.m_val  = src.m_val;
+    }
+
+    void _clear_type(id_type node)
+    {
+        _p(node)->m_type = NOTYPE;
+    }
+
+    void _clear(id_type 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;
+    }
+
+    void _clear_key(id_type node)
+    {
+        _p(node)->m_key.clear();
+        _rem_flags(node, KEY);
+    }
+
+    void _clear_val(id_type node)
+    {
+        _p(node)->m_val.clear();
+        _rem_flags(node, VAL);
+    }
+
+    /** @endcond */
+
+private:
+
+    void _clear_range(id_type first, id_type num);
+
+public:
+    id_type _claim();
+private:
+    void   _claim_root();
+    void   _release(id_type node);
+    void   _free_list_add(id_type node);
+    void   _free_list_rem(id_type node);
+
+    void _set_hierarchy(id_type node, id_type parent, id_type after_sibling);
+    void _rem_hierarchy(id_type node);
+
+public:
+
+    // members are exposed, but you should NOT access them directly
+
+    NodeData *m_buf;
+    id_type   m_cap;
+
+    id_type m_size;
+
+    id_type m_free_head;
+    id_type m_free_tail;
+
+    substr m_arena;
+    size_t m_arena_pos;
+
+    Callbacks m_callbacks;
+
+    TagDirective m_tag_directives[RYML_MAX_TAG_DIRECTIVES];
+
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_serialization_helpers Serialization helpers
+ *
+ * @{
+ */
+
+
+// NON-ARITHMETIC -------------------------------------------------------------
+
+/** convert the val of a scalar node to a particular non-arithmetic
+ * non-float type, by forwarding its val to @ref from_chars<T>(). The
+ * full string is used.
+ * @return false if the conversion failed, or if the key was empty and unquoted */
+template<class T>
+inline auto read(Tree const* C4_RESTRICT tree, id_type id, T *v)
+    -> typename std::enable_if<!std::is_arithmetic<T>::value, bool>::type
+{
+    return C4_LIKELY(!(tree->type(id) & VALNIL)) ? from_chars(tree->val(id), v) : false;
+}
+
+/** convert the key of a node to a particular non-arithmetic
+ * non-float type, by forwarding its key to @ref from_chars<T>(). The
+ * full string is used.
+ * @return false if the conversion failed, or if the key was empty and unquoted */
+template<class T>
+inline auto readkey(Tree const* C4_RESTRICT tree, id_type id, T *v)
+    -> typename std::enable_if<!std::is_arithmetic<T>::value, bool>::type
+{
+    return C4_LIKELY(!(tree->type(id) & KEYNIL)) ? from_chars(tree->key(id), v) : false;
+}
+
+
+// INTEGRAL, NOT FLOATING -------------------------------------------------------------
+
+/** convert the val of a scalar node to a particular arithmetic
+ * integral non-float type, by forwarding its val to @ref
+ * from_chars<T>(). The full string is used.
+ *
+ * @return false if the conversion failed */
+template<class T>
+inline auto read(Tree const* C4_RESTRICT tree, id_type id, T *v)
+    -> typename std::enable_if<std::is_arithmetic<T>::value && !std::is_floating_point<T>::value, bool>::type
+{
+    using U = typename std::remove_cv<T>::type;
+    enum { ischar = std::is_same<char, U>::value || std::is_same<signed char, U>::value || std::is_same<unsigned char, U>::value };
+    csubstr val = tree->val(id);
+    NodeType ty = tree->type(id);
+    if(C4_UNLIKELY((ty & VALNIL) || val.empty()))
+        return false;
+    // quote integral numbers if they have a leading 0
+    // https://github.com/biojppm/rapidyaml/issues/291
+    char first = val[0];
+    if(ty.is_val_quoted() && (first != '0' && !ischar))
+        return false;
+    else if(first == '+')
+        val = val.sub(1);
+    return from_chars(val, v);
+}
+
+/** convert the key of a node to a particular arithmetic
+ * integral non-float type, by forwarding its val to @ref
+ * from_chars<T>(). The full string is used.
+ *
+ * @return false if the conversion failed */
+template<class T>
+inline auto readkey(Tree const* C4_RESTRICT tree, id_type id, T *v)
+    -> typename std::enable_if<std::is_arithmetic<T>::value && !std::is_floating_point<T>::value, bool>::type
+{
+    using U = typename std::remove_cv<T>::type;
+    enum { ischar = std::is_same<char, U>::value || std::is_same<signed char, U>::value || std::is_same<unsigned char, U>::value };
+    csubstr key = tree->key(id);
+    NodeType ty = tree->type(id);
+    if((ty & KEYNIL) || key.empty())
+        return false;
+    // quote integral numbers if they have a leading 0
+    // https://github.com/biojppm/rapidyaml/issues/291
+    char first = key[0];
+    if(ty.is_key_quoted() && (first != '0' && !ischar))
+        return false;
+    else if(first == '+')
+        key = key.sub(1);
+    return from_chars(key, v);
+}
+
+
+// FLOATING -------------------------------------------------------------
+
+/** encode a floating point value to a string. */
+template<class T>
+size_t to_chars_float(substr buf, T val)
+{
+    static_assert(std::is_floating_point<T>::value, "must be floating point");
+    C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wfloat-equal");
+    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(buf.begins_with('+'))
+    {
+        buf = buf.sub(1);
+    }
+    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;
+    }
+}
+
+/** convert the val of a scalar node to a floating point type, by
+ * forwarding its val to @ref from_chars_float<T>().
+ *
+ * @return false if the conversion failed
+ *
+ * @warning Unlike non-floating types, only the leading part of the
+ * string that may constitute a number is processed. This happens
+ * because the float parsing is delegated to fast_float, which is
+ * implemented that way. Consequently, for example, all of `"34"`,
+ * `"34 "` `"34hg"` `"34 gh"` will be read as 34. If you are not sure
+ * about the contents of the data, you can use
+ * csubstr::first_real_span() to check before calling `>>`, for
+ * example like this:
+ *
+ * ```cpp
+ * csubstr val = node.val();
+ * if(val.first_real_span() == val)
+ *     node >> v;
+ * else
+ *     ERROR("not a real")
+ * ```
+ */
+template<class T>
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+inline read(Tree const* C4_RESTRICT tree, id_type id, T *v)
+{
+    csubstr val = tree->val(id);
+    return C4_LIKELY(!val.empty()) ? from_chars_float(val, v) : false;
+}
+
+/** convert the key of a scalar node to a floating point type, by
+ * forwarding its key to @ref from_chars_float<T>().
+ *
+ * @return false if the conversion failed
+ *
+ * @warning Unlike non-floating types, only the leading part of the
+ * string that may constitute a number is processed. This happens
+ * because the float parsing is delegated to fast_float, which is
+ * implemented that way. Consequently, for example, all of `"34"`,
+ * `"34 "` `"34hg"` `"34 gh"` will be read as 34. If you are not sure
+ * about the contents of the data, you can use
+ * csubstr::first_real_span() to check before calling `>>`, for
+ * example like this:
+ *
+ * ```cpp
+ * csubstr key = node.key();
+ * if(key.first_real_span() == key)
+ *     node >> v;
+ * else
+ *     ERROR("not a real")
+ * ```
+ */
+template<class T>
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type
+inline readkey(Tree const* C4_RESTRICT tree, id_type id, T *v)
+{
+    csubstr key = tree->key(id);
+    return C4_LIKELY(!key.empty()) ? from_chars_float(key, v) : false;
+}
+
+/** @} */
+
+/** @} */
+
+
+} // 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 Node classes */
+
+//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 __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wtype-limits"
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic push
+#   pragma GCC diagnostic ignored "-Wtype-limits"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#   pragma GCC diagnostic ignored "-Wuseless-cast"
+#elif 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 {
+
+/** @addtogroup doc_node_classes
+ *
+ * @{
+ */
+
+
+/** @defgroup doc_serialization_helpers Serialization helpers
+ *
+ * @{
+ */
+template<class K> struct Key { K & k; }; // NOLINT
+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> inline bool read(ConstNodeRef const& C4_RESTRICT n, T *v);
+template<class T> inline bool read(NodeRef const& C4_RESTRICT n, T *v);
+template<class T> inline bool readkey(ConstNodeRef const& C4_RESTRICT n, T *v);
+template<class T> inline bool readkey(NodeRef const& C4_RESTRICT n, T *v);
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// forward decls
+class NodeRef;
+class ConstNodeRef;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+namespace detail {
+
+template<class NodeRefType>
+struct child_iterator
+{
+    using value_type = NodeRefType;
+    using tree_type = typename NodeRefType::tree_type;
+
+    tree_type * C4_RESTRICT m_tree;
+    id_type m_child_id;
+
+    child_iterator(tree_type * t, id_type 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; }
+
+    NodeRefType operator*  () const { return NodeRefType(m_tree, m_child_id); }
+    NodeRefType operator-> () const { return NodeRefType(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; }
+};
+
+template<class NodeRefType>
+struct children_view_
+{
+    using n_iterator = child_iterator<NodeRefType>;
+
+    n_iterator b, e;
+
+    children_view_(n_iterator const& C4_RESTRICT b_,
+                          n_iterator const& C4_RESTRICT e_) : b(b_), e(e_) {}
+
+    n_iterator begin() const { return b; }
+    n_iterator end  () const { return e; }
+};
+
+template<class NodeRefType, class Visitor>
+bool _visit(NodeRefType &node, Visitor fn, id_type indentation_level, bool skip_root=false)
+{
+    id_type increment = 0;
+    if( ! (node.is_root() && skip_root))
+    {
+        if(fn(node, indentation_level))
+            return true;
+        ++increment;
+    }
+    if(node.has_children())
+    {
+        for(auto ch : node.children())
+        {
+            if(_visit(ch, fn, indentation_level + increment, false)) // no need to forward skip_root as it won't be root
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+template<class NodeRefType, class Visitor>
+bool _visit_stacked(NodeRefType &node, Visitor fn, id_type indentation_level, bool skip_root=false)
+{
+    id_type increment = 0;
+    if( ! (node.is_root() && skip_root))
+    {
+        if(fn(node, indentation_level))
+        {
+            return true;
+        }
+        ++increment;
+    }
+    if(node.has_children())
+    {
+        fn.push(node, indentation_level);
+        for(auto ch : node.children())
+        {
+            if(_visit_stacked(ch, fn, indentation_level + increment, false)) // no need to forward skip_root as it won't be root
+            {
+                fn.pop(node, indentation_level);
+                return true;
+            }
+        }
+        fn.pop(node, indentation_level);
+    }
+    return false;
+}
+
+template<class Impl, class ConstImpl>
+struct RoNodeMethods;
+} // detail
+/** @endcond */
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+
+/** a CRTP base providing read-only methods for @ref ConstNodeRef and @ref NodeRef */
+namespace detail {
+template<class Impl, class ConstImpl>
+struct RoNodeMethods
+{
+    C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wcast-align")
+    /** @cond dev */
+    // helper CRTP macros, undefined at the end
+    #define tree_ ((ConstImpl const* C4_RESTRICT)this)->m_tree
+    #define id_ ((ConstImpl const* C4_RESTRICT)this)->m_id
+    #define tree__ ((Impl const* C4_RESTRICT)this)->m_tree
+    #define id__ ((Impl const* C4_RESTRICT)this)->m_id
+    // require readable: this is a precondition for reading from the
+    // tree using this object.
+    #define _C4RR()                                       \
+        RYML_ASSERT(tree_ != nullptr);                    \
+        _RYML_CB_ASSERT(tree_->m_callbacks, id_ != NONE); \
+        _RYML_CB_ASSERT(tree_->m_callbacks, (((Impl const* C4_RESTRICT)this)->readable()))
+    // a SFINAE beautifier to enable a function only if the
+    // implementation is mutable
+    #define _C4_IF_MUTABLE(ty) typename std::enable_if<!std::is_same<U, ConstImpl>::value, ty>::type
+    /** @endcond */
+
+public:
+
+    /** @name node property getters */
+    /** @{ */
+
+    /** returns the data or null when the id is NONE */
+    C4_ALWAYS_INLINE NodeData const* get() const RYML_NOEXCEPT { return ((Impl const*)this)->readable() ? tree_->get(id_) : nullptr; }
+    /** returns the data or null when the id is NONE */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto get() RYML_NOEXCEPT -> _C4_IF_MUTABLE(NodeData*) { return ((Impl const*)this)->readable() ? tree__->get(id__) : nullptr; }
+
+    C4_ALWAYS_INLINE NodeType    type()     const RYML_NOEXCEPT { _C4RR(); return tree_->type(id_); }     /**< Forward to @ref Tree::type_str(). Node must be readable. */
+    C4_ALWAYS_INLINE const char* type_str() const RYML_NOEXCEPT { _C4RR(); return tree_->type_str(id_); } /**< Forward to @ref Tree::type_str(). Node must be readable. */
+
+    C4_ALWAYS_INLINE csubstr key()        const RYML_NOEXCEPT { _C4RR(); return tree_->key(id_); }        /**< Forward to @ref Tree::key(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr key_tag()    const RYML_NOEXCEPT { _C4RR(); return tree_->key_tag(id_); }    /**< Forward to @ref Tree::key_tag(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr key_ref()    const RYML_NOEXCEPT { _C4RR(); return tree_->key_ref(id_); }    /**< Forward to @ref Tree::key_ref(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr key_anchor() const RYML_NOEXCEPT { _C4RR(); return tree_->key_anchor(id_); } /**< Forward to @ref Tree::key_anchor(). Node must be readable. */
+
+    C4_ALWAYS_INLINE csubstr val()        const RYML_NOEXCEPT { _C4RR(); return tree_->val(id_); }        /**< Forward to @ref Tree::val(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr val_tag()    const RYML_NOEXCEPT { _C4RR(); return tree_->val_tag(id_); }    /**< Forward to @ref Tree::val_tag(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr val_ref()    const RYML_NOEXCEPT { _C4RR(); return tree_->val_ref(id_); }    /**< Forward to @ref Tree::val_ref(). Node must be readable. */
+    C4_ALWAYS_INLINE csubstr val_anchor() const RYML_NOEXCEPT { _C4RR(); return tree_->val_anchor(id_); } /**< Forward to @ref Tree::val_anchor(). Node must be readable. */
+
+    C4_ALWAYS_INLINE NodeScalar const& keysc() const RYML_NOEXCEPT { _C4RR(); return tree_->keysc(id_); } /**< Forward to @ref Tree::keysc(). Node must be readable. */
+    C4_ALWAYS_INLINE NodeScalar const& valsc() const RYML_NOEXCEPT { _C4RR(); return tree_->valsc(id_); } /**< Forward to @ref Tree::valsc(). Node must be readable. */
+
+    C4_ALWAYS_INLINE bool key_is_null() const RYML_NOEXCEPT { _C4RR(); return tree_->key_is_null(id_); } /**< Forward to @ref Tree::key_is_null(). Node must be readable. */
+    C4_ALWAYS_INLINE bool val_is_null() const RYML_NOEXCEPT { _C4RR(); return tree_->val_is_null(id_); } /**< Forward to @ref Tree::val_is_null(). Node must be readable. */
+
+    C4_ALWAYS_INLINE bool is_key_unfiltered() const noexcept { _C4RR(); return tree_->is_key_unfiltered(id_); } /**< Forward to @ref Tree::is_key_unfiltered(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_unfiltered() const noexcept { _C4RR(); return tree_->is_val_unfiltered(id_); } /**< Forward to @ref Tree::is_val_unfiltered(). Node must be readable. */
+
+    /** @} */
+
+public:
+
+    /** @name node type predicates */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool empty()            const RYML_NOEXCEPT { _C4RR(); return tree_->empty(id_); } /**< Forward to @ref Tree::empty(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_stream()        const RYML_NOEXCEPT { _C4RR(); return tree_->is_stream(id_); } /**< Forward to @ref Tree::is_stream(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_doc()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_doc(id_); } /**< Forward to @ref Tree::is_doc(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_container()     const RYML_NOEXCEPT { _C4RR(); return tree_->is_container(id_); } /**< Forward to @ref Tree::is_container(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_map()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_map(id_); } /**< Forward to @ref Tree::is_map(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_seq()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_seq(id_); } /**< Forward to @ref Tree::is_seq(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_val()          const RYML_NOEXCEPT { _C4RR(); return tree_->has_val(id_); } /**< Forward to @ref Tree::has_val(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_key()          const RYML_NOEXCEPT { _C4RR(); return tree_->has_key(id_); } /**< Forward to @ref Tree::has_key(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_val(id_); } /**< Forward to @ref Tree::is_val(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_keyval()        const RYML_NOEXCEPT { _C4RR(); return tree_->is_keyval(id_); } /**< Forward to @ref Tree::is_keyval(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_key_tag()      const RYML_NOEXCEPT { _C4RR(); return tree_->has_key_tag(id_); } /**< Forward to @ref Tree::has_key_tag(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_val_tag()      const RYML_NOEXCEPT { _C4RR(); return tree_->has_val_tag(id_); } /**< Forward to @ref Tree::has_val_tag(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_key_anchor()   const RYML_NOEXCEPT { _C4RR(); return tree_->has_key_anchor(id_); } /**< Forward to @ref Tree::has_key_anchor(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_val_anchor()   const RYML_NOEXCEPT { _C4RR(); return tree_->has_val_anchor(id_); } /**< Forward to @ref Tree::has_val_anchor(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_anchor()       const RYML_NOEXCEPT { _C4RR(); return tree_->has_anchor(id_); } /**< Forward to @ref Tree::has_anchor(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_ref()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_ref(id_); } /**< Forward to @ref Tree::is_key_ref(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_ref()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_ref(id_); } /**< Forward to @ref Tree::is_val_ref(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_ref()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_ref(id_); } /**< Forward to @ref Tree::is_ref(). Node must be readable. */
+    C4_ALWAYS_INLINE bool parent_is_seq()    const RYML_NOEXCEPT { _C4RR(); return tree_->parent_is_seq(id_); } /**< Forward to @ref Tree::parent_is_seq(). Node must be readable. */
+    C4_ALWAYS_INLINE bool parent_is_map()    const RYML_NOEXCEPT { _C4RR(); return tree_->parent_is_map(id_); } /**< Forward to @ref Tree::parent_is_map(). Node must be readable. */
+
+    RYML_DEPRECATED("use has_key_anchor()")  bool is_key_anchor() const noexcept { _C4RR(); return tree_->has_key_anchor(id_); }
+    RYML_DEPRECATED("use has_val_anchor()")  bool is_val_hanchor() const noexcept { _C4RR(); return tree_->has_val_anchor(id_); }
+    RYML_DEPRECATED("use has_anchor()")      bool is_anchor()     const noexcept { _C4RR(); return tree_->has_anchor(id_); }
+    RYML_DEPRECATED("use has_anchor() || is_ref()") bool is_anchor_or_ref() const noexcept { _C4RR(); return tree_->is_anchor_or_ref(id_); }
+
+    /** @} */
+
+public:
+
+    /** @name node container+scalar style predicates */
+    /** @{ */
+
+    // documentation to the right -->
+
+    C4_ALWAYS_INLINE bool type_has_any(NodeType_e bits)  const RYML_NOEXCEPT { _C4RR(); return tree_->type_has_any(id_, bits); }  /**< Forward to @ref Tree::type_has_any(). Node must be readable. */
+    C4_ALWAYS_INLINE bool type_has_all(NodeType_e bits)  const RYML_NOEXCEPT { _C4RR(); return tree_->type_has_all(id_, bits); }  /**< Forward to @ref Tree::type_has_all(). Node must be readable. */
+    C4_ALWAYS_INLINE bool type_has_none(NodeType_e bits) const RYML_NOEXCEPT { _C4RR(); return tree_->type_has_none(id_, bits); } /**< Forward to @ref Tree::type_has_none(). Node must be readable. */
+
+    C4_ALWAYS_INLINE bool is_container_styled() const RYML_NOEXCEPT { _C4RR(); return tree_->is_container_styled(id_); } /**< Forward to @ref Tree::is_container_styled(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_block()            const RYML_NOEXCEPT { _C4RR(); return tree_->is_block(id_); }   /**< Forward to @ref Tree::is_block(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_flow_sl()          const RYML_NOEXCEPT { _C4RR(); return tree_->is_flow_sl(id_); } /**< Forward to @ref Tree::is_flow_sl(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_flow_ml()          const RYML_NOEXCEPT { _C4RR(); return tree_->is_flow_ml(id_); } /**< Forward to @ref Tree::is_flow_ml(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_flow()             const RYML_NOEXCEPT { _C4RR(); return tree_->is_flow(id_); }    /**< Forward to @ref Tree::is_flow(). Node must be readable. */
+
+    C4_ALWAYS_INLINE bool is_key_styled()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_styled(id_); }  /**< Forward to @ref Tree::is_key_styled(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_styled()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_styled(id_); }  /**< Forward to @ref Tree::is_val_styled(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_literal()      const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_literal(id_); } /**< Forward to @ref Tree::is_key_literal(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_literal()      const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_literal(id_); } /**< Forward to @ref Tree::is_val_literal(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_folded()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_folded(id_); }  /**< Forward to @ref Tree::is_key_folded(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_folded()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_folded(id_); }  /**< Forward to @ref Tree::is_val_folded(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_squo()         const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_squo(id_); }    /**< Forward to @ref Tree::is_key_squo(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_squo()         const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_squo(id_); }    /**< Forward to @ref Tree::is_val_squo(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_dquo()         const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_dquo(id_); }    /**< Forward to @ref Tree::is_key_dquo(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_dquo()         const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_dquo(id_); }    /**< Forward to @ref Tree::is_val_dquo(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_plain()        const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_plain(id_); }   /**< Forward to @ref Tree::is_key_plain(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_plain()        const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_plain(id_); }   /**< Forward to @ref Tree::is_val_plain(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_key_quoted()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_key_quoted(id_); }  /**< Forward to @ref Tree::is_key_quoted(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_val_quoted()       const RYML_NOEXCEPT { _C4RR(); return tree_->is_val_quoted(id_); }  /**< Forward to @ref Tree::is_val_quoted(). Node must be readable. */
+    C4_ALWAYS_INLINE bool is_quoted()           const RYML_NOEXCEPT { _C4RR(); return tree_->is_quoted(id_); }      /**< Forward to @ref Tree::is_quoted(). Node must be readable. */
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy predicates */
+    /** @{ */
+
+    // documentation to the right -->
+
+    C4_ALWAYS_INLINE bool is_root()    const RYML_NOEXCEPT { _C4RR(); return tree_->is_root(id_); } /**< Forward to @ref Tree::is_root(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_parent() const RYML_NOEXCEPT { _C4RR(); return tree_->has_parent(id_); } /**< Forward to @ref Tree::has_parent()  Node must be readable. */
+    C4_ALWAYS_INLINE bool is_ancestor(ConstImpl const& ancestor) const RYML_NOEXCEPT { _C4RR(); return tree_->is_ancestor(id_, ancestor.m_id); } /**< Forward to @ref Tree::is_ancestor()  Node must be readable. */
+
+    C4_ALWAYS_INLINE bool has_child(ConstImpl const& n) const RYML_NOEXCEPT { _C4RR(); return n.readable() ? tree_->has_child(id_, n.m_id) : false; } /**< Forward to @ref Tree::has_child(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_child(id_type node) const RYML_NOEXCEPT { _C4RR(); return tree_->has_child(id_, node); } /**< Forward to @ref Tree::has_child(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_child(csubstr name) const RYML_NOEXCEPT { _C4RR(); return tree_->has_child(id_, name); } /**< Forward to @ref Tree::has_child(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_children() const RYML_NOEXCEPT { _C4RR(); return tree_->has_children(id_); } /**< Forward to @ref Tree::has_child(). Node must be readable. */
+
+    C4_ALWAYS_INLINE bool has_sibling(ConstImpl const& n) const RYML_NOEXCEPT { _C4RR(); return n.readable() ? tree_->has_sibling(id_, n.m_id) : false; } /**< Forward to @ref Tree::has_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_sibling(id_type node) const RYML_NOEXCEPT { _C4RR(); return tree_->has_sibling(id_, node); } /**< Forward to @ref Tree::has_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_sibling(csubstr name) const RYML_NOEXCEPT { _C4RR(); return tree_->has_sibling(id_, name); } /**< Forward to @ref Tree::has_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE bool has_other_siblings() const RYML_NOEXCEPT { _C4RR(); return tree_->has_other_siblings(id_); }  /**< Forward to @ref Tree::has_sibling(). Node must be readable. */
+
+    RYML_DEPRECATED("use has_other_siblings()") bool has_siblings() const RYML_NOEXCEPT { _C4RR(); return tree_->has_siblings(id_); }
+
+    /** @} */
+
+public:
+
+    /** @name hierarchy getters */
+    /** @{ */
+
+    // documentation to the right -->
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto doc(id_type i) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { RYML_ASSERT(tree_); return {tree__, tree__->doc(i)}; } /**< Forward to @ref Tree::doc(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl doc(id_type i) const RYML_NOEXCEPT { RYML_ASSERT(tree_); return {tree_, tree_->doc(i)}; }                /**< Forward to @ref Tree::doc(). Node must be readable. succeeds even when the node may have invalid or seed id */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto parent() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->parent(id__)}; } /**< Forward to @ref Tree::parent(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl parent() const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->parent(id_)}; }                 /**< Forward to @ref Tree::parent(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto first_child() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->first_child(id__)}; }  /**< Forward to @ref Tree::first_child(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl first_child() const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->first_child(id_)}; }                  /**< Forward to @ref Tree::first_child(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto last_child() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->last_child(id__)}; }  /**< Forward to @ref Tree::last_child(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl last_child () const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->last_child (id_)}; }                /**< Forward to @ref Tree::last_child(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto child(id_type pos) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->child(id__, pos)}; }  /**< Forward to @ref Tree::child(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl child(id_type pos) const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->child(id_, pos)}; }                  /**< Forward to @ref Tree::child(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto find_child(csubstr name)  RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->find_child(id__, name)}; }  /**< Forward to @ref Tree::first_child(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl find_child(csubstr name) const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->find_child(id_, name)}; }                   /**< Forward to @ref Tree::first_child(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto prev_sibling() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->prev_sibling(id__)}; }  /**< Forward to @ref Tree::prev_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl prev_sibling() const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->prev_sibling(id_)}; }                  /**< Forward to @ref Tree::prev_sibling(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto next_sibling() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->next_sibling(id__)}; }  /**< Forward to @ref Tree::next_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl next_sibling() const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->next_sibling(id_)}; }                  /**< Forward to @ref Tree::next_sibling(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto first_sibling() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->first_sibling(id__)}; }  /**< Forward to @ref Tree::first_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl first_sibling() const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->first_sibling(id_)}; }                  /**< Forward to @ref Tree::first_sibling(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto last_sibling() RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->last_sibling(id__)}; }  /**< Forward to @ref Tree::last_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl last_sibling () const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->last_sibling(id_)}; }                 /**< Forward to @ref Tree::last_sibling(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto sibling(id_type pos) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->sibling(id__, pos)}; }  /**< Forward to @ref Tree::sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl sibling(id_type pos) const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->sibling(id_, pos)}; }                  /**< Forward to @ref Tree::sibling(). Node must be readable. */
+
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto find_sibling(csubstr name) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl) { _C4RR(); return {tree__, tree__->find_sibling(id__, name)}; }  /**< Forward to @ref Tree::find_sibling(). Node must be readable. */
+    C4_ALWAYS_INLINE ConstImpl find_sibling(csubstr name) const RYML_NOEXCEPT { _C4RR(); return {tree_, tree_->find_sibling(id_, name)}; }                  /**< Forward to @ref Tree::find_sibling(). Node must be readable. */
+
+    C4_ALWAYS_INLINE id_type num_children() const RYML_NOEXCEPT { _C4RR(); return tree_->num_children(id_); } /**< O(num_children). Forward to @ref Tree::num_children(). */
+    C4_ALWAYS_INLINE id_type num_siblings() const RYML_NOEXCEPT { _C4RR(); return tree_->num_siblings(id_); } /**< O(num_children). Forward to @ref Tree::num_siblings(). */
+    C4_ALWAYS_INLINE id_type num_other_siblings() const RYML_NOEXCEPT { _C4RR(); return tree_->num_other_siblings(id_); } /**< O(num_siblings). Forward to @ref Tree::num_other_siblings(). */
+    C4_ALWAYS_INLINE id_type child_pos(ConstImpl const& n) const RYML_NOEXCEPT { _C4RR(); _RYML_CB_ASSERT(tree_->m_callbacks, n.readable()); return tree_->child_pos(id_, n.m_id); } /**< O(num_children). Forward to @ref Tree::child_pos(). */
+    C4_ALWAYS_INLINE id_type sibling_pos(ConstImpl const& n) const RYML_NOEXCEPT { _C4RR(); _RYML_CB_ASSERT(tree_->callbacks(), n.readable()); return tree_->child_pos(tree_->parent(id_), n.m_id); } /**< O(num_siblings). Forward to @ref Tree::sibling_pos(). */
+
+    C4_ALWAYS_INLINE id_type depth_asc() const RYML_NOEXCEPT { _C4RR(); return tree_->depth_asc(id_); } /** O(log(num_nodes)). Forward to Tree::depth_asc(). Node must be readable. */
+    C4_ALWAYS_INLINE id_type depth_desc() const RYML_NOEXCEPT { _C4RR(); return tree_->depth_desc(id_); } /** O(num_nodes). Forward to Tree::depth_desc(). Node must be readable. */
+
+    /** @} */
+
+public:
+
+    /** @name square_brackets
+     * operator[] */
+    /** @{ */
+
+    /** Find child by key; complexity is O(num_children).
+     *
+     * Returns the requested node, or an object in seed state if no
+     * such child is found (see @ref NodeRef for an explanation of
+     * what is seed state). When the object is in seed state, using it
+     * to read from the tree is UB. The seed node can be used to write
+     * to the tree provided that its create() method is called prior
+     * to writing, which happens in most modifying methods in
+     * NodeRef. It is the caller's responsibility to verify that the
+     * returned node is readable before subsequently using it to read
+     * from the tree.
+     *
+     * @warning the calling object must be readable. This precondition
+     * is asserted. The assertion is performed only if @ref
+     * RYML_USE_ASSERT is set to true. As with the non-const overload,
+     * it is UB to call this method if the node is not readable.
+     *
+     * @see https://github.com/biojppm/rapidyaml/issues/389 */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto operator[] (csubstr key) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl)
+    {
+        _C4RR();
+        id_type ch = tree__->find_child(id__, key);
+        return ch != NONE ? Impl(tree__, ch) : Impl(tree__, id__, key);
+    }
+
+    /** Find child by position; complexity is O(pos).
+     *
+     * Returns the requested node, or an object in seed state if no
+     * such child is found (see @ref NodeRef for an explanation of
+     * what is seed state). When the object is in seed state, using it
+     * to read from the tree is UB. The seed node can be used to write
+     * to the tree provided that its create() method is called prior
+     * to writing, which happens in most modifying methods in
+     * NodeRef. It is the caller's responsibility to verify that the
+     * returned node is readable before subsequently using it to read
+     * from the tree.
+     *
+     * @warning the calling object must be readable. This precondition
+     * is asserted. The assertion is performed only if @ref
+     * RYML_USE_ASSERT is set to true. As with the non-const overload,
+     * it is UB to call this method if the node is not readable.
+     *
+     * @see https://github.com/biojppm/rapidyaml/issues/389 */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto operator[] (id_type pos) RYML_NOEXCEPT -> _C4_IF_MUTABLE(Impl)
+    {
+        _C4RR();
+        id_type ch = tree__->child(id__, pos);
+        return ch != NONE ? Impl(tree__, ch) : Impl(tree__, id__, pos);
+    }
+
+    /** Find a child by key; complexity is O(num_children).
+     *
+     * Behaves similar to the non-const overload, but further asserts
+     * that the returned node is readable (because it can never be in
+     * a seed state). The assertion is performed only if @ref
+     * RYML_USE_ASSERT is set to true. As with the non-const overload,
+     * it is UB to use the return value if it is not valid.
+     *
+     * @see https://github.com/biojppm/rapidyaml/issues/389  */
+    C4_ALWAYS_INLINE ConstImpl operator[] (csubstr key) const RYML_NOEXCEPT
+    {
+        _C4RR();
+        id_type ch = tree_->find_child(id_, key);
+        _RYML_CB_ASSERT(tree_->m_callbacks, ch != NONE);
+        return {tree_, ch};
+    }
+
+    /** Find a child by position; complexity is O(pos).
+     *
+     * Behaves similar to the non-const overload, but further asserts
+     * that the returned node is readable (because it can never be in
+     * a seed state). This assertion is performed only if @ref
+     * RYML_USE_ASSERT is set to true. As with the non-const overload,
+     * it is UB to use the return value if it is not valid.
+     *
+     * @see https://github.com/biojppm/rapidyaml/issues/389  */
+    C4_ALWAYS_INLINE ConstImpl operator[] (id_type pos) const RYML_NOEXCEPT
+    {
+        _C4RR();
+        id_type ch = tree_->child(id_, pos);
+        _RYML_CB_ASSERT(tree_->m_callbacks, ch != NONE);
+        return {tree_, ch};
+    }
+
+    /** @} */
+
+public:
+
+    /** @name at
+     *
+     * These functions are the analogue to operator[], with the
+     * difference that they emit an error instead of an
+     * assertion. That is, if any of the pre or post conditions is
+     * violated, an error is always emitted (resulting in a call to
+     * the error callback).
+     *
+     * @{ */
+
+    /** Find child by key; complexity is O(num_children).
+     *
+     * Returns the requested node, or an object in seed state if no
+     * such child is found (see @ref NodeRef for an explanation of
+     * what is seed state). When the object is in seed state, using it
+     * to read from the tree is UB. The seed node can be subsequently
+     * used to write to the tree provided that its create() method is
+     * called prior to writing, which happens inside most mutating
+     * methods in NodeRef. It is the caller's responsibility to verify
+     * that the returned node is readable before subsequently using it
+     * to read from the tree.
+     *
+     * @warning This method will call the error callback (regardless
+     * of build type or of the value of RYML_USE_ASSERT) whenever any
+     * of the following preconditions is violated: a) the object is
+     * valid (points at a tree and a node), b) the calling object must
+     * be readable (must not be in seed state), c) the calling object
+     * must be pointing at a MAP node. The preconditions are similar
+     * to the non-const operator[](csubstr), but instead of using
+     * assertions, this function directly checks those conditions and
+     * calls the error callback if any of the checks fail.
+     *
+     * @note since it is valid behavior for the returned node to be in
+     * seed state, the error callback is not invoked when this
+     * happens. */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto at(csubstr key) -> _C4_IF_MUTABLE(Impl)
+    {
+        RYML_CHECK(tree_ != nullptr);
+        _RYML_CB_CHECK(tree_->m_callbacks, (id_ >= 0 && id_ < tree_->capacity()));
+        _RYML_CB_CHECK(tree_->m_callbacks, ((Impl const*)this)->readable());
+        _RYML_CB_CHECK(tree_->m_callbacks, tree_->is_map(id_));
+        id_type ch = tree__->find_child(id__, key);
+        return ch != NONE ? Impl(tree__, ch) : Impl(tree__, id__, key);
+    }
+
+    /** Find child by position; complexity is O(pos).
+     *
+     * Returns the requested node, or an object in seed state if no
+     * such child is found (see @ref NodeRef for an explanation of
+     * what is seed state). When the object is in seed state, using it
+     * to read from the tree is UB. The seed node can be used to write
+     * to the tree provided that its create() method is called prior
+     * to writing, which happens in most modifying methods in
+     * NodeRef. It is the caller's responsibility to verify that the
+     * returned node is readable before subsequently using it to read
+     * from the tree.
+     *
+     * @warning This method will call the error callback (regardless
+     * of build type or of the value of RYML_USE_ASSERT) whenever any
+     * of the following preconditions is violated: a) the object is
+     * valid (points at a tree and a node), b) the calling object must
+     * be readable (must not be in seed state), c) the calling object
+     * must be pointing at a MAP node. The preconditions are similar
+     * to the non-const operator[](id_type), but instead of using
+     * assertions, this function directly checks those conditions and
+     * calls the error callback if any of the checks fail.
+     *
+     * @note since it is valid behavior for the returned node to be in
+     * seed state, the error callback is not invoked when this
+     * happens. */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto at(id_type pos) -> _C4_IF_MUTABLE(Impl)
+    {
+        RYML_CHECK(tree_ != nullptr);
+        const id_type cap = tree_->capacity();
+        _RYML_CB_CHECK(tree_->m_callbacks, (id_ >= 0 && id_ < cap));
+        _RYML_CB_CHECK(tree_->m_callbacks, (pos >= 0 && pos < cap));
+        _RYML_CB_CHECK(tree_->m_callbacks, ((Impl const*)this)->readable());
+        _RYML_CB_CHECK(tree_->m_callbacks, tree_->is_container(id_));
+        id_type ch = tree__->child(id__, pos);
+        return ch != NONE ? Impl(tree__, ch) : Impl(tree__, id__, pos);
+    }
+
+    /** Get a child by name, with error checking; complexity is
+     * O(num_children).
+     *
+     * Behaves as operator[](csubstr) const, but always raises an
+     * error (even when RYML_USE_ASSERT is set to false) when the
+     * returned node does not exist, or when this node is not
+     * readable, or when it is not a map. This behaviour is similar to
+     * std::vector::at(), but the error consists in calling the error
+     * callback instead of directly raising an exception. */
+    ConstImpl at(csubstr key) const
+    {
+        RYML_CHECK(tree_ != nullptr);
+        _RYML_CB_CHECK(tree_->m_callbacks, (id_ >= 0 && id_ < tree_->capacity()));
+        _RYML_CB_CHECK(tree_->m_callbacks, ((Impl const*)this)->readable());
+        _RYML_CB_CHECK(tree_->m_callbacks, tree_->is_map(id_));
+        id_type ch = tree_->find_child(id_, key);
+        _RYML_CB_CHECK(tree_->m_callbacks, ch != NONE);
+        return {tree_, ch};
+    }
+
+    /** Get a child by position, with error checking; complexity is
+     * O(pos).
+     *
+     * Behaves as operator[](id_type) const, but always raises an error
+     * (even when RYML_USE_ASSERT is set to false) when the returned
+     * node does not exist, or when this node is not readable, or when
+     * it is not a container. This behaviour is similar to
+     * std::vector::at(), but the error consists in calling the error
+     * callback instead of directly raising an exception. */
+    ConstImpl at(id_type pos) const
+    {
+        RYML_CHECK(tree_ != nullptr);
+        const id_type cap = tree_->capacity();
+        _RYML_CB_CHECK(tree_->m_callbacks, (id_ >= 0 && id_ < cap));
+        _RYML_CB_CHECK(tree_->m_callbacks, (pos >= 0 && pos < cap));
+        _RYML_CB_CHECK(tree_->m_callbacks, ((Impl const*)this)->readable());
+        _RYML_CB_CHECK(tree_->m_callbacks, tree_->is_container(id_));
+        const id_type ch = tree_->child(id_, pos);
+        _RYML_CB_CHECK(tree_->m_callbacks, ch != NONE);
+        return {tree_, ch};
+    }
+
+    /** @} */
+
+public:
+
+    /** @name deserialization */
+    /** @{ */
+
+    /** deserialize the node's val to the given variable, forwarding
+     * to the user-overrideable @ref read() function. */
+    template<class T>
+    ConstImpl const& operator>> (T &v) const
+    {
+        _C4RR();
+        if( ! read((ConstImpl const&)*this, &v))
+            _RYML_CB_ERR(tree_->m_callbacks, "could not deserialize value");
+        return *((ConstImpl const*)this);
+    }
+
+    /** deserialize the node's key to the given variable, forwarding
+     * to the user-overrideable @ref read() function; use @ref key()
+     * to disambiguate; for example: `node >> ryml::key(var)` */
+    template<class T>
+    ConstImpl const& operator>> (Key<T> v) const
+    {
+        _C4RR();
+        if( ! readkey((ConstImpl const&)*this, &v.k))
+            _RYML_CB_ERR(tree_->m_callbacks, "could not deserialize key");
+        return *((ConstImpl const*)this);
+    }
+
+    /** look for a child by name, if it exists assign to var. return
+     * true if the child existed. */
+    template<class T>
+    bool get_if(csubstr name, T *var) const
+    {
+        _C4RR();
+        ConstImpl ch = find_child(name);
+        if(!ch.readable())
+            return false;
+        ch >> *var;
+        return true;
+    }
+
+    /** look for a child by name, if it exists assign to var,
+     * otherwise default to fallback. return true if the child
+     * existed. */
+    template<class T>
+    bool get_if(csubstr name, T *var, T const& fallback) const
+    {
+        _C4RR();
+        ConstImpl ch = find_child(name);
+        if(ch.readable())
+        {
+            ch >> *var;
+            return true;
+        }
+        else
+        {
+            *var = fallback;
+            return false;
+        }
+    }
+
+    /** @name deserialization_base64 */
+    /** @{ */
+
+    /** deserialize the node's key as base64. lightweight wrapper over @ref deserialize_key() */
+    ConstImpl const& operator>> (Key<fmt::base64_wrapper> w) const
+    {
+        deserialize_key(w.wrapper);
+        return *((ConstImpl const*)this);
+    }
+
+    /** deserialize the node's val as base64. lightweight wrapper over @ref deserialize_val() */
+    ConstImpl const& operator>> (fmt::base64_wrapper w) const
+    {
+        deserialize_val(w);
+        return *((ConstImpl const*)this);
+    }
+
+    /** decode the base64-encoded key 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
+    {
+        _C4RR();
+        return from_chars(key(), &v);
+    }
+    /** decode the base64-encoded key 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
+    {
+        _C4RR();
+        return from_chars(val(), &v);
+    };
+
+    /** @} */
+
+    /** @} */
+
+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
+
+    /** @name iteration */
+    /** @{ */
+
+    using iterator = detail::child_iterator<Impl>;
+    using const_iterator = detail::child_iterator<ConstImpl>;
+    using children_view = detail::children_view_<Impl>;
+    using const_children_view = detail::children_view_<ConstImpl>;
+
+    /** get an iterator to the first child */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto begin() RYML_NOEXCEPT -> _C4_IF_MUTABLE(iterator) { _C4RR(); return iterator(tree__, tree__->first_child(id__)); }
+    /** get an iterator to the first child */
+    C4_ALWAYS_INLINE const_iterator begin() const RYML_NOEXCEPT { _C4RR(); return const_iterator(tree_, tree_->first_child(id_)); }
+    /** get an iterator to the first child */
+    C4_ALWAYS_INLINE const_iterator cbegin() const RYML_NOEXCEPT { _C4RR(); return const_iterator(tree_, tree_->first_child(id_)); }
+
+    /** get an iterator to after the last child */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto end() RYML_NOEXCEPT -> _C4_IF_MUTABLE(iterator) { _C4RR(); return iterator(tree__, NONE); }
+    /** get an iterator to after the last child */
+    C4_ALWAYS_INLINE const_iterator end() const RYML_NOEXCEPT { _C4RR(); return const_iterator(tree_, NONE); }
+    /** get an iterator to after the last child */
+    C4_ALWAYS_INLINE const_iterator cend() const RYML_NOEXCEPT { _C4RR(); return const_iterator(tree_, tree_->first_child(id_)); }
+
+    /** get an iterable view over children */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto children() RYML_NOEXCEPT -> _C4_IF_MUTABLE(children_view) { _C4RR(); return children_view(begin(), end()); }
+    /** get an iterable view over children */
+    C4_ALWAYS_INLINE const_children_view children() const RYML_NOEXCEPT { _C4RR(); return const_children_view(begin(), end()); }
+    /** get an iterable view over children */
+    C4_ALWAYS_INLINE const_children_view cchildren() const RYML_NOEXCEPT { _C4RR(); return const_children_view(begin(), end()); }
+
+    /** get an iterable view over all siblings (including the calling node) */
+    template<class U=Impl>
+    C4_ALWAYS_INLINE auto siblings() RYML_NOEXCEPT -> _C4_IF_MUTABLE(children_view)
+    {
+        _C4RR();
+        NodeData const *nd = tree__->get(id__);
+        return (nd->m_parent != NONE) ? // does it have a parent?
+            children_view(iterator(tree__, tree_->get(nd->m_parent)->m_first_child), iterator(tree__, NONE))
+            :
+            children_view(end(), end());
+    }
+    /** get an iterable view over all siblings (including the calling node) */
+    C4_ALWAYS_INLINE const_children_view siblings() const RYML_NOEXCEPT
+    {
+        _C4RR();
+        NodeData const *nd = tree_->get(id_);
+        return (nd->m_parent != NONE) ? // does it have a parent?
+            const_children_view(const_iterator(tree_, tree_->get(nd->m_parent)->m_first_child), const_iterator(tree_, NONE))
+            :
+            const_children_view(end(), end());
+    }
+    /** get an iterable view over all siblings (including the calling node) */
+    C4_ALWAYS_INLINE const_children_view csiblings() const RYML_NOEXCEPT { return siblings(); }
+
+    /** visit every child node calling fn(node) */
+    template<class Visitor>
+    bool visit(Visitor fn, id_type indentation_level=0, bool skip_root=true) const RYML_NOEXCEPT
+    {
+        _C4RR();
+        return detail::_visit(*(ConstImpl const*)this, fn, indentation_level, skip_root);
+    }
+    /** visit every child node calling fn(node) */
+    template<class Visitor, class U=Impl>
+    auto visit(Visitor fn, id_type indentation_level=0, bool skip_root=true) RYML_NOEXCEPT
+        -> _C4_IF_MUTABLE(bool)
+    {
+        _C4RR();
+        return detail::_visit(*(Impl*)this, fn, indentation_level, skip_root);
+    }
+
+    /** visit every child node calling fn(node, level) */
+    template<class Visitor>
+    bool visit_stacked(Visitor fn, id_type indentation_level=0, bool skip_root=true) const RYML_NOEXCEPT
+    {
+        _C4RR();
+        return detail::_visit_stacked(*(ConstImpl const*)this, fn, indentation_level, skip_root);
+    }
+    /** visit every child node calling fn(node, level) */
+    template<class Visitor, class U=Impl>
+    auto visit_stacked(Visitor fn, id_type indentation_level=0, bool skip_root=true) RYML_NOEXCEPT
+        -> _C4_IF_MUTABLE(bool)
+    {
+        _C4RR();
+        return detail::_visit_stacked(*(Impl*)this, fn, indentation_level, skip_root);
+    }
+
+    /** @} */
+
+    #if defined(__clang__)
+    #   pragma clang diagnostic pop
+    #elif defined(__GNUC__)
+    #   pragma GCC diagnostic pop
+    #endif
+
+    #undef _C4_IF_MUTABLE
+    #undef _C4RR
+    #undef tree_
+    #undef tree__
+    #undef id_
+    #undef id__
+
+    C4_SUPPRESS_WARNING_GCC_CLANG_POP
+};
+} // detail
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** Holds a pointer to an existing tree, and a node id. It can be used
+ * only to read from the tree.
+ *
+ * @warning The lifetime of the tree must be larger than that of this
+ * object. It is up to the user to ensure that this happens. */
+class RYML_EXPORT ConstNodeRef : public detail::RoNodeMethods<ConstNodeRef, ConstNodeRef> // NOLINT
+{
+public:
+
+    using tree_type = Tree const;
+
+public:
+
+    Tree const* C4_RESTRICT m_tree;
+    id_type m_id;
+
+    friend NodeRef;
+    friend struct detail::RoNodeMethods<ConstNodeRef, ConstNodeRef>;
+
+public:
+
+    /** @name construction */
+    /** @{ */
+
+    ConstNodeRef() noexcept : m_tree(nullptr), m_id(NONE) {}
+    ConstNodeRef(Tree const &t) noexcept : m_tree(&t), m_id(t .root_id()) {}
+    ConstNodeRef(Tree const *t) noexcept : m_tree(t ), m_id(t->root_id()) {}
+    ConstNodeRef(Tree const *t, id_type id) noexcept : m_tree(t), m_id(id) {}
+    ConstNodeRef(std::nullptr_t) noexcept : m_tree(nullptr), m_id(NONE) {}
+
+    ConstNodeRef(ConstNodeRef const&) noexcept = default;
+    ConstNodeRef(ConstNodeRef     &&) noexcept = default;
+
+    inline ConstNodeRef(NodeRef const&) noexcept;
+    inline ConstNodeRef(NodeRef     &&) noexcept;
+
+    /** @} */
+
+public:
+
+    /** @name assignment */
+    /** @{ */
+
+    ConstNodeRef& operator= (std::nullptr_t) noexcept { m_tree = nullptr; m_id = NONE; return *this; }
+
+    ConstNodeRef& operator= (ConstNodeRef const&) noexcept = default;
+    ConstNodeRef& operator= (ConstNodeRef     &&) noexcept = default;
+
+    ConstNodeRef& operator= (NodeRef const&) noexcept;
+    ConstNodeRef& operator= (NodeRef     &&) noexcept;
+
+
+    /** @} */
+
+public:
+
+    /** @name state queries
+     *
+     * see @ref NodeRef for an explanation on what these states mean */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool invalid() const noexcept { return (!m_tree) || (m_id == NONE); }
+    /** because a ConstNodeRef cannot be used to write to the tree,
+     * readable() has the same meaning as !invalid() */
+    C4_ALWAYS_INLINE bool readable() const noexcept { return m_tree != nullptr && m_id != NONE; }
+    /** because a ConstNodeRef cannot be used to write to the tree, it can never be a seed.
+     * This method is provided for API equivalence between ConstNodeRef and NodeRef. */
+    constexpr static C4_ALWAYS_INLINE bool is_seed() noexcept { return false; }
+
+    RYML_DEPRECATED("use one of readable(), is_seed() or !invalid()") bool valid() const noexcept { return m_tree != nullptr && m_id != NONE; }
+
+    /** @} */
+
+public:
+
+    /** @name member getters */
+    /** @{ */
+
+    C4_ALWAYS_INLINE Tree const* tree() const noexcept { return m_tree; }
+    C4_ALWAYS_INLINE id_type id() const noexcept { return m_id; }
+
+    /** @} */
+
+public:
+
+    /** @name comparisons */
+    /** @{ */
+
+    C4_ALWAYS_INLINE bool operator== (ConstNodeRef const& that) const RYML_NOEXCEPT { return that.m_tree == m_tree && m_id == that.m_id; }
+    C4_ALWAYS_INLINE bool operator!= (ConstNodeRef const& that) const RYML_NOEXCEPT { return ! this->operator== (that); }
+
+    /** @cond dev */
+    RYML_DEPRECATED("use invalid()")  bool operator== (std::nullptr_t) const noexcept { return m_tree == nullptr || m_id == NONE; }
+    RYML_DEPRECATED("use !invalid()") bool operator!= (std::nullptr_t) const noexcept { return !(m_tree == nullptr || m_id == NONE); }
+
+    RYML_DEPRECATED("use (this->val() == s)") bool operator== (csubstr s) const RYML_NOEXCEPT { RYML_ASSERT(m_tree); _RYML_CB_ASSERT(m_tree->m_callbacks, m_id != NONE); return m_tree->val(m_id) == s; }
+    RYML_DEPRECATED("use (this->val() != s)") bool operator!= (csubstr s) const RYML_NOEXCEPT { RYML_ASSERT(m_tree); _RYML_CB_ASSERT(m_tree->m_callbacks, m_id != NONE); return m_tree->val(m_id) != s; }
+    /** @endcond */
+
+    /** @} */
+
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// NOLINTBEGIN(cppcoreguidelines-c-copy-assignment-signature,misc-unconventional-assign-operator)
+
+/** A reference to a node in an existing yaml tree, offering a more
+ * convenient API than the index-based API used in the tree.
+ *
+ * Unlike its imutable ConstNodeRef peer, a NodeRef can be used to
+ * mutate the tree, both by writing to existing nodes and by creating
+ * new nodes to subsequently write to. Semantically, a NodeRef
+ * object can be in one of three states:
+ *
+ * ```text
+ * invalid  := not pointing at anything
+ * readable := points at an existing tree/node
+ * seed     := points at an existing tree, and the node
+ *             may come to exist, if we write to it.
+ * ```
+ *
+ * So both `readable` and `seed` are states where the node is also `valid`.
+ *
+ * ```cpp
+ * Tree t = parse_in_arena("{a: b}");
+ * NodeRef invalid; // not pointing at anything.
+ * NodeRef readable = t["a"]; // also valid, because "a" exists
+ * NodeRef seed = t["none"]; // also valid, but is seed because "none" is not in the map
+ * ```
+ *
+ * When the object is in seed state, using it to read from the tree is
+ * UB. The seed node can be used to write to the tree, provided that
+ * its create() method is called prior to writing, which happens in
+ * most modifying methods in NodeRef.
+ *
+ * It is the owners's responsibility to verify that an existing
+ * node is readable before subsequently using it to read from the
+ * tree.
+ *
+ * @warning The lifetime of the tree must be larger than that of this
+ * object. It is up to the user to ensure that this happens.
+ */
+class RYML_EXPORT NodeRef : public detail::RoNodeMethods<NodeRef, ConstNodeRef> // NOLINT
+{
+public:
+
+    using tree_type = Tree;
+    using base_type = detail::RoNodeMethods<NodeRef, ConstNodeRef>;
+
+private:
+
+    Tree *C4_RESTRICT m_tree;
+    id_type 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;
+
+    friend ConstNodeRef;
+    friend struct detail::RoNodeMethods<NodeRef, ConstNodeRef>;
+
+    // require valid: a helper macro, undefined at the end
+    #define _C4RR()                                                         \
+        RYML_ASSERT(m_tree != nullptr);                                     \
+        _RYML_CB_ASSERT(m_tree->m_callbacks, m_id != NONE && !is_seed())
+    // require id: a helper macro, undefined at the end
+    #define _C4RID()                                                        \
+        RYML_ASSERT(m_tree != nullptr);                                     \
+        _RYML_CB_ASSERT(m_tree->m_callbacks, m_id != NONE)
+
+public:
+
+    /** @name construction */
+    /** @{ */
+
+    NodeRef() noexcept : m_tree(nullptr), m_id(NONE), m_seed() { _clear_seed(); }
+    NodeRef(Tree &t) noexcept : m_tree(&t), m_id(t .root_id()), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t) noexcept : m_tree(t ), m_id(t->root_id()), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t, id_type id) noexcept : m_tree(t), m_id(id), m_seed() { _clear_seed(); }
+    NodeRef(Tree *t, id_type id, id_type seed_pos) noexcept : m_tree(t), m_id(id), m_seed() { m_seed.str = nullptr; m_seed.len = (size_t)seed_pos; }
+    NodeRef(Tree *t, id_type id, csubstr  seed_key) noexcept : m_tree(t), m_id(id), m_seed(seed_key) {}
+    NodeRef(std::nullptr_t) noexcept : m_tree(nullptr), m_id(NONE), m_seed() {}
+
+    void _clear_seed() noexcept { /*do the following manually or an assert is triggered: */ m_seed.str = nullptr; m_seed.len = npos; }
+
+    /** @} */
+
+public:
+
+    /** @name assignment */
+    /** @{ */
+
+    NodeRef(NodeRef const&) noexcept = default;
+    NodeRef(NodeRef     &&) noexcept = default;
+
+    NodeRef& operator= (NodeRef const&) noexcept = default;
+    NodeRef& operator= (NodeRef     &&) noexcept = default;
+
+    /** @} */
+
+public:
+
+    /** @name state_queries
+     * @{ */
+
+    /** true if the object is not referring to any existing or seed node. @see the doc for @ref NodeRef */
+    bool invalid() const noexcept { return m_tree == nullptr || m_id == NONE; }
+    /** true if the object is not invalid and in seed state. @see the doc for @ref NodeRef */
+    bool is_seed() const noexcept { return (m_tree != nullptr && m_id != NONE) && (m_seed.str != nullptr || m_seed.len != (size_t)NONE); }
+    /** true if the object is not invalid and not in seed state. @see the doc for @ref NodeRef */
+    bool readable() const noexcept { return (m_tree != nullptr && m_id != NONE) && (m_seed.str == nullptr && m_seed.len == (size_t)NONE); }
+
+    RYML_DEPRECATED("use one of readable(), is_seed() or !invalid()") inline bool valid() const { return m_tree != nullptr && m_id != NONE; }
+
+    /** @} */
+
+public:
+
+    /** @name comparisons */
+    /** @{ */
+
+    bool operator== (NodeRef const& that) const
+    {
+        if(m_tree == that.m_tree && m_id == that.m_id)
+        {
+            bool seed = is_seed();
+            if(seed == that.is_seed())
+            {
+                if(seed)
+                {
+                    return (m_seed.len == that.m_seed.len)
+                        && (m_seed.str == that.m_seed.str
+                            || m_seed == that.m_seed); // do strcmp only in the last resort
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    bool operator!= (NodeRef const& that) const { return ! this->operator==(that); }
+
+    bool operator== (ConstNodeRef const& that) const { return m_tree == that.m_tree && m_id == that.m_id && !is_seed(); }
+    bool operator!= (ConstNodeRef const& that) const { return ! this->operator==(that); }
+
+    /** @cond dev */
+    RYML_DEPRECATED("use !readable()") bool operator== (std::nullptr_t) const { return m_tree == nullptr || m_id == NONE || is_seed(); }
+    RYML_DEPRECATED("use readable()")  bool operator!= (std::nullptr_t) const { return !(m_tree == nullptr || m_id == NONE || is_seed()); }
+
+    RYML_DEPRECATED("use `this->val() == s`") bool operator== (csubstr s) const { _C4RR(); _RYML_CB_ASSERT(m_tree->m_callbacks, has_val()); return m_tree->val(m_id) == s; }
+    RYML_DEPRECATED("use `this->val() != s`") bool operator!= (csubstr s) const { _C4RR(); _RYML_CB_ASSERT(m_tree->m_callbacks, has_val()); return m_tree->val(m_id) != s; }
+    /** @endcond */
+
+public:
+
+    /** @name node_property_getters
+     * @{ */
+
+    C4_ALWAYS_INLINE Tree * tree() noexcept { return m_tree; }
+    C4_ALWAYS_INLINE Tree const* tree() const noexcept { return m_tree; }
+
+    C4_ALWAYS_INLINE id_type id() const noexcept { return m_id; }
+
+    /** @} */
+
+public:
+
+    /** @name node_modifiers */
+    /** @{ */
+
+    void create() { _apply_seed(); }
+
+    void change_type(NodeType t) { _C4RR(); m_tree->change_type(m_id, t); }
+
+    void set_type(NodeType t) { _apply_seed(); m_tree->_set_flags(m_id, t); }
+    void set_key(csubstr key) { _apply_seed(); m_tree->_set_key(m_id, key); }
+    void set_val(csubstr val) { _apply_seed(); m_tree->_set_val(m_id, val); }
+    void set_key_tag(csubstr key_tag) { _apply_seed(); m_tree->set_key_tag(m_id, key_tag); }
+    void set_val_tag(csubstr val_tag) { _apply_seed(); m_tree->set_val_tag(m_id, val_tag); }
+    void set_key_anchor(csubstr key_anchor) { _apply_seed(); m_tree->set_key_anchor(m_id, key_anchor); }
+    void set_val_anchor(csubstr val_anchor) { _apply_seed(); m_tree->set_val_anchor(m_id, val_anchor); }
+    void set_key_ref(csubstr key_ref) { _apply_seed(); m_tree->set_key_ref(m_id, key_ref); }
+    void set_val_ref(csubstr val_ref) { _apply_seed(); m_tree->set_val_ref(m_id, val_ref); }
+
+    void set_container_style(NodeType_e style) { _C4RR(); m_tree->set_container_style(m_id, style); }
+    void set_key_style(NodeType_e style) { _C4RR(); m_tree->set_key_style(m_id, style); }
+    void set_val_style(NodeType_e style) { _C4RR(); m_tree->set_val_style(m_id, style); }
+
+public:
+
+    void clear()
+    {
+        if(is_seed())
+            return;
+        m_tree->remove_children(m_id);
+        m_tree->_clear(m_id);
+    }
+
+    void clear_key()
+    {
+        if(is_seed())
+            return;
+        m_tree->_clear_key(m_id);
+    }
+
+    void clear_val()
+    {
+        if(is_seed())
+            return;
+        m_tree->_clear_val(m_id);
+    }
+
+    void clear_children()
+    {
+        if(is_seed())
+            return;
+        m_tree->remove_children(m_id);
+    }
+
+    void operator= (NodeType_e t)
+    {
+        _apply_seed();
+        m_tree->_add_flags(m_id, t);
+    }
+
+    void operator|= (NodeType_e t)
+    {
+        _apply_seed();
+        m_tree->_add_flags(m_id, t);
+    }
+
+    void operator= (NodeInit const& v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    void operator= (NodeScalar const& v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    void operator= (std::nullptr_t)
+    {
+        _apply_seed();
+        _apply(csubstr{});
+    }
+
+    void operator= (csubstr v)
+    {
+        _apply_seed();
+        _apply(v);
+    }
+
+    template<size_t N>
+    void operator= (const char (&v)[N])
+    {
+        _apply_seed();
+        csubstr sv;
+        sv.assign<N>(v);
+        _apply(sv);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name serialization */
+    /** @{ */
+
+    /** serialize a variable to the arena */
+    template<class T>
+    csubstr to_arena(T const& C4_RESTRICT s)
+    {
+        RYML_ASSERT(m_tree); // no need for valid or readable
+        return m_tree->to_arena(s);
+    }
+
+    template<class T>
+    size_t set_key_serialized(T const& C4_RESTRICT k)
+    {
+        _apply_seed();
+        csubstr s = m_tree->to_arena(k);
+        m_tree->_set_key(m_id, s);
+        return s.len;
+    }
+    size_t set_key_serialized(std::nullptr_t)
+    {
+        _apply_seed();
+        m_tree->_set_key(m_id, csubstr{});
+        return 0;
+    }
+
+    template<class T>
+    size_t set_val_serialized(T const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        csubstr s = m_tree->to_arena(v);
+        m_tree->_set_val(m_id, s);
+        return s.len;
+    }
+    size_t set_val_serialized(std::nullptr_t)
+    {
+        _apply_seed();
+        m_tree->_set_val(m_id, csubstr{});
+        return 0;
+    }
+
+    /** encode a blob as base64 into the tree's arena, 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 into the tree's arena, 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);
+
+    /** serialize a variable, then assign the result to the node's val */
+    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_CB_ASSERT(m_tree->m_callbacks, val() == s);
+        return *this;
+    }
+
+    template<class T>
+    NodeRef& operator<< (T const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        write(this, v);
+        return *this;
+    }
+
+    /** serialize a variable, then assign the result to the node's key */
+    template<class T>
+    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>
+    NodeRef& operator<< (Key<T> const& C4_RESTRICT v)
+    {
+        _apply_seed();
+        set_key_serialized(v.k);
+        return *this;
+    }
+
+    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;
+    }
+
+    /** @} */
+
+private:
+
+    void _apply_seed()
+    {
+        _C4RID();
+        if(m_seed.str) // we have a seed key: use it to create the new child
+        {
+            m_id = m_tree->append_child(m_id);
+            m_tree->_set_key(m_id, m_seed);
+            m_seed.str = nullptr;
+            m_seed.len = (size_t)NONE;
+        }
+        else if(m_seed.len != (size_t)NONE) // we have a seed index: create a child at that position
+        {
+            _RYML_CB_ASSERT(m_tree->m_callbacks, (size_t)m_tree->num_children(m_id) == m_seed.len);
+            m_id = m_tree->append_child(m_id);
+            m_seed.str = nullptr;
+            m_seed.len = (size_t)NONE;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_tree->m_callbacks, readable());
+        }
+    }
+
+    void _apply(csubstr v)
+    {
+        m_tree->_set_val(m_id, v);
+    }
+
+    void _apply(NodeScalar const& v)
+    {
+        m_tree->_set_val(m_id, v);
+    }
+
+    void _apply(NodeInit const& i)
+    {
+        m_tree->_set(m_id, i);
+    }
+
+public:
+
+    /** @name modification of hierarchy */
+    /** @{ */
+
+    NodeRef insert_child(NodeRef after)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id));
+        return r;
+    }
+
+    NodeRef insert_child(NodeInit const& i, NodeRef after)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_child(m_id, after.m_id));
+        r._apply(i);
+        return r;
+    }
+
+    NodeRef prepend_child()
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->insert_child(m_id, NONE));
+        return r;
+    }
+
+    NodeRef prepend_child(NodeInit const& i)
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->insert_child(m_id, NONE));
+        r._apply(i);
+        return r;
+    }
+
+    NodeRef append_child()
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->append_child(m_id));
+        return r;
+    }
+
+    NodeRef append_child(NodeInit const& i)
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->append_child(m_id));
+        r._apply(i);
+        return r;
+    }
+
+    NodeRef insert_sibling(ConstNodeRef const& after)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id));
+        return r;
+    }
+
+    NodeRef insert_sibling(NodeInit const& i, ConstNodeRef const& after)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, after.m_tree == m_tree);
+        NodeRef r(m_tree, m_tree->insert_sibling(m_id, after.m_id));
+        r._apply(i);
+        return r;
+    }
+
+    NodeRef prepend_sibling()
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->prepend_sibling(m_id));
+        return r;
+    }
+
+    NodeRef prepend_sibling(NodeInit const& i)
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->prepend_sibling(m_id));
+        r._apply(i);
+        return r;
+    }
+
+    NodeRef append_sibling()
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->append_sibling(m_id));
+        return r;
+    }
+
+    NodeRef append_sibling(NodeInit const& i)
+    {
+        _C4RR();
+        NodeRef r(m_tree, m_tree->append_sibling(m_id));
+        r._apply(i);
+        return r;
+    }
+
+public:
+
+    void remove_child(NodeRef & child)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, has_child(child));
+        _RYML_CB_ASSERT(m_tree->m_callbacks, child.parent().id() == id());
+        m_tree->remove(child.id());
+        child.clear();
+    }
+
+    //! remove the nth child of this node
+    void remove_child(id_type pos)
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, pos >= 0 && pos < num_children());
+        id_type child = m_tree->child(m_id, pos);
+        _RYML_CB_ASSERT(m_tree->m_callbacks, child != NONE);
+        m_tree->remove(child);
+    }
+
+    //! remove a child by name
+    void remove_child(csubstr key)
+    {
+        _C4RR();
+        id_type child = m_tree->find_child(m_id, key);
+        _RYML_CB_ASSERT(m_tree->m_callbacks, child != NONE);
+        m_tree->remove(child);
+    }
+
+public:
+
+    /** change the node's position within its parent, placing it after
+     * @p after. To move to the first position in the parent, simply
+     * pass an empty or default-constructed reference like this:
+     * `n.move({})`. */
+    void move(ConstNodeRef const& after)
+    {
+        _C4RR();
+        m_tree->move(m_id, after.m_id);
+    }
+
+    /** move the node to a different @p parent (which may belong to a
+     * different tree), placing it after @p after. When the
+     * destination parent is in a new tree, then this node's tree
+     * pointer is reset to the tree of the parent node. */
+    void move(NodeRef const& parent, ConstNodeRef const& after)
+    {
+        _C4RR();
+        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;
+        }
+    }
+
+    /** duplicate the current node somewhere within its parent, and
+     * place it after the node @p after. To place into the first
+     * position of the parent, simply pass an empty or
+     * default-constructed reference like this: `n.move({})`. */
+    NodeRef duplicate(ConstNodeRef const& after) const
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree == after.m_tree || after.m_id == NONE);
+        id_type dup = m_tree->duplicate(m_id, m_tree->parent(m_id), after.m_id);
+        NodeRef r(m_tree, dup);
+        return r;
+    }
+
+    /** duplicate the current node somewhere into a different @p parent
+     * (possibly from a different tree), and place it after the node
+     * @p after. To place into the first position of the parent,
+     * simply pass an empty or default-constructed reference like
+     * this: `n.move({})`. */
+    NodeRef duplicate(NodeRef const& parent, ConstNodeRef const& after) const
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, parent.m_tree == after.m_tree || after.m_id == NONE);
+        if(parent.m_tree == m_tree)
+        {
+            id_type dup = m_tree->duplicate(m_id, parent.m_id, after.m_id);
+            NodeRef r(m_tree, dup);
+            return r;
+        }
+        else
+        {
+            id_type dup = parent.m_tree->duplicate(m_tree, m_id, parent.m_id, after.m_id);
+            NodeRef r(parent.m_tree, dup);
+            return r;
+        }
+    }
+
+    void duplicate_children(NodeRef const& parent, ConstNodeRef const& after) const
+    {
+        _C4RR();
+        _RYML_CB_ASSERT(m_tree->m_callbacks, 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);
+        }
+    }
+
+    /** @} */
+
+#undef _C4RR
+#undef _C4RID
+};
+
+// NOLINTEND(cppcoreguidelines-c-copy-assignment-signature,misc-unconventional-assign-operator)
+
+
+//-----------------------------------------------------------------------------
+
+inline ConstNodeRef::ConstNodeRef(NodeRef const& that) noexcept
+    : m_tree(that.m_tree)
+    , m_id(!that.is_seed() ? that.id() : (id_type)NONE)
+{
+}
+
+inline ConstNodeRef::ConstNodeRef(NodeRef && that) noexcept // NOLINT
+    : m_tree(that.m_tree)
+    , m_id(!that.is_seed() ? that.id() : (id_type)NONE)
+{
+}
+
+
+inline ConstNodeRef& ConstNodeRef::operator= (NodeRef const& that) noexcept
+{
+    m_tree = (that.m_tree);
+    m_id = (!that.is_seed() ? that.id() : (id_type)NONE);
+    return *this;
+}
+
+inline ConstNodeRef& ConstNodeRef::operator= (NodeRef && that) noexcept // NOLINT
+{
+    m_tree = (that.m_tree);
+    m_id = (!that.is_seed() ? that.id() : (id_type)NONE);
+    return *this;
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** @addtogroup doc_serialization_helpers
+ *
+ * @{
+ */
+
+template<class T>
+C4_ALWAYS_INLINE void write(NodeRef *n, T const& v)
+{
+    n->set_val_serialized(v);
+}
+
+template<class T>
+C4_ALWAYS_INLINE bool read(ConstNodeRef const& C4_RESTRICT n, T *v)
+{
+    return read(n.m_tree, n.m_id, v);
+}
+
+template<class T>
+C4_ALWAYS_INLINE bool read(NodeRef const& C4_RESTRICT n, T *v)
+{
+    return read(n.tree(), n.id(), v);
+}
+
+template<class T>
+C4_ALWAYS_INLINE bool readkey(ConstNodeRef const& C4_RESTRICT n, T *v)
+{
+    return readkey(n.m_tree, n.m_id, v);
+}
+
+template<class T>
+C4_ALWAYS_INLINE bool readkey(NodeRef const& C4_RESTRICT n, T *v)
+{
+    return readkey(n.tree(), n.id(), v);
+}
+
+/** @} */
+
+/** @} */
+
+
+} // 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_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 {
+
+/** @addtogroup doc_emit
+ * @{
+ */
+
+/** @defgroup doc_writers Writer objects to use with an Emitter
+ * @see Emitter
+ * @{
+ */
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** 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) {}
+
+    substr _get(bool /*error_on_excess*/) const
+    {
+        substr sp;
+        sp.str = nullptr;
+        sp.len = m_pos;
+        return sp;
+    }
+
+    template<size_t N>
+    void _do_write(const char (&a)[N])
+    {
+        (void)fwrite(a, sizeof(char), N - 1, m_file);
+        m_pos += N - 1;
+    }
+
+    void _do_write(csubstr sp)
+    {
+        C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wsign-conversion")
+        if(sp.empty())
+            return;
+        (void)fwrite(sp.str, sizeof(csubstr::char_type), sp.len, m_file);
+        m_pos += sp.len;
+        C4_SUPPRESS_WARNING_GCC_CLANG_POP
+    }
+
+    void _do_write(const char c)
+    {
+        (void)fputc(c, m_file);
+        ++m_pos;
+    }
+
+    void _do_write(const char c, size_t num_times)
+    {
+        for(size_t i = 0; i < num_times; ++i)
+            (void)fputc(c, m_file);
+        m_pos += 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) {}
+
+    substr _get(bool /*error_on_excess*/) const
+    {
+        substr sp;
+        sp.str = nullptr;
+        sp.len = m_pos;
+        return sp;
+    }
+
+    template<size_t N>
+    void _do_write(const char (&a)[N])
+    {
+        m_stream->write(a, N - 1);
+        m_pos += N - 1;
+    }
+
+    void _do_write(csubstr sp)
+    {
+        C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wsign-conversion")
+        if(sp.empty())
+            return;
+        m_stream->write(sp.str, sp.len);
+        m_pos += sp.len;
+        C4_SUPPRESS_WARNING_GCC_CLANG_POP
+    }
+
+    void _do_write(const char c)
+    {
+        m_stream->put(c);
+        ++m_pos;
+    }
+
+    void _do_write(const char c, size_t num_times)
+    {
+        for(size_t i = 0; i < num_times; ++i)
+            m_stream->put(c);
+        m_pos += 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) {}
+
+    substr _get(bool error_on_excess) const
+    {
+        if(m_pos <= m_buf.len)
+            return m_buf.first(m_pos);
+        else 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>
+    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;
+    }
+
+    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;
+    }
+
+    void _do_write(const char c)
+    {
+        if(m_pos + 1 <= m_buf.len)
+            m_buf[m_pos] = c;
+        ++m_pos;
+    }
+
+    void _do_write(const char c, size_t num_times)
+    {
+        if(m_pos + num_times <= m_buf.len)
+            for(size_t i = 0; i < num_times; ++i)
+                m_buf[m_pos + i] = c;
+        m_pos += 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
+
+#ifdef RYML_DBG
+//included above:
+//#include <cstdio>
+#endif
+
+
+//-----------------------------------------------------------------------------
+// some debugging scaffolds
+
+// NOLINTBEGIN(*)
+C4_SUPPRESS_WARNING_GCC_CLANG_PUSH
+C4_SUPPRESS_WARNING_MSVC_PUSH
+C4_SUPPRESS_WARNING_MSVC(4068/*unknown pragma*/)
+
+#pragma GCC system_header
+C4_SUPPRESS_WARNING_GCC("-Wunknown-pragmas")
+C4_SUPPRESS_WARNING_CLANG("-Wgnu-zero-variadic-macro-arguments")
+// NOLINTEND(*)
+
+
+#ifndef RYML_DBG
+#   define _c4err(fmt, ...)   \
+    this->_err("ERROR: " fmt, ## __VA_ARGS__)
+#   define _c4dbgt(fmt, ...)
+#   define _c4dbgpf(fmt, ...)
+#   define _c4dbgpf_(fmt, ...)
+#   define _c4dbgp(msg)
+#   define _c4dbgp_(msg)
+#   define _c4dbgq(msg)
+#   define _c4presc(...)
+#   define _c4prscalar(msg, scalar, keep_newlines)
+#else
+#   define _c4err(fmt, ...)   \
+    do { RYML_DEBUG_BREAK(); this->_err("ERROR:\n" "{}:{}: " fmt, __FILE__, __LINE__, ## __VA_ARGS__); } while(0)
+#   define _c4dbgt(fmt, ...)   do { if(_dbg_enabled()) {                \
+                               this->_dbg ("{}:{}: "   fmt     , __FILE__, __LINE__, ## __VA_ARGS__); } } while(0)
+#   define _c4dbgpf(fmt, ...)  _dbg_printf("{}:{}: "   fmt "\n", __FILE__, __LINE__, ## __VA_ARGS__)
+#   define _c4dbgpf_(fmt, ...) _dbg_printf("{}:{}: "   fmt     , __FILE__, __LINE__, ## __VA_ARGS__)
+#   define _c4dbgp(msg)        _dbg_printf("{}:{}: "   msg "\n", __FILE__, __LINE__                )
+#   define _c4dbgp_(msg)       _dbg_printf("{}:{}: "   msg     , __FILE__, __LINE__                )
+#   define _c4dbgq(msg)        _dbg_printf(msg "\n")
+#   define _c4presc(...)       do { if(_dbg_enabled()) __c4presc(__VA_ARGS__); } while(0)
+#   define _c4prscalar(msg, scalar, keep_newlines)                  \
+    do {                                                            \
+        _c4dbgpf_("{}: [{}]~~~", msg, scalar.len);                  \
+        if(_dbg_enabled()) {                                        \
+            __c4presc((scalar).str, (scalar).len, (keep_newlines)); \
+        }                                                           \
+        _c4dbgq("~~~");                                             \
+    } while(0)
+#endif // RYML_DBG
+
+
+//-----------------------------------------------------------------------------
+
+#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 bool& _dbg_enabled() { static bool enabled = true; return enabled; }
+inline void _dbg_set_enabled(bool yes) { _dbg_enabled() = yes; }
+inline void _dbg_dumper(csubstr s)
+{
+    if(s.str)
+        fwrite(s.str, 1, s.len, stdout);
+}
+inline substr _dbg_buf() noexcept
+{
+    static char writebuf[2048];
+    return substr{writebuf, sizeof(writebuf)}; // g++-5 has trouble with return writebuf;
+}
+template<class ...Args>
+C4_NO_INLINE void _dbg_printf(c4::csubstr fmt, Args const& ...args)
+{
+    if(_dbg_enabled())
+    {
+        substr buf = _dbg_buf();
+        const size_t needed_size = c4::format_dump(&_dbg_dumper, buf, fmt, args...);
+        C4_CHECK(needed_size <= buf.len);
+    }
+}
+inline C4_NO_INLINE void __c4presc(const char *s, size_t len, bool keep_newlines=false)
+{
+    RYML_ASSERT(s || !len);
+    size_t prev = 0;
+    for(size_t i = 0; i < len; ++i)
+    {
+        switch(s[i])
+        {
+        case '\n'  : _dbg_printf("{}{}{}", csubstr(s+prev, i-prev), csubstr("\\n"), csubstr(keep_newlines ? "\n":"")); prev = i+1; break;
+        case '\t'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\t")); prev = i+1; break;
+        case '\0'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\0")); prev = i+1; break;
+        case '\r'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\r")); prev = i+1; break;
+        case '\f'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\f")); prev = i+1; break;
+        case '\b'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\b")); prev = i+1; break;
+        case '\v'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\v")); prev = i+1; break;
+        case '\a'  : _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\a")); prev = i+1; break;
+        case '\x1b': _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\x1b")); prev = i+1; break;
+        case -0x3e/*0xc2u*/:
+            if(i+1 < len)
+            {
+                if(s[i+1] == -0x60/*0xa0u*/)
+                {
+                    _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\_")); prev = i+1;
+                }
+                else if(s[i+1] == -0x7b/*0x85u*/)
+                {
+                    _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\N")); prev = i+1;
+                }
+            }
+            break;
+        case -0x1e/*0xe2u*/:
+            if(i+2 < len && s[i+1] == -0x80/*0x80u*/)
+            {
+                if(s[i+2] == -0x58/*0xa8u*/)
+                {
+                    _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\L")); prev = i+1;
+                }
+                else if(s[i+2] == -0x57/*0xa9u*/)
+                {
+                    _dbg_printf("{}{}", csubstr(s+prev, i-prev), csubstr("\\P")); prev = i+1;
+                }
+            }
+            break;
+        }
+    }
+    if(len > prev)
+        _dbg_printf("{}", csubstr(s+prev, len-prev));
+}
+inline void __c4presc(csubstr s, bool keep_newlines=false)
+{
+    __c4presc(s.str, s.len, keep_newlines);
+}
+} // namespace c4
+
+#endif // RYML_DBG
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+C4_SUPPRESS_WARNING_MSVC_POP
+
+#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_
+
+/** @file emit.hpp Utilities to emit YAML and JSON. */
+
+#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
+
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_emit
+ *
+ * @{
+ */
+
+// fwd declarations
+template<class Writer> class Emitter;
+template<class OStream>
+using EmitterOStream = Emitter<WriterOStream<OStream>>;
+using EmitterFile = Emitter<WriterFile>;
+using EmitterBuf  = Emitter<WriterBuf>;
+
+namespace detail {
+inline bool is_set_(ConstNodeRef n) { return n.tree() && (n.id() != NONE); }
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** Specifies the type of content to emit */
+typedef enum {
+    EMIT_YAML = 0, ///< emit YAML
+    EMIT_JSON = 1  ///< emit JSON
+} EmitType_e;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** A lightweight object containing options to be used when emitting. */
+struct EmitOptions
+{
+    typedef enum : uint32_t {
+        DEFAULT_FLAGS = 0u,
+        JSON_ERR_ON_TAG = 1u << 0u,
+        JSON_ERR_ON_ANCHOR = 1u << 1u,
+        _JSON_ERR_MASK = JSON_ERR_ON_TAG|JSON_ERR_ON_ANCHOR,
+    } EmitOptionFlags_e;
+
+public:
+
+    /** @name option flags
+     *
+     * @{ */
+    C4_ALWAYS_INLINE EmitOptionFlags_e json_error_flags() const noexcept { return m_option_flags; }
+    EmitOptions& json_error_flags(EmitOptionFlags_e d) noexcept { m_option_flags = (EmitOptionFlags_e)(d & _JSON_ERR_MASK); return *this; }
+    /** @} */
+
+public:
+
+    /** @name max depth for the emitted tree
+     *
+     * This makes the emitter fail when emitting trees exceeding the
+     * max_depth.
+     *
+     * @{ */
+    C4_ALWAYS_INLINE id_type max_depth() const noexcept { return m_max_depth; }
+    EmitOptions& max_depth(id_type d) noexcept { m_max_depth = d; return *this; }
+    static constexpr const id_type max_depth_default = 64;
+    /** @} */
+
+public:
+
+    bool operator== (const EmitOptions& that) const noexcept
+    {
+        return m_max_depth == that.m_max_depth &&
+            m_option_flags == that.m_option_flags;
+    }
+
+private:
+
+    /** @cond dev */
+    id_type m_max_depth{max_depth_default};
+    EmitOptionFlags_e m_option_flags{DEFAULT_FLAGS};
+    /** @endcond */
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** A stateful emitter, for use with a writer such as @ref WriterBuf,
+ * @ref WriterFile, or @ref WriterOStream */
+template<class Writer>
+class Emitter : public Writer
+{
+public:
+
+    /** Construct the emitter and its internal Writer state, using default emit options.
+     * @param args arguments to be forwarded to the constructor of the writer.
+     * */
+    template<class ...Args>
+    Emitter(Args &&...args) : Writer(std::forward<Args>(args)...), m_tree(), m_opts(), m_flow(false) {}
+
+    /** Construct the emitter and its internal Writer state.
+     *
+     * @param opts EmitOptions
+     * @param args arguments to be forwarded to the constructor of the writer.
+     * */
+    template<class ...Args>
+    Emitter(EmitOptions const& opts, Args &&...args) : Writer(std::forward<Args>(args)...), m_tree(), m_opts(opts), m_flow(false) {}
+
+    /** emit!
+     *
+     * When writing to a buffer, returns a substr of the emitted YAML.
+     * If the given buffer has insufficient space, the returned substr
+     * will be null and its size will be the needed space. Whatever
+     * the size of the buffer, it is guaranteed that no writes are
+     * done past its end.
+     *
+     * When writing to a file, the returned substr will be null, but its
+     * length will be set to the number of bytes written.
+     *
+     * @param type specify what to emit
+     * @param t the tree to emit
+     * @param id the id of the node to emit
+     * @param error_on_excess when true, an error is raised when the
+     *        output buffer is too small for the emitted YAML/JSON
+     * */
+    substr emit_as(EmitType_e type, Tree const& t, id_type id, bool error_on_excess);
+    /** emit starting at the root node */
+    substr emit_as(EmitType_e type, Tree const& t, bool error_on_excess=true)
+    {
+        if(t.empty())
+            return {};
+        return this->emit_as(type, t, t.root_id(), error_on_excess);
+    }
+    /** emit starting at the given node */
+    substr emit_as(EmitType_e type, ConstNodeRef const& n, bool error_on_excess=true)
+    {
+        if(!detail::is_set_(n))
+            return {};
+        _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+        return this->emit_as(type, *n.tree(), n.id(), error_on_excess);
+    }
+
+public:
+
+    /** get the emit options for this object */
+    EmitOptions const& options() const noexcept { return m_opts; }
+
+    /** set the max depth for emitted trees (to prevent a stack overflow) */
+    void max_depth(id_type max_depth) noexcept { m_opts.max_depth(max_depth); }
+    /** get the max depth for emitted trees (to prevent a stack overflow) */
+    id_type max_depth() const noexcept { return m_opts.max_depth(); }
+
+private:
+
+    Tree const* C4_RESTRICT m_tree;
+    EmitOptions m_opts;
+    bool m_flow;
+
+private:
+
+    void _emit_yaml(id_type id);
+    void _do_visit_flow_sl(id_type id, id_type depth, id_type ilevel=0);
+    void _do_visit_flow_ml(id_type id, id_type depth, id_type ilevel=0, id_type do_indent=1);
+    void _do_visit_block(id_type id, id_type depth, id_type ilevel=0, id_type do_indent=1);
+    void _do_visit_block_container(id_type id, id_type depth, id_type next_level, bool do_indent);
+    void _do_visit_json(id_type id, id_type depth);
+
+private:
+
+    void _write(NodeScalar const& C4_RESTRICT sc, NodeType flags, id_type level);
+    void _write_json(NodeScalar const& C4_RESTRICT sc, NodeType flags);
+
+    void _write_doc(id_type id);
+    void _write_scalar_json_dquo(csubstr s);
+    void _write_scalar_literal(csubstr s, id_type level, bool as_key);
+    void _write_scalar_folded(csubstr s, id_type level, bool as_key);
+    void _write_scalar_squo(csubstr s, id_type level);
+    void _write_scalar_dquo(csubstr s, id_type level);
+    void _write_scalar_plain(csubstr s, id_type level);
+
+    size_t _write_escaped_newlines(csubstr s, size_t i);
+    size_t _write_indented_block(csubstr s, size_t i, id_type 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|KEY_STYLE) | ~(VAL|VALREF|VALANCH|VALQUO|VAL_STYLE) | CONTAINER_STYLE,
+        _valsc = ~(KEY|KEYREF|KEYANCH|KEYQUO|KEY_STYLE) |  (VAL|VALREF|VALANCH|VALQUO|VAL_STYLE) | CONTAINER_STYLE,
+        _keysc_json =  (KEY)  | ~(VAL),
+        _valsc_json = ~(KEY)  |  (VAL),
+    };
+
+    C4_ALWAYS_INLINE void _writek(id_type id, id_type level) { _write(m_tree->keysc(id), (m_tree->_p(id)->m_type.type & ~_valsc), level); }
+    C4_ALWAYS_INLINE void _writev(id_type id, id_type level) { _write(m_tree->valsc(id), (m_tree->_p(id)->m_type.type & ~_keysc), level); }
+
+    C4_ALWAYS_INLINE void _writek_json(id_type id) { _write_json(m_tree->keysc(id), m_tree->_p(id)->m_type.type & ~(VAL)); }
+    C4_ALWAYS_INLINE void _writev_json(id_type id) { _write_json(m_tree->valsc(id), m_tree->_p(id)->m_type.type & ~(KEY)); }
+
+    void _indent(id_type level, bool enabled)
+    {
+        if(enabled)
+            this->Writer::_do_write(' ', 2u * (size_t)level);
+    }
+    void _indent(id_type level)
+    {
+        if(!m_flow)
+            this->Writer::_do_write(' ', 2u * (size_t)level);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_emit_to_file Emit to file
+ *
+ * @{
+ */
+
+
+// emit from tree and node id -----------------------
+
+/** (1) emit YAML to the given file, starting at the given node. A null
+ * file defaults to stdout. Return the number of bytes written. */
+inline size_t emit_yaml(Tree const& t, id_type id, EmitOptions const& opts, FILE *f)
+{
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_YAML, t, id, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_yaml(Tree const& t, id_type id, FILE *f)
+{
+    EmitterFile em(f);
+    return em.emit_as(EMIT_YAML, t, id, /*error_on_excess*/true).len;
+}
+/** (1) emit JSON to the given file, starting at the given node. A null
+ * file defaults to stdout.  Return the number of bytes written. */
+inline size_t emit_json(Tree const& t, id_type id, EmitOptions const& opts, FILE *f)
+{
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_JSON, t, id, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_json(Tree const& t, id_type id, FILE *f)
+{
+    EmitterFile em(f);
+    return em.emit_as(EMIT_JSON, t, id, /*error_on_excess*/true).len;
+}
+
+
+// emit from root -------------------------
+
+/** (1) emit YAML to the given file, starting at the root node. A null file defaults to stdout.
+ * Return the number of bytes written. */
+inline size_t emit_yaml(Tree const& t, EmitOptions const& opts, FILE *f=nullptr)
+{
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_YAML, t, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_yaml(Tree const& t, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit_as(EMIT_YAML, t, /*error_on_excess*/true).len;
+}
+/** (1) 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, EmitOptions const& opts, FILE *f=nullptr)
+{
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_JSON, t, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_json(Tree const& t, FILE *f=nullptr)
+{
+    EmitterFile em(f);
+    return em.emit_as(EMIT_JSON, t, /*error_on_excess*/true).len;
+}
+
+
+// emit from ConstNodeRef ------------------------
+
+/** (1) emit YAML to the given file. A null file defaults to stdout.
+ * Return the number of bytes written. */
+inline size_t emit_yaml(ConstNodeRef const& r, EmitOptions const& opts, FILE *f=nullptr)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_YAML, r, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_yaml(ConstNodeRef const& r, FILE *f=nullptr)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterFile em(f);
+    return em.emit_as(EMIT_YAML, r, /*error_on_excess*/true).len;
+}
+/** (1) emit JSON to the given file. A null file defaults to stdout.
+ * Return the number of bytes written. */
+inline size_t emit_json(ConstNodeRef const& r, EmitOptions const& opts, FILE *f=nullptr)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterFile em(opts, f);
+    return em.emit_as(EMIT_JSON, r, /*error_on_excess*/true).len;
+}
+/** (2) like (1), but use default emit options */
+inline size_t emit_json(ConstNodeRef const& r, FILE *f=nullptr)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterFile em(f);
+    return em.emit_as(EMIT_JSON, r, /*error_on_excess*/true).len;
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_emit_to_ostream Emit to an STL-like ostream
+ *
+ * @{
+ */
+
+/** emit YAML to an STL-like ostream */
+template<class OStream>
+inline OStream& operator<< (OStream& s, Tree const& t)
+{
+    EmitterOStream<OStream> em(s);
+    em.emit_as(EMIT_YAML, t);
+    return s;
+}
+
+/** emit YAML to an STL-like ostream
+ * @overload */
+template<class OStream>
+inline OStream& operator<< (OStream& s, ConstNodeRef const& n)
+{
+    if(!detail::is_set_(n))
+        return s;
+    EmitterOStream<OStream> em(s);
+    em.emit_as(EMIT_YAML, n);
+    return s;
+}
+
+/** mark a tree or node to be emitted as yaml when using @ref
+ * operator<<, with options. For example:
+ *
+ * ```cpp
+ * Tree t = parse_in_arena("{foo: bar}");
+ * std::cout << t; // emits YAML
+ * std::cout << as_yaml(t); // emits YAML, same as above
+ * std::cout << as_yaml(t, EmitOptions().max_depth(10)); // emits JSON with a max tree depth
+ * ```
+ *
+ * @see @ref operator<< */
+struct as_json
+{
+    Tree const* tree;
+    size_t node;
+    EmitOptions options;
+    as_json(Tree const& t, EmitOptions const& opts={}) : tree(&t), node(t.empty() ? NONE : t.root_id()), options(opts)  {}
+    as_json(Tree const& t, size_t id, EmitOptions const& opts={}) : tree(&t), node(id), options(opts)  {}
+    as_json(ConstNodeRef const& n, EmitOptions const& opts={}) : tree(n.tree()), node(n.id()), options(opts) {}
+};
+
+/** mark a tree or node to be emitted as yaml when using @ref
+ * operator<< . For example:
+ *
+ * ```cpp
+ * Tree t = parse_in_arena("{foo: bar}");
+ * std::cout << t; // emits YAML
+ * std::cout << as_json(t); // emits JSON
+ * std::cout << as_json(t, EmitOptions().max_depth(10)); // emits JSON with a max tree depth
+ * ```
+ *
+ * @see @ref operator<< */
+struct as_yaml
+{
+    Tree const* tree;
+    size_t node;
+    EmitOptions options;
+    as_yaml(Tree const& t, EmitOptions const& opts={}) : tree(&t), node(t.empty() ? NONE : t.root_id()), options(opts)  {}
+    as_yaml(Tree const& t, size_t id, EmitOptions const& opts={}) : tree(&t), node(id), options(opts)  {}
+    as_yaml(ConstNodeRef const& n, EmitOptions const& opts={}) : tree(n.tree()), node(n.id()), options(opts) {}
+};
+
+/** emit json to an STL-like stream */
+template<class OStream>
+inline OStream& operator<< (OStream& s, as_json const& j)
+{
+    if(!j.tree || j.node == NONE)
+        return s;
+    EmitterOStream<OStream> em(j.options, s);
+    em.emit_as(EMIT_JSON, *j.tree, j.node, true);
+    return s;
+}
+
+/** emit yaml to an STL-like stream */
+template<class OStream>
+inline OStream& operator<< (OStream& s, as_yaml const& y)
+{
+    if(!y.tree || y.node == NONE)
+        return s;
+    EmitterOStream<OStream> em(y.options, s);
+    em.emit_as(EMIT_YAML, *y.tree, y.node, true);
+    return s;
+}
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_emit_to_buffer Emit to memory buffer
+ *
+ * @{
+ */
+
+// emit from tree and node id -----------------------
+
+/** (1) emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param t the tree to emit.
+ * @param id the node where to start emitting.
+ * @param opts emit options.
+ * @param buf the output buffer.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_yaml(Tree const& t, id_type id, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_YAML, t, id, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_yaml(Tree const& t, id_type id, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_YAML, t, id, error_on_excess);
+}
+/** (1) emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param t the tree to emit.
+ * @param id the node where to start emitting.
+ * @param opts emit options.
+ * @param buf the output buffer.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_json(Tree const& t, id_type id, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_JSON, t, id, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_json(Tree const& t, id_type id, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_JSON, t, id, error_on_excess);
+}
+
+
+// emit from root -------------------------
+
+/** (1) emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param t the tree; will be emitted from the root node.
+ * @param opts emit options.
+ * @param buf the output buffer.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_yaml(Tree const& t, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_YAML, t, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_yaml(Tree const& t, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_YAML, t, error_on_excess);
+}
+/** (1) emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param t the tree; will be emitted from the root node.
+ * @param opts emit options.
+ * @param buf the output buffer.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_json(Tree const& t, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_JSON, t, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_json(Tree const& t, substr buf, bool error_on_excess=true)
+{
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_JSON, t, error_on_excess);
+}
+
+
+// emit from ConstNodeRef ------------------------
+
+/** (1) emit YAML to the given buffer. Return a substr trimmed to the emitted YAML.
+ * @param r the starting node.
+ * @param buf the output buffer.
+ * @param opts emit options.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_yaml(ConstNodeRef const& r, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_YAML, r, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_yaml(ConstNodeRef const& r, substr buf, bool error_on_excess=true)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_YAML, r, error_on_excess);
+}
+/** (1) emit JSON to the given buffer. Return a substr trimmed to the emitted JSON.
+ * @param r the starting node.
+ * @param buf the output buffer.
+ * @param opts emit options.
+ * @param error_on_excess Raise an error if the space in the buffer is insufficient.
+ * @return a substr trimmed to the result in the output buffer. If the buffer is
+ * insufficient (when error_on_excess is false), the string pointer of the
+ * result will be set to null, and the length will report the required buffer size. */
+inline substr emit_json(ConstNodeRef const& r, EmitOptions const& opts, substr buf, bool error_on_excess=true)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterBuf em(opts, buf);
+    return em.emit_as(EMIT_JSON, r, error_on_excess);
+}
+/** (2) like (1), but use default emit options */
+inline substr emit_json(ConstNodeRef const& r, substr buf, bool error_on_excess=true)
+{
+    if(!detail::is_set_(r))
+        return {};
+    EmitterBuf em(buf);
+    return em.emit_as(EMIT_JSON, r, error_on_excess);
+}
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_emit_to_container Emit to resizeable container
+ *
+ * @{
+ */
+
+// emit from tree and node id ---------------------------
+
+/** (1) emit+resize: emit YAML to the given `std::string`/`std::vector`-like
+ * container, resizing it as needed to fit the emitted YAML. If @p append is
+ * set to true, the emitted YAML is appended at the end of the container.
+ *
+ * @return a substr trimmed to the emitted YAML (excluding the initial contents, when appending) */
+template<class CharOwningContainer>
+substr emitrs_yaml(Tree const& t, id_type id, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    size_t startpos = append ? cont->size() : 0u;
+    cont->resize(cont->capacity()); // otherwise the first emit would be certain to fail
+    substr buf = to_substr(*cont).sub(startpos);
+    substr ret = emit_yaml(t, id, opts, buf, /*error_on_excess*/false);
+    if(ret.str == nullptr && ret.len > 0)
+    {
+        cont->resize(startpos + ret.len);
+        buf = to_substr(*cont).sub(startpos);
+        ret = emit_yaml(t, id, opts, buf, /*error_on_excess*/true);
+    }
+    else
+    {
+        cont->resize(startpos + ret.len);
+    }
+    return ret;
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_yaml(Tree const& t, id_type id, CharOwningContainer * cont, bool append=false)
+{
+    return emitrs_yaml(t, id, EmitOptions{}, cont, append);
+}
+/** (1) emit+resize: emit JSON to the given `std::string`/`std::vector`-like
+ * container, resizing it as needed to fit the emitted JSON. If @p append is
+ * set to true, the emitted YAML is appended at the end of the container.
+ *
+ * @return a substr trimmed to the emitted JSON (excluding the initial contents, when appending) */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, id_type id, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    const size_t startpos = append ? cont->size() : 0u;
+    cont->resize(cont->capacity()); // otherwise the first emit would be certain to fail
+    substr buf = to_substr(*cont).sub(startpos);
+    EmitterBuf em(opts, buf);
+    substr ret = emit_json(t, id, opts, buf, /*error_on_excess*/false);
+    if(ret.str == nullptr && ret.len > 0)
+    {
+        cont->resize(startpos + ret.len);
+        buf = to_substr(*cont).sub(startpos);
+        ret = emit_json(t, id, opts, buf, /*error_on_excess*/true);
+    }
+    else
+    {
+        cont->resize(startpos + ret.len);
+    }
+    return ret;
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, id_type id, CharOwningContainer * cont, bool append=false)
+{
+    return emitrs_json(t, id, EmitOptions{}, cont, append);
+}
+
+
+/** (3) emit+resize: YAML to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_yaml(Tree const& t, id_type id, EmitOptions const& opts={})
+{
+    CharOwningContainer c;
+    emitrs_yaml(t, id, opts, &c);
+    return c;
+}
+/** (3) emit+resize: JSON to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(Tree const& t, id_type id, EmitOptions const& opts={})
+{
+    CharOwningContainer c;
+    emitrs_json(t, id, opts, &c);
+    return c;
+}
+
+
+// emit from root -------------------------
+
+/** (1) emit+resize: YAML to the given `std::string`/`std::vector`-like
+ * container, resizing it as needed to fit the emitted YAML.
+ * @return a substr trimmed to the new emitted contents. */
+template<class CharOwningContainer>
+substr emitrs_yaml(Tree const& t, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    if(t.empty())
+        return {};
+    return emitrs_yaml(t, t.root_id(), opts, cont, append);
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_yaml(Tree const& t, CharOwningContainer * cont, bool append=false)
+{
+    if(t.empty())
+        return {};
+    return emitrs_yaml(t, t.root_id(), EmitOptions{}, cont, append);
+}
+/** (1) emit+resize: JSON to the given `std::string`/`std::vector`-like
+ * container, resizing it as needed to fit the emitted JSON.
+ * @return a substr trimmed to the new emitted contents. */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    if(t.empty())
+        return {};
+    return emitrs_json(t, t.root_id(), opts, cont, append);
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_json(Tree const& t, CharOwningContainer * cont, bool append=false)
+{
+    if(t.empty())
+        return {};
+    return emitrs_json(t, t.root_id(), EmitOptions{}, cont, append);
+}
+
+
+/** (3) emit+resize: YAML to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_yaml(Tree const& t, EmitOptions const& opts={})
+{
+    CharOwningContainer c;
+    if(t.empty())
+        return c;
+    emitrs_yaml(t, t.root_id(), opts, &c);
+    return c;
+}
+/** (3) emit+resize: JSON to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(Tree const& t, EmitOptions const& opts={})
+{
+    CharOwningContainer c;
+    if(t.empty())
+        return c;
+    emitrs_json(t, t.root_id(), opts, &c);
+    return c;
+}
+
+
+// emit from ConstNodeRef ------------------------
+
+
+/** (1) emit+resize: YAML to the given `std::string`/`std::vector`-like container,
+ * resizing it as needed to fit the emitted YAML.
+ * @return a substr trimmed to the new emitted contents */
+template<class CharOwningContainer>
+substr emitrs_yaml(ConstNodeRef const& n, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    return emitrs_yaml(*n.tree(), n.id(), opts, cont, append);
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_yaml(ConstNodeRef const& n, CharOwningContainer * cont, bool append=false)
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    return emitrs_yaml(*n.tree(), n.id(), EmitOptions{}, cont, append);
+}
+/** (1) emit+resize: JSON to the given `std::string`/`std::vector`-like container,
+ * resizing it as needed to fit the emitted JSON.
+ * @return a substr trimmed to the new emitted contents */
+template<class CharOwningContainer>
+substr emitrs_json(ConstNodeRef const& n, EmitOptions const& opts, CharOwningContainer * cont, bool append=false)
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    return emitrs_json(*n.tree(), n.id(), opts, cont, append);
+}
+/** (2) like (1), but use default emit options */
+template<class CharOwningContainer>
+substr emitrs_json(ConstNodeRef const& n, CharOwningContainer * cont, bool append=false)
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    return emitrs_json(*n.tree(), n.id(), EmitOptions{}, cont, append);
+}
+
+
+/** (3) emit+resize: YAML to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_yaml(ConstNodeRef const& n, EmitOptions const& opts={})
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    CharOwningContainer c;
+    emitrs_yaml(*n.tree(), n.id(), opts, &c);
+    return c;
+}
+/** (3) emit+resize: JSON to a newly-created `std::string`/`std::vector`-like container. */
+template<class CharOwningContainer>
+CharOwningContainer emitrs_json(ConstNodeRef const& n, EmitOptions const& opts={})
+{
+    if(!detail::is_set_(n))
+        return {};
+    _RYML_CB_CHECK(n.tree()->callbacks(), n.readable());
+    CharOwningContainer c;
+    emitrs_json(*n.tree(), n.id(), opts, &c);
+    return c;
+}
+
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @cond dev */
+
+#define RYML_DEPRECATE_EMIT                                             \
+    RYML_DEPRECATED("use emit_yaml() instead. "                         \
+                    "See https://github.com/biojppm/rapidyaml/issues/120")
+#define RYML_DEPRECATE_EMITRS                                           \
+    RYML_DEPRECATED("use emitrs_yaml() instead. "                       \
+                    "See https://github.com/biojppm/rapidyaml/issues/120")
+
+// workaround for Qt emit which is a macro;
+// see https://github.com/biojppm/rapidyaml/issues/120.
+// emit is defined in qobjectdefs.h (as an empty define).
+#ifdef emit
+#define RYML_TMP_EMIT_
+#undef emit
+#endif
+
+RYML_DEPRECATE_EMIT inline size_t emit(Tree const& t, id_type id, FILE *f)
+{
+    return emit_yaml(t, id, f);
+}
+RYML_DEPRECATE_EMIT inline size_t emit(Tree const& t, FILE *f=nullptr)
+{
+    return emit_yaml(t, f);
+}
+RYML_DEPRECATE_EMIT inline size_t emit(ConstNodeRef const& r, FILE *f=nullptr)
+{
+    return emit_yaml(r, f);
+}
+
+RYML_DEPRECATE_EMIT inline substr emit(Tree const& t, id_type id, substr buf, bool error_on_excess=true)
+{
+    return emit_yaml(t, id, buf, error_on_excess);
+}
+RYML_DEPRECATE_EMIT inline substr emit(Tree const& t, substr buf, bool error_on_excess=true)
+{
+    return emit_yaml(t, buf, error_on_excess);
+}
+RYML_DEPRECATE_EMIT inline substr emit(ConstNodeRef const& r, substr buf, bool error_on_excess=true)
+{
+    return emit_yaml(r, buf, error_on_excess);
+}
+
+#ifdef RYML_TMP_EMIT_
+#define emit
+#undef RYML_TMP_EMIT_
+#endif
+
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS substr emitrs(Tree const& t, id_type id, CharOwningContainer * cont)
+{
+    return emitrs_yaml(t, id, cont);
+}
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS CharOwningContainer emitrs(Tree const& t, id_type id)
+{
+    return emitrs_yaml<CharOwningContainer>(t, id);
+}
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS substr emitrs(Tree const& t, CharOwningContainer * cont)
+{
+    return emitrs_yaml(t, cont);
+}
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS CharOwningContainer emitrs(Tree const& t)
+{
+    return emitrs_yaml<CharOwningContainer>(t);
+}
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS substr emitrs(ConstNodeRef const& n, CharOwningContainer * cont)
+{
+    return emitrs_yaml(n, cont);
+}
+template<class CharOwningContainer>
+RYML_DEPRECATE_EMITRS CharOwningContainer emitrs(ConstNodeRef const& n)
+{
+    return emitrs_yaml<CharOwningContainer>(n);
+}
+
+/** @endcond */
+
+
+} // namespace yml
+} // namespace c4
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+#undef RYML_DEPRECATE_EMIT
+#undef RYML_DEPRECATE_EMITRS
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/emit.def.hpp
+//#include "c4/yml/emit.def.hpp" // NOLINT
+#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
+
+/** @file emit.def.hpp Definitions for emit functions. */
+#ifndef _C4_YML_DETAIL_PARSER_DBG_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_ */
+
+#endif
+
+namespace c4 {
+namespace yml {
+
+template<class Writer>
+substr Emitter<Writer>::emit_as(EmitType_e type, Tree const& t, id_type id, bool error_on_excess)
+{
+    if(t.empty())
+    {
+        _RYML_CB_ASSERT(t.callbacks(), id == NONE);
+        return {};
+    }
+    if(id == NONE)
+        id = t.root_id();
+    _RYML_CB_CHECK(t.callbacks(), id < t.capacity());
+    m_tree = &t;
+    m_flow = false;
+    if(type == EMIT_YAML)
+        _emit_yaml(id);
+    else if(type == EMIT_JSON)
+        _do_visit_json(id, 0);
+    else
+        _RYML_CB_ERR(m_tree->callbacks(), "unknown emit type");
+    m_tree = nullptr;
+    return this->Writer::_get(error_on_excess);
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class Writer>
+void Emitter<Writer>::_emit_yaml(id_type 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](id_type node){
+        NodeType ty = m_tree->type(node);
+        if(ty.is_flow_sl())
+            _do_visit_flow_sl(node, 0);
+        else if(ty.is_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).is_flow())
+        {
+            id_type 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, 0, ilevel, ilevel);
+            return;
+        }
+    }
+
+    TagDirectiveRange tagds = m_tree->tag_directives();
+    auto write_tag_directives = [&tagds, this](const id_type next_node){
+        TagDirective const* C4_RESTRICT end = tagds.b;
+        while(end < tagds.e)
+        {
+            if(end->next_node_id > next_node)
+                break;
+            ++end;
+        }
+        const id_type parent = m_tree->parent(next_node);
+        for( ; tagds.b != end; ++tagds.b)
+        {
+            if(next_node != m_tree->first_child(parent))
+                this->Writer::_do_write("...\n");
+            this->Writer::_do_write("%TAG ");
+            this->Writer::_do_write(tagds.b->handle);
+            this->Writer::_do_write(' ');
+            this->Writer::_do_write(tagds.b->prefix);
+            this->Writer::_do_write('\n');
+        }
+    };
+    if(m_tree->is_stream(id))
+    {
+        const id_type first_child = m_tree->first_child(id);
+        if(first_child != NONE)
+            write_tag_directives(first_child);
+        for(id_type child = first_child; child != NONE; child = m_tree->next_sibling(child))
+        {
+            dispatch(child);
+            if(m_tree->is_doc(child) && m_tree->type(child).is_flow_sl())
+                this->Writer::_do_write('\n');
+            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).is_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).is_flow())
+            this->Writer::_do_write('\n');
+    }
+    else if(m_tree->type(id) == NOTYPE)
+    {
+        ;
+    }
+    else
+    {
+        _RYML_CB_ERR(m_tree->callbacks(), "unknown type");
+    }
+}
+
+#define _rymlindent_nextline() this->_indent(ilevel + 1);
+
+template<class Writer>
+void Emitter<Writer>::_write_doc(id_type id)
+{
+    const NodeType ty = m_tree->type(id);
+    RYML_ASSERT(ty.is_doc());
+    RYML_ASSERT(!ty.has_key());
+    if(!m_tree->is_root(id))
+    {
+        RYML_ASSERT(m_tree->is_stream(m_tree->parent(id)));
+        this->Writer::_do_write("---");
+    }
+    //
+    if(!ty.has_val()) // this is more frequent
+    {
+        const bool tag = ty.has_val_tag();
+        const bool anchor = ty.has_val_anchor();
+        if(!tag && !anchor)
+        {
+            ;
+        }
+        else if(!tag && anchor)
+        {
+            if(!m_tree->is_root(id))
+                this->Writer::_do_write(' ');
+            this->Writer::_do_write('&');
+            this->Writer::_do_write(m_tree->val_anchor(id));
+            #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+            if(m_tree->has_children(id) && m_tree->is_root(id))
+                this->Writer::_do_write('\n');
+            #endif
+        }
+        else if(tag && !anchor)
+        {
+            if(!m_tree->is_root(id))
+                this->Writer::_do_write(' ');
+            _write_tag(m_tree->val_tag(id));
+            #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+            if(m_tree->has_children(id) && m_tree->is_root(id))
+                this->Writer::_do_write('\n');
+            #endif
+        }
+        else // tag && anchor
+        {
+            if(!m_tree->is_root(id))
+                this->Writer::_do_write(' ');
+            _write_tag(m_tree->val_tag(id));
+            this->Writer::_do_write(" &");
+            this->Writer::_do_write(m_tree->val_anchor(id));
+            #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+            if(m_tree->has_children(id) && m_tree->is_root(id))
+                this->Writer::_do_write('\n');
+            #endif
+        }
+    }
+    else // docval
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), ty.has_val());
+        // some plain scalars such as '...' and '---' must not
+        // appear at 0-indentation
+        const csubstr val = m_tree->val(id);
+        const bool preceded_by_3_dashes = !m_tree->is_root(id);
+        const type_bits style_marks = ty & VAL_STYLE;
+        const bool is_plain = ty.is_val_plain();
+        const bool is_ambiguous = (is_plain || !style_marks)
+            && ((val.begins_with("...") || val.begins_with("---"))
+                ||
+                (val.find('\n') != npos));
+        if(preceded_by_3_dashes)
+        {
+            if(is_plain && val.len == 0 && !ty.has_val_anchor() && !ty.has_val_tag())
+            {
+                this->Writer::_do_write('\n');
+                return;
+            }
+            else if(val.len && is_ambiguous)
+            {
+                this->Writer::_do_write('\n');
+            }
+            else
+            {
+                this->Writer::_do_write(' ');
+            }
+        }
+        id_type ilevel = 0u;
+        if(is_ambiguous)
+        {
+            _rymlindent_nextline();
+            ++ilevel;
+        }
+        _writev(id, ilevel);
+        if(val.len && m_tree->is_root(id))
+            this->Writer::_do_write('\n');
+    }
+    if(!m_tree->is_root(id))
+        this->Writer::_do_write('\n');
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_flow_sl(id_type node, id_type depth, id_type ilevel)
+{
+    const bool prev_flow = m_flow;
+    m_flow = true;
+    _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->is_stream(node));
+    _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_container(node) || m_tree->is_doc(node));
+    _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_root(node) || (m_tree->parent_is_map(node) || m_tree->parent_is_seq(node)));
+    if(C4_UNLIKELY(depth > m_opts.max_depth()))
+        _RYML_CB_ERR(m_tree->callbacks(), "max depth exceeded");
+
+    if(m_tree->is_doc(node))
+    {
+        _write_doc(node);
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        if(!m_tree->has_children(node))
+            return;
+        else
+        #endif
+        {
+            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('[');
+            }
+        }
+    }
+    else if(m_tree->is_container(node))
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), 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(id_type 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, depth + 1, ilevel + 1);
+        }
+    }
+
+    if(m_tree->is_map(node))
+    {
+        this->Writer::_do_write('}');
+    }
+    else if(m_tree->is_seq(node))
+    {
+        this->Writer::_do_write(']');
+    }
+    m_flow = prev_flow;
+}
+
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4702) // unreachable error, triggered by flow_ml not implemented
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_flow_ml(id_type id, id_type depth, id_type ilevel, id_type do_indent)
+{
+    C4_UNUSED(id);
+    C4_UNUSED(depth);
+    C4_UNUSED(ilevel);
+    C4_UNUSED(do_indent);
+    c4::yml::error("not implemented");
+    #ifdef THIS_IS_A_WORK_IN_PROGRESS
+    if(C4_UNLIKELY(depth > m_opts.max_depth()))
+        _RYML_CB_ERR(m_tree->callbacks(), "max depth exceeded");
+    const bool prev_flow = m_flow;
+    m_flow = true;
+    // do it...
+    m_flow = prev_flow;
+    #endif
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_block_container(id_type node, id_type depth, id_type level, bool do_indent)
+{
+    if(m_tree->is_seq(node))
+    {
+        for(id_type 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))
+            {
+                _indent(level, do_indent);
+                this->Writer::_do_write("- ");
+                _writev(child, 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.is_flow_sl())
+                {
+                    _indent(level, do_indent);
+                    this->Writer::_do_write("- ");
+                    _do_visit_flow_sl(child, depth+1, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else if(ty.is_flow_ml())
+                {
+                    _indent(level, do_indent);
+                    this->Writer::_do_write("- ");
+                    _do_visit_flow_ml(child, depth+1, 0u, do_indent);
+                    this->Writer::_do_write('\n');
+                }
+                else
+                {
+                    _do_visit_block(child, depth+1, level, do_indent); // same indentation level
+                }
+            }
+            do_indent = true;
+        }
+    }
+    else // map
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_map(node));
+        for(id_type 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))
+            {
+                _indent(level, do_indent);
+                _writek(ich, level);
+                this->Writer::_do_write(": ");
+                _writev(ich, 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.is_flow_sl())
+                {
+                    _indent(level, do_indent);
+                    _do_visit_flow_sl(ich, depth+1, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else if(ty.is_flow_ml())
+                {
+                    _indent(level, do_indent);
+                    _do_visit_flow_ml(ich, depth+1, 0u);
+                    this->Writer::_do_write('\n');
+                }
+                else
+                {
+                    _do_visit_block(ich, depth+1, level, do_indent); // same level!
+                }
+            } // keyval vs container
+            do_indent = true;
+        } // for children
+    } // seq vs map
+}
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_block(id_type node, id_type depth, id_type ilevel, id_type do_indent)
+{
+    _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->is_stream(node));
+    _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_container(node) || m_tree->is_doc(node));
+    _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_root(node) || (m_tree->parent_is_map(node) || m_tree->parent_is_seq(node)));
+    if(C4_UNLIKELY(depth > m_opts.max_depth()))
+        _RYML_CB_ERR(m_tree->callbacks(), "max depth exceeded");
+    if(m_tree->is_doc(node))
+    {
+        _write_doc(node);
+        if(!m_tree->has_children(node))
+            return;
+    }
+    else if(m_tree->is_container(node))
+    {
+        _RYML_CB_ASSERT(m_tree->callbacks(), 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))
+        {
+            _indent(ilevel, do_indent);
+            _writek(node, ilevel);
+            this->Writer::_do_write(':');
+            spc = true;
+        }
+        else if(!m_tree->is_root(node))
+        {
+            _indent(ilevel, do_indent);
+            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
+
+    id_type 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, depth, next_level, do_indent);
+}
+
+C4_SUPPRESS_WARNING_MSVC_POP
+
+
+template<class Writer>
+void Emitter<Writer>::_do_visit_json(id_type id, id_type depth)
+{
+    _RYML_CB_CHECK(m_tree->callbacks(), !m_tree->is_stream(id)); // JSON does not have streams
+    if(C4_UNLIKELY(depth > m_opts.max_depth()))
+        _RYML_CB_ERR(m_tree->callbacks(), "max depth exceeded");
+    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(id_type 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, depth+1);
+    }
+
+    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, id_type 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);
+        if(flags.is_key_ref())
+            this->Writer::_do_write(' ');
+        return;
+    }
+
+    // ensure the style flags only have one of KEY or VAL
+    _RYML_CB_ASSERT(m_tree->callbacks(), ((flags & SCALAR_STYLE) == 0) || (((flags & KEY_STYLE) == 0) != ((flags & VAL_STYLE) == 0)));
+    type_bits style_marks = flags & SCALAR_STYLE;
+    if(!style_marks)
+        style_marks = scalar_style_choose(sc.scalar);
+    if(style_marks & (KEY_LITERAL|VAL_LITERAL))
+    {
+        _write_scalar_literal(sc.scalar, ilevel, flags.has_key());
+    }
+    else if(style_marks & (KEY_FOLDED|VAL_FOLDED))
+    {
+        _write_scalar_folded(sc.scalar, ilevel, flags.has_key());
+    }
+    else if(style_marks & (KEY_SQUO|VAL_SQUO))
+    {
+        _write_scalar_squo(sc.scalar, ilevel);
+    }
+    else if(style_marks & (KEY_DQUO|VAL_DQUO))
+    {
+        _write_scalar_dquo(sc.scalar, ilevel);
+    }
+    else if(style_marks & (KEY_PLAIN|VAL_PLAIN))
+    {
+        if(C4_LIKELY(!(sc.scalar.begins_with(": ") || sc.scalar.begins_with(":\t"))))
+            _write_scalar_plain(sc.scalar, ilevel);
+        else
+            _write_scalar_squo(sc.scalar, ilevel);
+    }
+    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(flags & (KEYTAG|VALTAG))
+        if(m_opts.json_error_flags() & EmitOptions::JSON_ERR_ON_TAG)
+            _RYML_CB_ERR(m_tree->callbacks(), "JSON does not have tags");
+    if(C4_UNLIKELY(flags.has_anchor()))
+        if(m_opts.json_error_flags() & EmitOptions::JSON_ERR_ON_ANCHOR)
+            _RYML_CB_ERR(m_tree->callbacks(), "JSON does not have anchors");
+    if(sc.scalar.len)
+    {
+        // use double quoted style...
+        // if it is a key (mandatory in JSON)
+        // if the style is marked quoted
+        bool dquoted = ((flags & (KEY|VALQUO))
+                        || (scalar_style_json_choose(sc.scalar) & SCALAR_DQUO)); // choose the style
+        if(dquoted)
+            _write_scalar_json_dquo(sc.scalar);
+        else
+            this->Writer::_do_write(sc.scalar);
+    }
+    else
+    {
+        if(sc.scalar.str || (flags & (KEY|VALQUO|KEYTAG|VALTAG)))
+            this->Writer::_do_write("\"\"");
+        else
+            this->Writer::_do_write("null");
+    }
+}
+
+template<class Writer>
+size_t Emitter<Writer>::_write_escaped_newlines(csubstr s, size_t i)
+{
+    RYML_ASSERT(s.len > i);
+    RYML_ASSERT(s.str[i] == '\n');
+    //_c4dbgpf("nl@i={} rem=[{}]~~~{}~~~", i, s.sub(i).len, s.sub(i));
+    // add an extra newline for each sequence of consecutive
+    // newline/whitespace
+    this->Writer::_do_write('\n');
+    do
+    {
+        this->Writer::_do_write('\n'); // write the newline again
+        ++i; // increase the outer loop counter!
+    } while(i < s.len && s.str[i] == '\n');
+    _RYML_CB_ASSERT(m_tree->callbacks(), i > 0);
+    --i;
+    _RYML_CB_ASSERT(m_tree->callbacks(), s.str[i] == '\n');
+    return i;
+}
+
+inline bool _is_indented_block(csubstr s, size_t prev, size_t i) noexcept
+{
+    if(prev == 0 && s.begins_with_any(" \t"))
+        return true;
+    const size_t pos = s.first_not_of('\n', i);
+    return (pos != npos) && (s.str[pos] == ' ' || s.str[pos] == '\t');
+}
+
+template<class Writer>
+size_t Emitter<Writer>::_write_indented_block(csubstr s, size_t i, id_type ilevel)
+{
+    //_c4dbgpf("indblock@i={} rem=[{}]~~~\n{}~~~", i, s.sub(i).len, s.sub(i));
+    _RYML_CB_ASSERT(m_tree->callbacks(), i > 0);
+    _RYML_CB_ASSERT(m_tree->callbacks(), s.str[i-1] == '\n');
+    _RYML_CB_ASSERT(m_tree->callbacks(), i < s.len);
+    _RYML_CB_ASSERT(m_tree->callbacks(), s.str[i] == ' ' || s.str[i] == '\t' || s.str[i] == '\n');
+again:
+    size_t pos = s.find("\n ", i);
+    if(pos == npos)
+        pos = s.find("\n\t", i);
+    if(pos != npos)
+    {
+        ++pos;
+        //_c4dbgpf("indblock line@i={} rem=[{}]~~~\n{}~~~", i, s.range(i, pos).len, s.range(i, pos));
+        _rymlindent_nextline();
+        this->Writer::_do_write(s.range(i, pos));
+        i = pos;
+        goto again; // NOLINT
+    }
+    // consume the newlines after the indented block
+    // to prevent them from being escaped
+    pos = s.find('\n', i);
+    if(pos != npos)
+    {
+        const size_t pos2 = s.first_not_of('\n', pos);
+        pos = (pos2 != npos) ? pos2 : pos;
+        //_c4dbgpf("indblock line@i={} rem=[{}]~~~\n{}~~~", i, s.range(i, pos).len, s.range(i, pos));
+        _rymlindent_nextline();
+        this->Writer::_do_write(s.range(i, pos));
+        i = pos;
+    }
+    return i;
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_literal(csubstr s, id_type ilevel, bool explicit_key)
+{
+    _RYML_CB_ASSERT(m_tree->callbacks(), s.find("\r") == csubstr::npos);
+    if(explicit_key)
+        this->Writer::_do_write("? ");
+    csubstr trimmed = s.trimr('\n');
+    const size_t numnewlines_at_end = s.len - trimmed.len;
+    const bool is_newline_only = (trimmed.len == 0 && (s.len > 0));
+    const bool explicit_indentation = s.triml("\n\r").begins_with_any(" \t");
+    //
+    this->Writer::_do_write('|');
+    if(explicit_indentation)
+        this->Writer::_do_write('2');
+    //
+    if(numnewlines_at_end > 1 || is_newline_only)
+        this->Writer::_do_write('+');
+    else if(numnewlines_at_end == 0)
+        this->Writer::_do_write('-');
+    //
+    if(trimmed.len)
+    {
+        this->Writer::_do_write('\n');
+        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));
+        }
+    }
+    for(size_t i = !is_newline_only; i < numnewlines_at_end; ++i)
+        this->Writer::_do_write('\n');
+    if(explicit_key)
+    {
+        this->Writer::_do_write('\n');
+        this->_indent(ilevel);
+    }
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_folded(csubstr s, id_type ilevel, bool explicit_key)
+{
+    if(explicit_key)
+        this->Writer::_do_write("? ");
+    _RYML_CB_ASSERT(m_tree->callbacks(), s.find("\r") == csubstr::npos);
+    csubstr trimmed = s.trimr('\n');
+    const size_t numnewlines_at_end = s.len - trimmed.len;
+    const bool is_newline_only = (trimmed.len == 0 && (s.len > 0));
+    const bool explicit_indentation = s.triml("\n\r").begins_with_any(" \t");
+    //
+    this->Writer::_do_write('>');
+    if(explicit_indentation)
+        this->Writer::_do_write('2');
+    //
+    if(numnewlines_at_end == 0)
+        this->Writer::_do_write('-');
+    else if(numnewlines_at_end > 1 || is_newline_only)
+        this->Writer::_do_write('+');
+    //
+    if(trimmed.len)
+    {
+        this->Writer::_do_write('\n');
+        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;
+            // escape newline sequences
+            if( ! _is_indented_block(s, pos, i))
+            {
+                if(pos < i)
+                {
+                    _rymlindent_nextline()
+                    this->Writer::_do_write(s.range(pos, i));
+                    i = _write_escaped_newlines(s, i);
+                    pos = i+1;
+                }
+                else
+                {
+                    if(i+1 < s.len)
+                    {
+                        if(s.str[i+1] == '\n')
+                        {
+                            ++i;
+                            i = _write_escaped_newlines(s, i);
+                            pos = i+1;
+                        }
+                        else
+                        {
+                            this->Writer::_do_write('\n');
+                            pos = i+1;
+                        }
+                    }
+                }
+            }
+            else // do not escape newlines in indented blocks
+            {
+                ++i;
+                _rymlindent_nextline()
+                this->Writer::_do_write(s.range(pos, i));
+                if(pos > 0 || !s.begins_with_any(" \t"))
+                    i = _write_indented_block(s, i, ilevel);
+                pos = i;
+            }
+        }
+        if(pos < trimmed.len)
+        {
+            _rymlindent_nextline()
+            this->Writer::_do_write(trimmed.sub(pos));
+        }
+    }
+    for(size_t i = !is_newline_only; i < numnewlines_at_end; ++i)
+        this->Writer::_do_write('\n');
+    if(explicit_key)
+    {
+        this->Writer::_do_write('\n');
+        this->_indent(ilevel);
+    }
+}
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_squo(csubstr s, id_type 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')
+        {
+            this->Writer::_do_write(s.range(pos, i));  // write everything up to (excluding) this char
+            //_c4dbgpf("newline at {}. writing ~~~{}~~~", i, s.range(pos, i));
+            i = _write_escaped_newlines(s, i);
+            //_c4dbgpf("newline --> {}", i);
+            if(i < s.len)
+                _rymlindent_nextline()
+            pos = i+1;
+        }
+        else if(s[i] == '\'')
+        {
+            csubstr sub = s.range(pos, i+1);
+            //_c4dbgpf("squote at {}. writing ~~~{}~~~", i, sub);
+            this->Writer::_do_write(sub); // write everything up to (including) this squote
+            this->Writer::_do_write('\''); // write the squote 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, id_type 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];
+        switch(curr) // NOLINT
+        {
+        case '"':
+        case '\\':
+        {
+            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;
+            break;
+        }
+#ifndef prefer_writing_newlines_as_double_newlines
+        case '\n':
+        {
+            csubstr sub = s.range(pos, i);
+            this->Writer::_do_write(sub);   // write everything up to (excluding) this char
+            this->Writer::_do_write("\\n"); // write the escape
+            pos = i+1;
+            (void)ilevel;
+            break;
+        }
+#else
+        case '\n':
+        {
+            // write everything up to (excluding) this newline
+            //_c4dbgpf("nl@i={} rem=[{}]~~~{}~~~", i, s.sub(i).len, s.sub(i));
+            this->Writer::_do_write(s.range(pos, i));
+            i = _write_escaped_newlines(s, i);
+            ++i;
+            pos = i;
+            // as for the next line...
+            if(i < s.len)
+            {
+                _rymlindent_nextline() // indent the next line
+                // escape leading whitespace, and flush it
+                size_t first = s.first_not_of(" \t", i);
+                _c4dbgpf("@i={} first={} rem=[{}]~~~{}~~~", i, first, s.sub(i).len, s.sub(i));
+                if(first > i)
+                {
+                    if(first == npos)
+                        first = s.len;
+                    this->Writer::_do_write('\\');
+                    this->Writer::_do_write(s.range(i, first));
+                    this->Writer::_do_write('\\');
+                    i = first-1;
+                    pos = first;
+                }
+            }
+            break;
+        }
+        // escape trailing whitespace before a newline
+        case ' ':
+        case '\t':
+        {
+            const size_t next = s.first_not_of(" \t\r", i);
+            if(next != npos && s.str[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;
+            }
+            break;
+        }
+#endif
+        case '\r':
+        {
+            csubstr sub = s.range(pos, i);
+            this->Writer::_do_write(sub);  // write everything up to (excluding) this char
+            this->Writer::_do_write("\\r"); // write the escaped char
+            pos = i+1;
+            break;
+        }
+        case '\b':
+        {
+            csubstr sub = s.range(pos, i);
+            this->Writer::_do_write(sub);  // write everything up to (excluding) this char
+            this->Writer::_do_write("\\b"); // write the escaped char
+            pos = i+1;
+            break;
+        }
+        }
+    }
+    // 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_plain(csubstr s, id_type ilevel)
+{
+    if(C4_UNLIKELY(ilevel == 0 && (s.begins_with("...") || s.begins_with("---"))))
+    {
+        _rymlindent_nextline()     // indent the next line
+        ++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);
+            this->Writer::_do_write(sub);  // write everything up to (including) this newline
+            i = _write_escaped_newlines(s, i);
+            pos = i+1;
+            if(pos < s.len)
+                _rymlindent_nextline()     // indent the next line
+        }
+    }
+    // write missing characters at the end of the string
+    if(pos < s.len)
+        this->Writer::_do_write(s.sub(pos));
+}
+
+#undef _rymlindent_nextline
+
+template<class Writer>
+void Emitter<Writer>::_write_scalar_json_dquo(csubstr s)
+{
+    size_t pos = 0;
+    this->Writer::_do_write('"');
+    for(size_t i = 0; i < s.len; ++i)
+    {
+        switch(s.str[i])
+        {
+        case '"':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\\"");
+            pos = i + 1;
+            break;
+        case '\n':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\n");
+            pos = i + 1;
+            break;
+        case '\t':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\t");
+            pos = i + 1;
+            break;
+        case '\\':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\\\");
+            pos = i + 1;
+            break;
+        case '\r':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\r");
+            pos = i + 1;
+            break;
+        case '\b':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\b");
+            pos = i + 1;
+            break;
+        case '\f':
+            this->Writer ::_do_write(s.range(pos, i));
+            this->Writer ::_do_write("\\f");
+            pos = i + 1;
+            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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+namespace detail {
+
+/** A lightweight contiguous stack with Small Storage
+ * Optimization. This is required because std::vector can throw
+ * exceptions, and we don't want to enforce any particular error
+ * mechanism. */
+template<class T, id_type 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");
+
+public:
+
+    enum : id_type { sso_size = N };
+
+public:
+
+    T              m_buf[size_t(N)];
+    T *C4_RESTRICT m_stack;
+    id_type        m_size;
+    id_type        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) RYML_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) RYML_NOEXCEPT
+    {
+        if(&that != this)
+        {
+            _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:
+
+    id_type size() const { return m_size; }
+    id_type empty() const { return m_size == 0; }
+    id_type capacity() const { return m_capacity; }
+
+    void clear()
+    {
+        m_size = 0;
+    }
+
+    void resize(id_type sz)
+    {
+        reserve(sz);
+        m_size = sz;
+    }
+
+    void reserve(id_type sz);
+
+    void push(T const& C4_RESTRICT n)
+    {
+        _RYML_CB_ASSERT(m_callbacks, (const char*)&n + sizeof(T) < (const char*)m_stack || &n > m_stack + m_capacity);
+        if(m_size == m_capacity)
+        {
+            id_type cap = m_capacity == 0 ? N : 2 * m_capacity;
+            reserve(cap);
+        }
+        m_stack[m_size] = n;
+        ++m_size;
+    }
+
+    void push_top()
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_size > 0);
+        if(m_size == m_capacity)
+        {
+            id_type 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_CB_ASSERT(m_callbacks, m_size > 0);
+        --m_size;
+        return m_stack[m_size];
+    }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT top() const { _RYML_CB_ASSERT(m_callbacks, m_size > 0); return m_stack[m_size - 1]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT top()       { _RYML_CB_ASSERT(m_callbacks, m_size > 0); return m_stack[m_size - 1]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT bottom() const { _RYML_CB_ASSERT(m_callbacks, m_size > 0); return m_stack[0]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT bottom()       { _RYML_CB_ASSERT(m_callbacks, m_size > 0); return m_stack[0]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT top(id_type i) const { _RYML_CB_ASSERT(m_callbacks, i < m_size); return m_stack[m_size - 1 - i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT top(id_type i)       { _RYML_CB_ASSERT(m_callbacks, i < m_size); return m_stack[m_size - 1 - i]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT bottom(id_type i) const { _RYML_CB_ASSERT(m_callbacks, i < m_size); return m_stack[i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT bottom(id_type i)       { _RYML_CB_ASSERT(m_callbacks, i < m_size); return m_stack[i]; }
+
+    C4_ALWAYS_INLINE T const& C4_RESTRICT operator[](id_type i) const { _RYML_CB_ASSERT(m_callbacks, i < m_size); return m_stack[i]; }
+    C4_ALWAYS_INLINE T      & C4_RESTRICT operator[](id_type i)       { _RYML_CB_ASSERT(m_callbacks, 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, id_type N>
+void stack<T, N>::reserve(id_type sz)
+{
+    if(sz <= m_size)
+        return;
+    if(sz <= N)
+    {
+        m_stack = m_buf;
+        m_capacity = N;
+        return;
+    }
+    T *buf = (T*) m_callbacks.m_allocate((size_t)sz * sizeof(T), m_stack, m_callbacks.m_user_data);
+    _RYML_CB_ASSERT(m_callbacks, ((uintptr_t)buf % alignof(T)) == 0u);
+    memcpy(buf, m_stack, (size_t)m_size * sizeof(T));
+    if(m_stack != m_buf)
+    {
+        m_callbacks.m_free(m_stack, (size_t)m_capacity * sizeof(T), m_callbacks.m_user_data);
+    }
+    m_stack = buf;
+    m_capacity = sz;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, id_type N>
+void stack<T, N>::_free()
+{
+    _RYML_CB_ASSERT(m_callbacks, m_stack != nullptr); // this structure cannot be memset() to zero
+    if(m_stack != m_buf)
+    {
+        m_callbacks.m_free(m_stack, (size_t)m_capacity * sizeof(T), m_callbacks.m_user_data);
+        m_stack = m_buf;
+        m_size = N;
+        m_capacity = N;
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_callbacks, m_capacity == N);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, id_type N>
+void stack<T, N>::_cp(stack const* C4_RESTRICT that)
+{
+    if(that->m_stack != that->m_buf)
+    {
+        _RYML_CB_ASSERT(m_callbacks, that->m_capacity > N);
+        _RYML_CB_ASSERT(m_callbacks, that->m_size <= that->m_capacity);
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_callbacks, that->m_capacity <= N);
+        _RYML_CB_ASSERT(m_callbacks, 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, id_type N>
+void stack<T, N>::_mv(stack * that)
+{
+    if(that->m_stack != that->m_buf)
+    {
+        _RYML_CB_ASSERT(m_callbacks, that->m_capacity > N);
+        _RYML_CB_ASSERT(m_callbacks, that->m_size <= that->m_capacity);
+        m_stack = that->m_stack;
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_callbacks, that->m_capacity <= N);
+        _RYML_CB_ASSERT(m_callbacks, 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_CB_ASSERT(m_callbacks, that->m_stack != m_buf);
+    that->m_stack = that->m_buf;
+    that->m_capacity = N;
+    that->m_size = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class T, id_type N>
+void stack<T, N>::_cb(Callbacks const& cb)
+{
+    if(cb != m_callbacks)
+    {
+        _free();
+        m_callbacks = cb;
+    }
+}
+
+} // namespace detail
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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/filter_processor.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/filter_processor.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_FILTER_PROCESSOR_HPP_
+#define _C4_YML_FILTER_PROCESSOR_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_ */
+
+
+#ifdef RYML_DBG
+// 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_ */
+
+// 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_ */
+
+#endif
+
+namespace c4 {
+namespace yml {
+
+/** @defgroup doc_filter_processors Scalar filter processors
+ *
+ * These are internal classes used by @ref ParseEngine to parse the
+ * scalars; normally there is no reason for a user to be manually
+ * using these classes.
+ *
+ * @ingroup doc_parse */
+/** @{ */
+
+//-----------------------------------------------------------------------------
+
+/** Filters an input string into a different output string */
+struct FilterProcessorSrcDst
+{
+    csubstr src;
+    substr dst;
+    size_t rpos; ///< read position
+    size_t wpos; ///< write position
+
+    C4_ALWAYS_INLINE FilterProcessorSrcDst(csubstr src_, substr dst_) noexcept
+        : src(src_)
+        , dst(dst_)
+        , rpos(0)
+        , wpos(0)
+    {
+        RYML_ASSERT(!dst.overlaps(src));
+    }
+
+    C4_ALWAYS_INLINE void setwpos(size_t wpos_) noexcept { wpos = wpos_; }
+    C4_ALWAYS_INLINE void setpos(size_t rpos_, size_t wpos_) noexcept { rpos = rpos_; wpos = wpos_; }
+    C4_ALWAYS_INLINE void set_at_end() noexcept { skip(src.len - rpos); }
+
+    C4_ALWAYS_INLINE bool has_more_chars() const noexcept { return rpos < src.len; }
+    C4_ALWAYS_INLINE bool has_more_chars(size_t maxpos) const noexcept { RYML_ASSERT(maxpos <= src.len); return rpos < maxpos; }
+
+    C4_ALWAYS_INLINE csubstr rem() const noexcept { return src.sub(rpos); }
+    C4_ALWAYS_INLINE csubstr sofar() const noexcept { return csubstr(dst.str, wpos <= dst.len ? wpos : dst.len); }
+    C4_ALWAYS_INLINE FilterResult result() const noexcept
+    {
+        FilterResult ret;
+        ret.str.str = wpos <= dst.len ? dst.str : nullptr;
+        ret.str.len = wpos;
+        return ret;
+    }
+
+    C4_ALWAYS_INLINE char curr() const noexcept { RYML_ASSERT(rpos < src.len); return src[rpos]; }
+    C4_ALWAYS_INLINE char next() const noexcept { return rpos+1 < src.len ? src[rpos+1] : '\0'; }
+    C4_ALWAYS_INLINE bool skipped_chars() const noexcept { return wpos != rpos; }
+
+    C4_ALWAYS_INLINE void skip() noexcept { ++rpos; }
+    C4_ALWAYS_INLINE void skip(size_t num) noexcept { rpos += num; }
+
+    C4_ALWAYS_INLINE void set_at(size_t pos, char c) noexcept // NOLINT(readability-make-member-function-const)
+    {
+        RYML_ASSERT(pos < wpos);
+        dst.str[pos] = c;
+    }
+    C4_ALWAYS_INLINE void set(char c) noexcept
+    {
+        if(wpos < dst.len)
+            dst.str[wpos] = c;
+        ++wpos;
+    }
+    C4_ALWAYS_INLINE void set(char c, size_t num) noexcept
+    {
+        RYML_ASSERT(num > 0);
+        if(wpos + num <= dst.len)
+            memset(dst.str + wpos, c, num);
+        wpos += num;
+    }
+
+    C4_ALWAYS_INLINE void copy() noexcept
+    {
+        RYML_ASSERT(rpos < src.len);
+        if(wpos < dst.len)
+            dst.str[wpos] = src.str[rpos];
+        ++wpos;
+        ++rpos;
+    }
+    C4_ALWAYS_INLINE void copy(size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        RYML_ASSERT(rpos+num <= src.len);
+        if(wpos + num <= dst.len)
+            memcpy(dst.str + wpos, src.str + rpos, num);
+        wpos += num;
+        rpos += num;
+    }
+
+    C4_ALWAYS_INLINE void translate_esc(char c) noexcept
+    {
+        if(wpos < dst.len)
+            dst.str[wpos] = c;
+        ++wpos;
+        rpos += 2;
+    }
+    C4_ALWAYS_INLINE void translate_esc_bulk(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        RYML_ASSERT(nw > 0);
+        RYML_ASSERT(nr > 0);
+        RYML_ASSERT(rpos+nr <= src.len);
+        if(wpos+nw <= dst.len)
+            memcpy(dst.str + wpos, s, nw);
+        wpos += nw;
+        rpos += 1 + nr;
+    }
+    C4_ALWAYS_INLINE void translate_esc_extending(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        translate_esc_bulk(s, nw, nr);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+// filter in place
+
+// debugging scaffold
+/** @cond dev */
+#if defined(RYML_DBG) && 0
+#define _c4dbgip(...) _c4dbgpf(__VA_ARGS__)
+#else
+#define _c4dbgip(...)
+#endif
+/** @endcond */
+
+/** Filters in place. While the result may be larger than the source,
+ * any extending happens only at the end of the string. Consequently,
+ * it's impossible for characters to be left unfiltered.
+ *
+ * @see FilterProcessorInplaceMidExtending */
+struct FilterProcessorInplaceEndExtending
+{
+    substr src;  ///< the subject string
+    size_t wcap; ///< write capacity - the capacity of the subject string's buffer
+    size_t rpos; ///< read position
+    size_t wpos; ///< write position
+
+    C4_ALWAYS_INLINE FilterProcessorInplaceEndExtending(substr src_, size_t wcap_) noexcept
+        : src(src_)
+        , wcap(wcap_)
+        , rpos(0)
+        , wpos(0)
+    {
+        RYML_ASSERT(wcap >= src.len);
+    }
+
+    C4_ALWAYS_INLINE void setwpos(size_t wpos_) noexcept { wpos = wpos_; }
+    C4_ALWAYS_INLINE void setpos(size_t rpos_, size_t wpos_) noexcept { rpos = rpos_; wpos = wpos_; }
+    C4_ALWAYS_INLINE void set_at_end() noexcept { skip(src.len - rpos); }
+
+    C4_ALWAYS_INLINE bool has_more_chars() const noexcept { return rpos < src.len; }
+    C4_ALWAYS_INLINE bool has_more_chars(size_t maxpos) const noexcept { RYML_ASSERT(maxpos <= src.len); return rpos < maxpos; }
+
+    C4_ALWAYS_INLINE FilterResult result() const noexcept
+    {
+        _c4dbgip("inplace: wpos={} wcap={} small={}", wpos, wcap, wpos > rpos);
+        FilterResult ret;
+        ret.str.str = (wpos <= wcap) ? src.str : nullptr;
+        ret.str.len = wpos;
+        return ret;
+    }
+    C4_ALWAYS_INLINE csubstr sofar() const noexcept { return csubstr(src.str, wpos <= wcap ? wpos : wcap); }
+    C4_ALWAYS_INLINE csubstr rem() const noexcept { return src.sub(rpos); }
+
+    C4_ALWAYS_INLINE char curr() const noexcept { RYML_ASSERT(rpos < src.len); return src[rpos]; }
+    C4_ALWAYS_INLINE char next() const noexcept { return rpos+1 < src.len ? src[rpos+1] : '\0'; }
+
+    C4_ALWAYS_INLINE void skip() noexcept { ++rpos; }
+    C4_ALWAYS_INLINE void skip(size_t num) noexcept { rpos += num; }
+
+    void set_at(size_t pos, char c) noexcept
+    {
+        RYML_ASSERT(pos < wpos);
+        const size_t save = wpos;
+        wpos = pos;
+        set(c);
+        wpos = save;
+    }
+    void set(char c) noexcept
+    {
+        if(wpos < wcap)  // respect write-capacity
+            src.str[wpos] = c;
+        ++wpos;
+    }
+    void set(char c, size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        if(wpos + num <= wcap)  // respect write-capacity
+            memset(src.str + wpos, c, num);
+        wpos += num;
+    }
+
+    void copy() noexcept
+    {
+        RYML_ASSERT(wpos <= rpos);
+        RYML_ASSERT(rpos < src.len);
+        if(wpos < wcap)  // respect write-capacity
+            src.str[wpos] = src.str[rpos];
+        ++rpos;
+        ++wpos;
+    }
+    void copy(size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        RYML_ASSERT(rpos+num <= src.len);
+        RYML_ASSERT(wpos <= rpos);
+        if(wpos + num <= wcap)  // respect write-capacity
+        {
+            if(wpos + num <= rpos) // there is no overlap
+                memcpy(src.str + wpos, src.str + rpos, num);
+            else                   // there is overlap
+                memmove(src.str + wpos, src.str + rpos, num);
+        }
+        rpos += num;
+        wpos += num;
+    }
+
+    void translate_esc(char c) noexcept
+    {
+        RYML_ASSERT(rpos + 2 <= src.len);
+        RYML_ASSERT(wpos <= rpos);
+        if(wpos < wcap) // respect write-capacity
+            src.str[wpos] = c;
+        rpos += 2; // add 1u to account for the escape character
+        ++wpos;
+    }
+
+    void translate_esc_bulk(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        RYML_ASSERT(nw > 0);
+        RYML_ASSERT(nr > 0);
+        RYML_ASSERT(nw <= nr + 1u);
+        RYML_ASSERT(rpos+nr <= src.len);
+        RYML_ASSERT(wpos <= rpos);
+        const size_t wpos_next = wpos + nw;
+        const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
+        RYML_ASSERT(wpos_next <= rpos_next);
+        if(wpos_next <= wcap)
+            memcpy(src.str + wpos, s, nw);
+        rpos = rpos_next;
+        wpos = wpos_next;
+    }
+
+    C4_ALWAYS_INLINE void translate_esc_extending(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        translate_esc_bulk(s, nw, nr);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** Filters in place. The result may be larger than the source, and
+ * extending may happen anywhere. As a result some characters may be
+ * left unfiltered when there is no slack in the buffer and the
+ * write-position would overlap the read-position. Consequently, it's
+ * possible for characters to be left unfiltered. In YAML, this
+ * happens only with double-quoted strings, and only with a small
+ * number of escape sequences such as `\L` which is substituted by three
+ * bytes. These escape sequences cause a call to translate_esc_extending()
+ * which is the only entry point to this unfiltered situation.
+ *
+ * @see FilterProcessorInplaceMidExtending */
+struct FilterProcessorInplaceMidExtending
+{
+    substr src;  ///< the subject string
+    size_t wcap; ///< write capacity - the capacity of the subject string's buffer
+    size_t rpos; ///< read position
+    size_t wpos; ///< write position
+    size_t maxcap; ///< the max capacity needed for filtering the string. This may be larger than the final string size.
+    bool unfiltered_chars; ///< number of characters that were not added to wpos from lack of capacity
+
+    C4_ALWAYS_INLINE FilterProcessorInplaceMidExtending(substr src_, size_t wcap_) noexcept
+        : src(src_)
+        , wcap(wcap_)
+        , rpos(0)
+        , wpos(0)
+        , maxcap(src.len)
+        , unfiltered_chars(false)
+    {
+        RYML_ASSERT(wcap >= src.len);
+    }
+
+    C4_ALWAYS_INLINE void setwpos(size_t wpos_) noexcept { wpos = wpos_; }
+    C4_ALWAYS_INLINE void setpos(size_t rpos_, size_t wpos_) noexcept { rpos = rpos_; wpos = wpos_; }
+    C4_ALWAYS_INLINE void set_at_end() noexcept { skip(src.len - rpos); }
+
+    C4_ALWAYS_INLINE bool has_more_chars() const noexcept { return rpos < src.len; }
+    C4_ALWAYS_INLINE bool has_more_chars(size_t maxpos) const noexcept { RYML_ASSERT(maxpos <= src.len); return rpos < maxpos; }
+
+    C4_ALWAYS_INLINE FilterResultExtending result() const noexcept
+    {
+        _c4dbgip("inplace: wpos={} wcap={} unfiltered={} maxcap={}", this->wpos, this->wcap, this->unfiltered_chars, this->maxcap);
+        FilterResultExtending ret;
+        ret.str.str = (wpos <= wcap && !unfiltered_chars) ? src.str : nullptr;
+        ret.str.len = wpos;
+        ret.reqlen = maxcap;
+        return ret;
+    }
+    C4_ALWAYS_INLINE csubstr sofar() const noexcept { return csubstr(src.str, wpos <= wcap ? wpos : wcap); }
+    C4_ALWAYS_INLINE csubstr rem() const noexcept { return src.sub(rpos); }
+
+    C4_ALWAYS_INLINE char curr() const noexcept { RYML_ASSERT(rpos < src.len); return src[rpos]; }
+    C4_ALWAYS_INLINE char next() const noexcept { return rpos+1 < src.len ? src[rpos+1] : '\0'; }
+
+    C4_ALWAYS_INLINE void skip() noexcept { ++rpos; }
+    C4_ALWAYS_INLINE void skip(size_t num) noexcept { rpos += num; }
+
+    void set_at(size_t pos, char c) noexcept
+    {
+        RYML_ASSERT(pos < wpos);
+        const size_t save = wpos;
+        wpos = pos;
+        set(c);
+        wpos = save;
+    }
+    void set(char c) noexcept
+    {
+        if(wpos < wcap)  // respect write-capacity
+        {
+            if((wpos <= rpos) && !unfiltered_chars)
+                src.str[wpos] = c;
+        }
+        else
+        {
+            _c4dbgip("inplace: add unwritten {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
+            unfiltered_chars = true;
+        }
+        ++wpos;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+    void set(char c, size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        if(wpos + num <= wcap)  // respect write-capacity
+        {
+            if((wpos <= rpos) && !unfiltered_chars)
+                memset(src.str + wpos, c, num);
+        }
+        else
+        {
+            _c4dbgip("inplace: add unwritten {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+num > maxcap ? wpos+num : maxcap));
+            unfiltered_chars = true;
+        }
+        wpos += num;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+
+    void copy() noexcept
+    {
+        RYML_ASSERT(rpos < src.len);
+        if(wpos < wcap)  // respect write-capacity
+        {
+            if((wpos < rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
+                src.str[wpos] = src.str[rpos];
+        }
+        else
+        {
+            _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})   maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
+            unfiltered_chars = true;
+        }
+        ++rpos;
+        ++wpos;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+    void copy(size_t num) noexcept
+    {
+        RYML_ASSERT(num);
+        RYML_ASSERT(rpos+num <= src.len);
+        if(wpos + num <= wcap)  // respect write-capacity
+        {
+            if((wpos < rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
+            {
+                if(wpos + num <= rpos) // there is no overlap
+                    memcpy(src.str + wpos, src.str + rpos, num);
+                else                   // there is overlap
+                    memmove(src.str + wpos, src.str + rpos, num);
+            }
+        }
+        else
+        {
+            _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})  maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap);
+            unfiltered_chars = true;
+        }
+        rpos += num;
+        wpos += num;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+
+    void translate_esc(char c) noexcept
+    {
+        RYML_ASSERT(rpos + 2 <= src.len);
+        if(wpos < wcap) // respect write-capacity
+        {
+            if((wpos <= rpos) && !unfiltered_chars)
+                src.str[wpos] = c;
+        }
+        else
+        {
+            _c4dbgip("inplace: add unfiltered {}->{}  maxcap={}->{}!", unfiltered_chars, true, maxcap, (wpos+1u > maxcap ? wpos+1u : maxcap));
+            unfiltered_chars = true;
+        }
+        rpos += 2;
+        ++wpos;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+
+    C4_NO_INLINE void translate_esc_bulk(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        RYML_ASSERT(nw > 0);
+        RYML_ASSERT(nr > 0);
+        RYML_ASSERT(nr+1u >= nw);
+        const size_t wpos_next = wpos + nw;
+        const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
+        if(wpos_next <= wcap)  // respect write-capacity
+        {
+            if((wpos <= rpos) && !unfiltered_chars)  // write only if wpos is behind rpos
+                memcpy(src.str + wpos, s, nw);
+        }
+        else
+        {
+            _c4dbgip("inplace: add unwritten {}->{} (wpos={}!=rpos={})={}  (wpos={}<wcap={})  maxcap={}->{}!", unfiltered_chars, true, wpos, rpos, wpos!=rpos, wpos, wcap, wpos<wcap);
+            unfiltered_chars = true;
+        }
+        rpos = rpos_next;
+        wpos = wpos_next;
+        maxcap = wpos > maxcap ? wpos : maxcap;
+    }
+
+    C4_NO_INLINE void translate_esc_extending(const char *C4_RESTRICT s, size_t nw, size_t nr) noexcept
+    {
+        RYML_ASSERT(nw > 0);
+        RYML_ASSERT(nr > 0);
+        RYML_ASSERT(rpos+nr <= src.len);
+        const size_t wpos_next = wpos + nw;
+        const size_t rpos_next = rpos + nr + 1u; // add 1u to account for the escape character
+        if(wpos_next <= rpos_next) // read and write do not overlap. just do a vanilla copy.
+        {
+            if((wpos_next <= wcap) && !unfiltered_chars)
+                memcpy(src.str + wpos, s, nw);
+            rpos = rpos_next;
+            wpos = wpos_next;
+            maxcap = wpos > maxcap ? wpos : maxcap;
+        }
+        else // there is overlap. move the (to-be-read) string to the right.
+        {
+            const size_t excess = wpos_next - rpos_next;
+            RYML_ASSERT(wpos_next > rpos_next);
+            if(src.len + excess <= wcap) // ensure we do not go past the end
+            {
+                RYML_ASSERT(rpos+nr+excess <= src.len);
+                if(wpos_next <= wcap)
+                {
+                    if(!unfiltered_chars)
+                    {
+                        memmove(src.str + wpos_next, src.str + rpos_next, src.len - rpos_next);
+                        memcpy(src.str + wpos, s, nw);
+                    }
+                    rpos = wpos_next; // wpos, not rpos
+                }
+                else
+                {
+                    rpos = rpos_next;
+                    //const size_t unw = nw > (nr + 1u) ? nw - (nr + 1u) : 0;
+                    _c4dbgip("inplace: add unfiltered {}->{}   maxcap={}->{}!", unfiltered_chars, true);
+                    unfiltered_chars = true;
+                }
+                wpos = wpos_next;
+                // extend the string up to capacity
+                src.len += excess;
+                maxcap = wpos > maxcap ? wpos : maxcap;
+            }
+            else
+            {
+                //const size_t unw = nw > (nr + 1u) ? nw - (nr + 1u) : 0;
+                RYML_ASSERT(rpos_next <= src.len);
+                const size_t required_size = wpos_next + (src.len - rpos_next);
+                _c4dbgip("inplace: add unfiltered {}->{}   maxcap={}->{}!", unfiltered_chars, true, maxcap, required_size > maxcap ? required_size : maxcap);
+                RYML_ASSERT(required_size > wcap);
+                unfiltered_chars = true;
+                maxcap = required_size > maxcap ? required_size : maxcap;
+                wpos = wpos_next;
+                rpos = rpos_next;
+            }
+        }
+    }
+};
+
+#undef _c4dbgip
+
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_FILTER_PROCESSOR_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/filter_processor.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/parser_state.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parser_state.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_PARSER_STATE_HPP_
+#define _C4_YML_PARSER_STATE_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
+
+// NOLINTBEGIN(hicpp-signed-bitwise)
+
+namespace c4 {
+namespace yml {
+
+/** data type for @ref ParserState_e */
+using ParserFlag_t = int;
+
+/** Enumeration of the state flags for the parser */
+typedef enum : ParserFlag_t {
+    RTOP = 0x01 <<  0,   ///< reading at top level
+    RUNK = 0x01 <<  1,   ///< reading unknown state (when starting): 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 {}
+    BLCK = 0x01 <<  5,   ///< reading in block mode
+    QMRK = 0x01 <<  6,   ///< reading an explicit key (`? key`)
+    RKEY = 0x01 <<  7,   ///< reading a scalar as key
+    RVAL = 0x01 <<  9,   ///< reading a scalar as val
+    RKCL = 0x01 <<  8,   ///< reading the key colon (ie the : after the key in the map)
+    RNXT = 0x01 << 10,   ///< read next val or keyval
+    SSCL = 0x01 << 11,   ///< there's a stored scalar
+    QSCL = 0x01 << 12,   ///< stored scalar was quoted
+    RSET = 0x01 << 13,   ///< the (implicit) map being read is a !!set. @see https://yaml.org/type/set.html
+    RDOC = 0x01 << 14,   ///< reading a document
+    NDOC = 0x01 << 15,   ///< no document mode. a document has ended and another has not started yet.
+    USTY = 0x01 << 16,   ///< reading in unknown style mode - must determine FLOW or BLCK
+    //! 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 << 17,
+} ParserState_e;
+
+#ifdef RYML_DBG
+/** @cond dev */
+namespace detail {
+csubstr _parser_flags_to_str(substr buf, ParserFlag_t flags);
+} // namespace
+/** @endcond */
+#endif
+
+
+/** Helper to control the line contents while parsing a buffer */
+struct LineContents
+{
+    substr  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
+    substr  full;        ///< the full line, including newlines on the right
+    substr  stripped;    ///< the stripped line, excluding newlines on the right
+
+    LineContents() = default;
+
+    void reset_with_next_line(substr buf, size_t offset)
+    {
+        RYML_ASSERT(offset <= buf.len);
+        size_t e = offset;
+        // get the current line stripped of newline chars
+        while(e < buf.len && (buf.str[e] != '\n' && buf.str[e] != '\r'))
+            ++e;
+        RYML_ASSERT(e >= offset);
+        const substr stripped_ = buf.range(offset, e);
+        #if defined(__GNUC__) && __GNUC__ == 11
+        C4_DONT_OPTIMIZE(stripped_);
+        #endif
+        // advance pos to include the first line ending
+        if(e < buf.len && buf.str[e] == '\r')
+            ++e;
+        if(e < buf.len && buf.str[e] == '\n')
+            ++e;
+        const substr full_ = buf.range(offset, e);
+        reset(full_, stripped_);
+    }
+
+    void reset(substr full_, substr stripped_)
+    {
+        rem = stripped_;
+        indentation = stripped_.first_not_of(' ');  // find the first column where the character is not a space
+        full = full_;
+        stripped = stripped_;
+    }
+
+    C4_ALWAYS_INLINE size_t current_col() const RYML_NOEXCEPT
+    {
+        // WARNING: gcc x86 release builds were wrong (eg returning 0
+        // when the result should be 4 ) when this function was like
+        // this:
+        //
+        //return current_col(rem);
+        //
+        // (see below for the full definition of the called overload
+        // of current_col())
+        //
+        // ... so we explicitly inline the code in here:
+        RYML_ASSERT(rem.str >= full.str);
+        size_t col = static_cast<size_t>(rem.str - full.str);
+        return col;
+        //
+        // this was happening only on builds specifically with (gcc
+        // AND x86 AND release); no other builds were having the
+        // problem: not in debug, not in x64, not in other
+        // architectures, not in clang, not in visual studio. WTF!?
+        //
+        // Enabling debug prints with RYML_DBG made the problem go
+        // away, so these could not be used to debug the
+        // problem. Adding prints inside the called current_col() also
+        // made the problem go away! WTF!???
+        //
+        // a prize will be offered to anybody able to explain why this
+        // was happening.
+    }
+
+    C4_ALWAYS_INLINE size_t current_col(csubstr s) const RYML_NOEXCEPT
+    {
+        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;
+    }
+};
+static_assert(std::is_standard_layout<LineContents>::value, "LineContents not standard");
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+struct ParserState
+{
+    LineContents line_contents;
+    Location     pos;
+    ParserFlag_t flags;
+    size_t       indref;  ///< the reference indentation in the current block scope
+    id_type      level;
+    id_type      node_id; ///< don't hold a pointer to the node as it will be relocated during tree resizes
+    size_t       scalar_col; // the column where the scalar (or its quotes) begin
+    bool         more_indented;
+    bool         has_children;
+
+    ParserState() = default;
+
+    void start_parse(const char *file, id_type node_id_)
+    {
+        level = 0;
+        pos.name = to_csubstr(file);
+        pos.offset = 0;
+        pos.line = 1;
+        pos.col = 1;
+        node_id = node_id_;
+        more_indented = false;
+        scalar_col = 0;
+        indref = 0;
+        has_children = false;
+    }
+
+    void reset_after_push()
+    {
+        node_id = NONE;
+        indref = npos;
+        more_indented = false;
+        ++level;
+        has_children = false;
+    }
+
+    C4_ALWAYS_INLINE void reset_before_pop(ParserState const& to_pop)
+    {
+        pos = to_pop.pos;
+        line_contents = to_pop.line_contents;
+    }
+
+public:
+
+    C4_ALWAYS_INLINE bool at_line_beginning() const noexcept
+    {
+        return line_contents.rem.str == line_contents.full.str;
+    }
+    C4_ALWAYS_INLINE bool indentation_eq() const noexcept
+    {
+        RYML_ASSERT(indref != npos);
+        return line_contents.indentation != npos && line_contents.indentation == indref;
+    }
+    C4_ALWAYS_INLINE bool indentation_ge() const noexcept
+    {
+        RYML_ASSERT(indref != npos);
+        return line_contents.indentation != npos && line_contents.indentation >= indref;
+    }
+    C4_ALWAYS_INLINE bool indentation_gt() const noexcept
+    {
+        RYML_ASSERT(indref != npos);
+        return line_contents.indentation != npos && line_contents.indentation > indref;
+    }
+    C4_ALWAYS_INLINE bool indentation_lt() const noexcept
+    {
+        RYML_ASSERT(indref != npos);
+        return line_contents.indentation != npos && line_contents.indentation < indref;
+    }
+};
+static_assert(std::is_standard_layout<ParserState>::value, "ParserState not standard");
+
+
+} // namespace yml
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise)
+
+#endif /* _C4_YML_PARSER_STATE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/parser_state.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/event_handler_stack.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_stack.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_EVENT_HANDLER_STACK_HPP_
+#define _C4_YML_EVENT_HANDLER_STACK_HPP_
+
+#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
+
+#ifndef _C4_YML_NODE_TYPE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.hpp
+//#include "c4/yml/node_type.hpp"
+#if !defined(C4_YML_NODE_TYPE_HPP_) && !defined(_C4_YML_NODE_TYPE_HPP_)
+#error "amalgamate: file c4/yml/node_type.hpp must have been included at this point"
+#endif /* C4_YML_NODE_TYPE_HPP_ */
+
+#endif
+
+#ifndef _C4_YML_DETAIL_PARSER_DBG_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_ */
+
+#endif
+
+#ifndef _C4_YML_PARSER_STATE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parser_state.hpp
+//#include "c4/yml/parser_state.hpp"
+#if !defined(C4_YML_PARSER_STATE_HPP_) && !defined(_C4_YML_PARSER_STATE_HPP_)
+#error "amalgamate: file c4/yml/parser_state.hpp must have been included at this point"
+#endif /* C4_YML_PARSER_STATE_HPP_ */
+
+#endif
+
+#ifdef RYML_DBG
+#ifndef _C4_YML_DETAIL_PRINT_HPP_
+// 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
+#endif
+
+// NOLINTBEGIN(hicpp-signed-bitwise)
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_event_handlers
+ * @{ */
+
+namespace detail {
+using pfn_relocate_arena = void (*)(void*, csubstr prev_arena, substr next_arena);
+} // detail
+
+/** Use this class a base of implementations of event handler to
+ * simplify the stack logic. */
+template<class HandlerImpl, class HandlerState>
+struct EventHandlerStack
+{
+    static_assert(std::is_base_of<ParserState, HandlerState>::value,
+                  "ParserState must be a base of HandlerState");
+
+    using state = HandlerState;
+    using pfn_relocate_arena = detail::pfn_relocate_arena;
+
+public:
+
+    detail::stack<state> m_stack;
+    state *C4_RESTRICT   m_curr;    ///< current stack level: top of the stack. cached here for easier access.
+    state *C4_RESTRICT   m_parent;  ///< parent of the current stack level.
+    pfn_relocate_arena   m_relocate_arena; ///< callback when the arena gets relocated
+    void *               m_relocate_arena_data;
+
+protected:
+
+    EventHandlerStack() : m_stack(), m_curr(), m_parent(), m_relocate_arena(), m_relocate_arena_data() {}
+    EventHandlerStack(Callbacks const& cb) : m_stack(cb), m_curr(), m_parent(), m_relocate_arena(), m_relocate_arena_data() {}
+
+protected:
+
+    void _stack_start_parse(const char *filename, pfn_relocate_arena relocate_arena, void *relocate_arena_data)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_curr != nullptr);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, relocate_arena != nullptr);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, relocate_arena_data != nullptr);
+        m_curr->start_parse(filename, m_curr->node_id);
+        m_relocate_arena = relocate_arena;
+        m_relocate_arena_data = relocate_arena_data;
+    }
+
+    void _stack_finish_parse()
+    {
+    }
+
+protected:
+
+    void _stack_reset_root()
+    {
+        m_stack.clear();
+        m_stack.push({});
+        m_parent = nullptr;
+        m_curr = &m_stack.top();
+    }
+
+    void _stack_reset_non_root()
+    {
+        m_stack.clear();
+        m_stack.push({}); // parent
+        m_stack.push({}); // node
+        m_parent = &m_stack.top(1);
+        m_curr = &m_stack.top();
+    }
+
+    void _stack_push()
+    {
+        m_stack.push_top();
+        m_parent = &m_stack.top(1); // don't use m_curr. watch out for relocations inside the prev push
+        m_curr = &m_stack.top();
+        m_curr->reset_after_push();
+    }
+
+    void _stack_pop()
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_parent);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_stack.size() > 1);
+        m_parent->reset_before_pop(*m_curr);
+        m_stack.pop();
+        m_parent = m_stack.size() > 1 ? &m_stack.top(1) : nullptr;
+        m_curr = &m_stack.top();
+        #ifdef RYML_DBG
+        if(m_parent)
+            _c4dbgpf("popped! top is now node={} (parent={})", m_curr->node_id, m_parent->node_id);
+        else
+            _c4dbgpf("popped! top is now node={} @ ROOT", m_curr->node_id);
+        #endif
+    }
+
+protected:
+
+    // undefined at the end
+    #define _has_any_(bits) (static_cast<HandlerImpl const* C4_RESTRICT>(this)->template _has_any__<bits>())
+
+    bool _stack_should_push_on_begin_doc() const
+    {
+        const bool is_root = (m_stack.size() == 1u);
+        return is_root && (_has_any_(DOC|VAL|MAP|SEQ) || m_curr->has_children);
+    }
+
+    bool _stack_should_pop_on_end_doc() const
+    {
+        const bool is_root = (m_stack.size() == 1u);
+        return !is_root && _has_any_(DOC);
+    }
+
+protected:
+
+    void _stack_relocate_to_new_arena(csubstr prev, substr curr)
+    {
+        for(state &st : m_stack)
+        {
+            if(st.line_contents.rem.is_sub(prev))
+                st.line_contents.rem = _stack_relocate_to_new_arena(st.line_contents.rem, prev, curr);
+            if(st.line_contents.full.is_sub(prev))
+                st.line_contents.full = _stack_relocate_to_new_arena(st.line_contents.full, prev, curr);
+            if(st.line_contents.stripped.is_sub(prev))
+                st.line_contents.stripped = _stack_relocate_to_new_arena(st.line_contents.stripped, prev, curr);
+        }
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_relocate_arena != nullptr);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_relocate_arena_data != nullptr);
+        m_relocate_arena(m_relocate_arena_data, prev, curr);
+    }
+
+    substr _stack_relocate_to_new_arena(csubstr s, csubstr prev, substr curr)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, prev.is_super(s));
+        auto pos = s.str - prev.str;
+        substr out = {curr.str + pos, s.len};
+        _RYML_CB_ASSERT(m_stack.m_callbacks, curr.is_super(out));
+        return out;
+    }
+
+public:
+
+    /** Check whether the current parse tokens are trailing on the
+     * previous doc, and raise an error if they are. This function is
+     * called by the parse engine (not the event handler) before a doc
+     * is started. */
+    void check_trailing_doc_token() const
+    {
+        const bool is_root = (m_stack.size() == 1u);
+        const bool isndoc = (m_curr->flags & NDOC) != 0;
+        const bool suspicious = _has_any_(MAP|SEQ|VAL);
+        _c4dbgpf("target={} isroot={} suspicious={} ndoc={}", m_curr->node_id, is_root, suspicious, isndoc);
+        if((is_root || _has_any_(DOC)) && suspicious && !isndoc)
+            _RYML_CB_ERR_(m_stack.m_callbacks, "parse error", m_curr->pos);
+    }
+
+protected:
+
+    #undef _has_any_
+
+};
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise)
+
+#endif /* _C4_YML_EVENT_HANDLER_STACK_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_stack.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/event_handler_tree.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_tree.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_EVENT_HANDLER_TREE_HPP_
+#define _C4_YML_EVENT_HANDLER_TREE_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_EVENT_HANDLER_STACK_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_stack.hpp
+//#include "c4/yml/event_handler_stack.hpp"
+#if !defined(C4_YML_EVENT_HANDLER_STACK_HPP_) && !defined(_C4_YML_EVENT_HANDLER_STACK_HPP_)
+#error "amalgamate: file c4/yml/event_handler_stack.hpp must have been included at this point"
+#endif /* C4_YML_EVENT_HANDLER_STACK_HPP_ */
+
+#endif
+
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4702) // unreachable code
+// NOLINTBEGIN(hicpp-signed-bitwise)
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_event_handlers
+ * @{ */
+
+
+/** The stack state needed specifically by @ref EventHandlerTree */
+struct EventHandlerTreeState : public ParserState
+{
+    NodeData *tr_data;
+};
+
+
+/** The event handler to create a ryml @ref Tree. See the
+ * documentation for @ref doc_event_handlers, which has important
+ * notes about the event model used by rapidyaml. */
+struct EventHandlerTree : public EventHandlerStack<EventHandlerTree, EventHandlerTreeState>
+{
+
+    /** @name types
+     * @{ */
+
+    using state = EventHandlerTreeState;
+
+    /** @} */
+
+public:
+
+    /** @cond dev */
+    Tree *C4_RESTRICT m_tree;
+    id_type m_id;
+    size_t m_num_directives;
+    bool m_yaml_directive;
+
+    #ifdef RYML_DBG
+    #define _enable_(bits) _enable__<bits>(); _c4dbgpf("node[{}]: enable {}", m_curr->node_id, #bits)
+    #define _disable_(bits) _disable__<bits>(); _c4dbgpf("node[{}]: disable {}", m_curr->node_id, #bits)
+    #else
+    #define _enable_(bits) _enable__<bits>()
+    #define _disable_(bits) _disable__<bits>()
+    #endif
+    #define _has_any_(bits) _has_any__<bits>()
+    /** @endcond */
+
+public:
+
+    /** @name construction and resetting
+     * @{ */
+
+    EventHandlerTree() : EventHandlerStack(), m_tree(), m_id(NONE), m_num_directives(), m_yaml_directive() {}
+    EventHandlerTree(Callbacks const& cb) : EventHandlerStack(cb), m_tree(), m_id(NONE), m_num_directives(), m_yaml_directive() {}
+    EventHandlerTree(Tree *tree, id_type id) : EventHandlerStack(tree->callbacks()), m_tree(tree), m_id(id), m_num_directives(), m_yaml_directive()
+    {
+        reset(tree, id);
+    }
+
+    void reset(Tree *tree, id_type id)
+    {
+        if(C4_UNLIKELY(!tree))
+            _RYML_CB_ERR(m_stack.m_callbacks, "null tree");
+        if(C4_UNLIKELY(id >= tree->capacity()))
+            _RYML_CB_ERR(tree->callbacks(), "invalid node");
+        if(C4_UNLIKELY(!tree->is_root(id)))
+            if(C4_UNLIKELY(tree->is_map(tree->parent(id))))
+                if(C4_UNLIKELY(!tree->has_key(id)))
+                    _RYML_CB_ERR(tree->callbacks(), "destination node belongs to a map and has no key");
+        m_tree = tree;
+        m_id = id;
+        if(m_tree->is_root(id))
+        {
+            _stack_reset_root();
+            _reset_parser_state(m_curr, id, m_tree->root_id());
+        }
+        else
+        {
+            _stack_reset_non_root();
+            _reset_parser_state(m_parent, id, m_tree->parent(id));
+            _reset_parser_state(m_curr, id, id);
+        }
+        m_num_directives = 0;
+        m_yaml_directive = false;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name parse events
+     * @{ */
+
+    void start_parse(const char* filename, detail::pfn_relocate_arena relocate_arena, void *relocate_arena_data)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree != nullptr);
+        this->_stack_start_parse(filename, relocate_arena, relocate_arena_data);
+    }
+
+    void finish_parse()
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree != nullptr);
+        if(m_num_directives && !m_tree->is_stream(m_tree->root_id()))
+            _RYML_CB_ERR_(m_stack.m_callbacks, "directives cannot be used without a document", {});
+        this->_stack_finish_parse();
+        /* This pointer is temporary. Remember that:
+         *
+         * - this handler object may be held by the user
+         * - it may be used with a temporary tree inside the parse function
+         * - when the parse function returns the temporary tree, its address
+         *   will change
+         *
+         * As a result, the user could try to read the tree from m_tree, and
+         * end up reading the stale temporary object.
+         *
+         * So it is better to clear it here; then the user will get an obvious
+         * segfault if reading from m_tree. */
+        m_tree = nullptr;
+    }
+
+    void cancel_parse()
+    {
+        m_tree = nullptr;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML stream events */
+    /** @{ */
+
+    C4_ALWAYS_INLINE void begin_stream() const noexcept { /*nothing to do*/ }
+
+    C4_ALWAYS_INLINE void end_stream() const noexcept { /*nothing to do*/ }
+
+    /** @} */
+
+public:
+
+    /** @name YAML document events */
+    /** @{ */
+
+    /** implicit doc start (without ---) */
+    void begin_doc()
+    {
+        _c4dbgp("begin_doc");
+        if(_stack_should_push_on_begin_doc())
+        {
+            _c4dbgp("push!");
+            _set_root_as_stream();
+            _push();
+            _enable_(DOC);
+        }
+    }
+    /** implicit doc end (without ...) */
+    void end_doc()
+    {
+        _c4dbgp("end_doc");
+        if(_stack_should_pop_on_end_doc())
+        {
+            _remove_speculative();
+            _c4dbgp("pop!");
+            _pop();
+        }
+    }
+
+    /** explicit doc start, with --- */
+    void begin_doc_expl()
+    {
+        _c4dbgp("begin_doc_expl");
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->root_id() == m_curr->node_id);
+        if(!m_tree->is_stream(m_tree->root_id())) //if(_should_push_on_begin_doc())
+        {
+            _c4dbgp("ensure stream");
+            _set_root_as_stream();
+            id_type first = m_tree->first_child(m_tree->root_id());
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_stream(m_tree->root_id()));
+            _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->num_children(m_tree->root_id()) == 1u);
+            if(m_tree->has_children(first) || m_tree->is_val(first))
+            {
+                _c4dbgp("push!");
+                _push();
+            }
+            else
+            {
+                _c4dbgp("tweak");
+                _push();
+                _remove_speculative();
+                m_curr->node_id = m_tree->last_child(m_tree->root_id());
+                m_curr->tr_data = m_tree->_p(m_curr->node_id);
+            }
+        }
+        else
+        {
+            _c4dbgp("push!");
+            _push();
+        }
+        _enable_(DOC);
+    }
+    /** explicit doc end, with ... */
+    void end_doc_expl()
+    {
+        _c4dbgp("end_doc_expl");
+        _remove_speculative();
+        if(_stack_should_pop_on_end_doc())
+        {
+            _c4dbgp("pop!");
+            _pop();
+        }
+        m_yaml_directive = false;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML map events */
+    /** @{ */
+
+    void begin_map_key_flow()
+    {
+        _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+    }
+    void begin_map_key_block()
+    {
+        _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+    }
+
+    void begin_map_val_flow()
+    {
+        _c4dbgpf("node[{}]: begin_map_val_flow", m_curr->node_id);
+        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
+        _enable_(MAP|FLOW_SL);
+        _save_loc();
+        _push();
+    }
+    void begin_map_val_block()
+    {
+        _c4dbgpf("node[{}]: begin_map_val_block", m_curr->node_id);
+        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
+        _enable_(MAP|BLOCK);
+        _save_loc();
+        _push();
+    }
+
+    void end_map()
+    {
+        _pop();
+        _c4dbgpf("node[{}]: end_map_val", m_curr->node_id);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML seq events */
+    /** @{ */
+
+    void begin_seq_key_flow()
+    {
+        _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+    }
+    void begin_seq_key_block()
+    {
+        _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+    }
+
+    void begin_seq_val_flow()
+    {
+        _c4dbgpf("node[{}]: begin_seq_val_flow", m_curr->node_id);
+        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
+        _enable_(SEQ|FLOW_SL);
+        _save_loc();
+        _push();
+    }
+    void begin_seq_val_block()
+    {
+        _c4dbgpf("node[{}]: begin_seq_val_block", m_curr->node_id);
+        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
+        _enable_(SEQ|BLOCK);
+        _save_loc();
+        _push();
+    }
+
+    void end_seq()
+    {
+        _pop();
+        _c4dbgpf("node[{}]: end_seq_val", m_curr->node_id);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML structure events */
+    /** @{ */
+
+    void add_sibling()
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_parent);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->has_children(m_parent->node_id));
+        NodeData const* prev = m_tree->m_buf; // watchout against relocation of the tree nodes
+        _set_state_(m_curr, m_tree->_append_child__unprotected(m_parent->node_id));
+        if(prev != m_tree->m_buf)
+            _refresh_after_relocation();
+        _c4dbgpf("node[{}]: added sibling={} prev={}", m_parent->node_id, m_curr->node_id, m_tree->prev_sibling(m_curr->node_id));
+    }
+
+    /** set the previous val as the first key of a new map, with flow style.
+     *
+     * See the documentation for @ref doc_event_handlers, which has
+     * important notes about this event.
+     */
+    void actually_val_is_first_key_of_new_map_flow()
+    {
+        if(C4_UNLIKELY(m_tree->is_container(m_curr->node_id)))
+            _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_parent);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree->is_seq(m_parent->node_id));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, !m_tree->is_container(m_curr->node_id));
+        _RYML_CB_ASSERT(m_stack.m_callbacks, !m_tree->has_key(m_curr->node_id));
+        const NodeData tmp = _val2key_(*m_curr->tr_data);
+        _disable_(_VALMASK|VAL_STYLE);
+        m_curr->tr_data->m_val = {};
+        begin_map_val_flow();
+        m_curr->tr_data->m_type = tmp.m_type;
+        m_curr->tr_data->m_key = tmp.m_key;
+    }
+
+    /** like its flow counterpart, but this function can only be
+     * called after the end of a flow-val at root or doc level.
+     *
+     * See the documentation for @ref doc_event_handlers, which has
+     * important notes about this event.
+     */
+    void actually_val_is_first_key_of_new_map_block()
+    {
+        _RYML_CB_ERR_(m_stack.m_callbacks, "ryml trees cannot handle containers as keys", m_curr->pos);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML scalar events */
+    /** @{ */
+
+
+    C4_ALWAYS_INLINE void set_key_scalar_plain_empty() noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar plain as empty", m_curr->node_id);
+        m_curr->tr_data->m_key.scalar = {};
+        _enable_(KEY|KEY_PLAIN|KEYNIL);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_plain_empty() noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar plain as empty", m_curr->node_id);
+        m_curr->tr_data->m_val.scalar = {};
+        _enable_(VAL|VAL_PLAIN|VALNIL);
+    }
+
+    C4_ALWAYS_INLINE void set_key_scalar_plain(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar plain: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_key.scalar = scalar;
+        _enable_(KEY|KEY_PLAIN);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_plain(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar plain: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_val.scalar = scalar;
+        _enable_(VAL|VAL_PLAIN);
+    }
+
+
+    C4_ALWAYS_INLINE void set_key_scalar_dquoted(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar dquot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_key.scalar = scalar;
+        _enable_(KEY|KEY_DQUO);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_dquoted(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar dquot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_val.scalar = scalar;
+        _enable_(VAL|VAL_DQUO);
+    }
+
+
+    C4_ALWAYS_INLINE void set_key_scalar_squoted(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar squot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_key.scalar = scalar;
+        _enable_(KEY|KEY_SQUO);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_squoted(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar squot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_val.scalar = scalar;
+        _enable_(VAL|VAL_SQUO);
+    }
+
+
+    C4_ALWAYS_INLINE void set_key_scalar_literal(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar literal: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_key.scalar = scalar;
+        _enable_(KEY|KEY_LITERAL);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_literal(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar literal: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_val.scalar = scalar;
+        _enable_(VAL|VAL_LITERAL);
+    }
+
+
+    C4_ALWAYS_INLINE void set_key_scalar_folded(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set key scalar folded: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_key.scalar = scalar;
+        _enable_(KEY|KEY_FOLDED);
+    }
+    C4_ALWAYS_INLINE void set_val_scalar_folded(csubstr scalar) noexcept
+    {
+        _c4dbgpf("node[{}]: set val scalar folded: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
+        m_curr->tr_data->m_val.scalar = scalar;
+        _enable_(VAL|VAL_FOLDED);
+    }
+
+
+    C4_ALWAYS_INLINE void mark_key_scalar_unfiltered() noexcept
+    {
+        _enable_(KEY_UNFILT);
+    }
+    C4_ALWAYS_INLINE void mark_val_scalar_unfiltered() noexcept
+    {
+        _enable_(VAL_UNFILT);
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML anchor/reference events */
+    /** @{ */
+
+    void set_key_anchor(csubstr anchor)
+    {
+        _c4dbgpf("node[{}]: set key anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        if(C4_UNLIKELY(_has_any_(KEYREF)))
+            _RYML_CB_ERR_(m_tree->callbacks(), "key cannot have both anchor and ref", m_curr->pos);
+        _RYML_CB_ASSERT(m_tree->callbacks(), !anchor.begins_with('&'));
+        _enable_(KEYANCH);
+        m_curr->tr_data->m_key.anchor = anchor;
+    }
+    void set_val_anchor(csubstr anchor)
+    {
+        _c4dbgpf("node[{}]: set val anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        if(C4_UNLIKELY(_has_any_(VALREF)))
+            _RYML_CB_ERR_(m_tree->callbacks(), "val cannot have both anchor and ref", m_curr->pos);
+        _RYML_CB_ASSERT(m_tree->callbacks(), !anchor.begins_with('&'));
+        _enable_(VALANCH);
+        m_curr->tr_data->m_val.anchor = anchor;
+    }
+
+    void set_key_ref(csubstr ref)
+    {
+        _c4dbgpf("node[{}]: set key ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        if(C4_UNLIKELY(_has_any_(KEYANCH)))
+            _RYML_CB_ERR_(m_tree->callbacks(), "key cannot have both anchor and ref", m_curr->pos);
+        _RYML_CB_ASSERT(m_tree->callbacks(), ref.begins_with('*'));
+        _enable_(KEY|KEYREF);
+        m_curr->tr_data->m_key.anchor = ref.sub(1);
+        m_curr->tr_data->m_key.scalar = ref;
+    }
+    void set_val_ref(csubstr ref)
+    {
+        _c4dbgpf("node[{}]: set val ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        if(C4_UNLIKELY(_has_any_(VALANCH)))
+            _RYML_CB_ERR_(m_tree->callbacks(), "val cannot have both anchor and ref", m_curr->pos);
+        _RYML_CB_ASSERT(m_tree->callbacks(), ref.begins_with('*'));
+        _enable_(VAL|VALREF);
+        m_curr->tr_data->m_val.anchor = ref.sub(1);
+        m_curr->tr_data->m_val.scalar = ref;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML tag events */
+    /** @{ */
+
+    void set_key_tag(csubstr tag) noexcept
+    {
+        _c4dbgpf("node[{}]: set key tag: [{}]~~~{}~~~", m_curr->node_id, tag.len, tag);
+        _enable_(KEYTAG);
+        m_curr->tr_data->m_key.tag = tag;
+    }
+    void set_val_tag(csubstr tag) noexcept
+    {
+        _c4dbgpf("node[{}]: set val tag: [{}]~~~{}~~~", m_curr->node_id, tag.len, tag);
+        _enable_(VALTAG);
+        m_curr->tr_data->m_val.tag = tag;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name YAML directive events */
+    /** @{ */
+
+    C4_NO_INLINE void add_directive(csubstr directive)
+    {
+        _c4dbgpf("% directive! {}", directive);
+        _RYML_CB_ASSERT(m_tree->callbacks(), directive.begins_with('%'));
+        if(directive.begins_with("%TAG"))
+        {
+            if(C4_UNLIKELY(!m_tree->add_tag_directive(directive)))
+                _RYML_CB_ERR_(m_stack.m_callbacks, "failed to add directive", m_curr->pos);
+        }
+        else if(directive.begins_with("%YAML"))
+        {
+            _c4dbgpf("%YAML directive! ignoring...: {}", directive);
+            if(C4_UNLIKELY(m_yaml_directive))
+                _RYML_CB_ERR_(m_stack.m_callbacks, "multiple yaml directives", m_curr->pos);
+            m_yaml_directive = true;
+        }
+        else
+        {
+            _c4dbgpf("unknown directive! ignoring... {}", directive);
+        }
+        ++m_num_directives;
+    }
+
+    /** @} */
+
+public:
+
+    /** @name arena functions */
+    /** @{ */
+
+    substr alloc_arena(size_t len)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        csubstr prev = m_tree->arena();
+        substr out = m_tree->alloc_arena(len);
+        substr curr = m_tree->arena();
+        if(curr.str != prev.str)
+            _stack_relocate_to_new_arena(prev, curr);
+        return out;
+    }
+
+    substr alloc_arena(size_t len, substr *relocated)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        csubstr prev = m_tree->arena();
+        if(!prev.is_super(*relocated))
+            return alloc_arena(len);
+        substr out = alloc_arena(len);
+        substr curr = m_tree->arena();
+        if(curr.str != prev.str)
+            *relocated = _stack_relocate_to_new_arena(*relocated, prev, curr);
+        return out;
+    }
+
+    /** @} */
+
+public:
+
+    /** @cond dev */
+    void _reset_parser_state(state* st, id_type parse_root, id_type node)
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        _set_state_(st, node);
+        const NodeType type = m_tree->type(node);
+        #ifdef RYML_DBG
+        char flagbuf[80];
+        _c4dbgpf("resetting state: initial flags={}", detail::_parser_flags_to_str(flagbuf, st->flags));
+        #endif
+        if(type == NOTYPE)
+        {
+            _c4dbgpf("node[{}] is notype", node);
+            if(m_tree->is_root(parse_root))
+            {
+                _c4dbgpf("node[{}] is root", node);
+                st->flags |= RUNK|RTOP;
+            }
+            else
+            {
+                _c4dbgpf("node[{}] is not root. setting USTY", node);
+                st->flags |= USTY;
+            }
+        }
+        else if(type.is_map())
+        {
+            _c4dbgpf("node[{}] is map", node);
+            st->flags |= RMAP|USTY;
+        }
+        else if(type.is_seq())
+        {
+            _c4dbgpf("node[{}] is map", node);
+            st->flags |= RSEQ|USTY;
+        }
+        else if(type.has_key())
+        {
+            _c4dbgpf("node[{}] has key. setting USTY", node);
+            st->flags |= USTY;
+        }
+        else
+        {
+            _RYML_CB_ERR(m_tree->callbacks(), "cannot append to node");
+        }
+        if(type.is_doc())
+        {
+            _c4dbgpf("node[{}] is doc", node);
+            st->flags |= RDOC;
+        }
+        #ifdef RYML_DBG
+        _c4dbgpf("resetting state: final flags={}", detail::_parser_flags_to_str(flagbuf, st->flags));
+        #endif
+    }
+
+    /** push a new parent, add a child to the new parent, and set the
+     * child as the current node */
+    void _push()
+    {
+        _stack_push();
+        NodeData const* prev = m_tree->m_buf; // watch out against relocation of the tree nodes
+        m_curr->node_id = m_tree->_append_child__unprotected(m_parent->node_id);
+        m_curr->tr_data = m_tree->_p(m_curr->node_id);
+        if(prev != m_tree->m_buf)
+            _refresh_after_relocation();
+        _c4dbgpf("pushed! level={}. top is now node={} (parent={})", m_curr->level, m_curr->node_id, m_parent ? m_parent->node_id : NONE);
+    }
+    /** end the current scope */
+    void _pop()
+    {
+        _remove_speculative_with_parent();
+        _stack_pop();
+    }
+
+public:
+
+    template<type_bits bits> C4_HOT C4_ALWAYS_INLINE void _enable__() noexcept
+    {
+        m_curr->tr_data->m_type.type = static_cast<NodeType_e>(m_curr->tr_data->m_type.type | bits);
+    }
+    template<type_bits bits> C4_HOT C4_ALWAYS_INLINE void _disable__() noexcept
+    {
+        m_curr->tr_data->m_type.type = static_cast<NodeType_e>(m_curr->tr_data->m_type.type & (~bits));
+    }
+    template<type_bits bits> C4_HOT C4_ALWAYS_INLINE bool _has_any__() const noexcept
+    {
+        return (m_curr->tr_data->m_type.type & bits) != 0;
+    }
+
+public:
+
+    C4_ALWAYS_INLINE void _set_state_(state *C4_RESTRICT s, id_type id) const noexcept
+    {
+        s->node_id = id;
+        s->tr_data = m_tree->_p(id);
+    }
+    void _refresh_after_relocation()
+    {
+        _c4dbgp("tree: refreshing stack data after tree data relocation");
+        for(auto &st : m_stack)
+            st.tr_data = m_tree->_p(st.node_id);
+    }
+
+    void _set_root_as_stream()
+    {
+        _c4dbgp("set root as stream");
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->root_id() == 0u);
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_curr->node_id == 0u);
+        const bool hack = !m_tree->has_children(m_curr->node_id) && !m_tree->is_val(m_curr->node_id);
+        if(hack)
+            m_tree->_p(m_tree->root_id())->m_type.add(VAL);
+        m_tree->set_root_as_stream();
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_stream(m_tree->root_id()));
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->has_children(m_tree->root_id()));
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->is_doc(m_tree->first_child(m_tree->root_id())));
+        if(hack)
+            m_tree->_p(m_tree->first_child(m_tree->root_id()))->m_type.rem(VAL);
+        _set_state_(m_curr, m_tree->root_id());
+    }
+
+    static NodeData _val2key_(NodeData const& C4_RESTRICT d) noexcept
+    {
+        NodeData r = d;
+        r.m_key = d.m_val;
+        r.m_val = {};
+        r.m_type = d.m_type;
+        static_assert((_VALMASK >> 1u) == _KEYMASK, "required for this function to work");
+        static_assert((VAL_STYLE >> 1u) == KEY_STYLE, "required for this function to work");
+        r.m_type.type = ((d.m_type.type & (_VALMASK|VAL_STYLE)) >> 1u);
+        r.m_type.type = (r.m_type.type & ~(_VALMASK|VAL_STYLE));
+        r.m_type.type = (r.m_type.type | KEY);
+        return r;
+    }
+
+    void _remove_speculative()
+    {
+        _c4dbgp("remove speculative node");
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->empty());
+        const id_type last_added = m_tree->size() - 1;
+        if(m_tree->has_parent(last_added))
+            if(m_tree->_p(last_added)->m_type == NOTYPE)
+                m_tree->remove(last_added);
+    }
+
+    void _remove_speculative_with_parent()
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        _RYML_CB_ASSERT(m_tree->callbacks(), !m_tree->empty());
+        const id_type last_added = m_tree->size() - 1;
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->has_parent(last_added));
+        if(m_tree->_p(last_added)->m_type == NOTYPE)
+        {
+            _c4dbgpf("remove speculative node with parent. parent={} node={} parent(node)={}", m_parent->node_id, last_added, m_tree->parent(last_added));
+            m_tree->remove(last_added);
+        }
+    }
+
+    C4_ALWAYS_INLINE void _save_loc()
+    {
+        _RYML_CB_ASSERT(m_stack.m_callbacks, m_tree);
+        _RYML_CB_ASSERT(m_tree->callbacks(), m_tree->_p(m_curr->node_id)->m_val.scalar.len == 0);
+        m_tree->_p(m_curr->node_id)->m_val.scalar.str = m_curr->line_contents.rem.str;
+    }
+
+#undef _enable_
+#undef _disable_
+#undef _has_any_
+
+    /** @endcond */
+};
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise)
+C4_SUPPRESS_WARNING_MSVC_POP
+
+#endif /* _C4_YML_EVENT_HANDLER_TREE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_tree.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/parse_engine.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_PARSE_ENGINE_HPP_
+#define _C4_YML_PARSE_ENGINE_HPP_
+
+#ifndef _C4_YML_DETAIL_PARSER_DBG_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_ */
+
+#endif
+
+#ifndef _C4_YML_PARSER_STATE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parser_state.hpp
+//#include "c4/yml/parser_state.hpp"
+#if !defined(C4_YML_PARSER_STATE_HPP_) && !defined(_C4_YML_PARSER_STATE_HPP_)
+#error "amalgamate: file c4/yml/parser_state.hpp must have been included at this point"
+#endif /* C4_YML_PARSER_STATE_HPP_ */
+
+#endif
+
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4251/*needs to have dll-interface to be used by clients of struct*/)
+#endif
+
+// NOLINTBEGIN(hicpp-signed-bitwise)
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_parse
+ * @{ */
+
+/** @defgroup doc_event_handlers Event Handlers
+ *
+ * @brief rapidyaml implements its parsing logic with a two-level
+ * model, where a @ref ParseEngine object reads through the YAML
+ * source, and dispatches events to an EventHandler bound to the @ref
+ * ParseEngine. Because @ref ParseEngine is templated on the event
+ * handler, the binding uses static polymorphism, without any virtual
+ * functions. The actual handler object can be changed at run time,
+ * (but of course needs to be the type of the template parameter).
+ * This is thus a very efficient architecture, and further enables the
+ * user to provide his own custom handler if he wishes to bypass the
+ * rapidyaml @ref Tree.
+ *
+ * There are two handlers implemented in this project:
+ *
+ * - @ref EventHandlerTree is the handler responsible for creating the
+ *   ryml @ref Tree
+ *
+ * - @ref EventHandlerYamlStd is the handler responsible for emitting
+ *   standardized [YAML test suite
+ *   events](https://github.com/yaml/yaml-test-suite), used (only) in
+ *   the CI of this project.
+ *
+ *
+ * ### Event model
+ *
+ * The event model used by the parse engine and event handlers follows
+ * very closely the event model in the [YAML test
+ * suite](https://github.com/yaml/yaml-test-suite).
+ *
+ * Consider for example this YAML,
+ * ```yaml
+ * {foo: bar,foo2: bar2}
+ * ```
+ * which would produce these events in the test-suite parlance:
+ * ```
+ * +STR
+ * +DOC
+ * +MAP {}
+ * =VAL :foo
+ * =VAL :bar
+ * =VAL :foo2
+ * =VAL :bar2
+ * -MAP
+ * -DOC
+ * -STR
+ * ```
+ *
+ * For reference, the @ref ParseEngine object will produce this
+ * sequence of calls to its bound EventHandler:
+ * ```cpp
+ * handler.begin_stream();
+ * handler.begin_doc();
+ * handler.begin_map_val_flow();
+ * handler.set_key_scalar_plain("foo");
+ * handler.set_val_scalar_plain("bar");
+ * handler.add_sibling();
+ * handler.set_key_scalar_plain("foo2");
+ * handler.set_val_scalar_plain("bar2");
+ * handler.end_map();
+ * handler.end_doc();
+ * handler.end_stream();
+ * ```
+ *
+ * For many other examples of all areas of YAML and how ryml's parse
+ * model corresponds to the YAML standard model, refer to the [unit
+ * tests for the parse
+ * engine](https://github.com/biojppm/rapidyaml/tree/master/test/test_parse_engine.cpp).
+ *
+ *
+ * ### Special events
+ *
+ * Most of the parsing events adopted by rapidyaml in its event model
+ * are fairly obvious, but there are two less-obvious events requiring
+ * some explanation.
+ *
+ * These events exist to make it easier to parse some special YAML
+ * cases. They are called by the parser when a just-handled
+ * value/container is actually the first key of a new map:
+ *
+ *   - `actually_val_is_first_key_of_new_map_flow()` (@ref EventHandlerTree::actually_val_is_first_key_of_new_map_flow() "see implementation in EventHandlerTree" / @ref EventHandlerYamlStd::actually_val_is_first_key_of_new_map_flow() "see implementation in EventHandlerYamlStd")
+ *   - `actually_val_is_first_key_of_new_map_block()` (@ref EventHandlerTree::actually_val_is_first_key_of_new_map_block() "see implementation in EventHandlerTree" / @ref EventHandlerYamlStd::actually_val_is_first_key_of_new_map_block() "see implementation in EventHandlerYamlStd")
+ *
+ * For example, consider an implicit map inside a seq: `[a: b, c:
+ * d]` which is parsed as `[{a: b}, {c: d}]`. The standard event
+ * sequence for this YAML would be the following:
+ * ```cpp
+ * handler.begin_seq_val_flow();
+ * handler.begin_map_val_flow();
+ * handler.set_key_scalar_plain("a");
+ * handler.set_val_scalar_plain("b");
+ * handler.end_map();
+ * handler.add_sibling();
+ * handler.begin_map_val_flow();
+ * handler.set_key_scalar_plain("c");
+ * handler.set_val_scalar_plain("d");
+ * handler.end_map();
+ * handler.end_seq();
+ * ```
+ * The problem with this event sequence is that it forces the
+ * parser to delay setting the val scalar (in this case "a" and
+ * "c") until it knows whether the scalar is a key or a val. This
+ * would require the parser to store the scalar until this
+ * time. For instance, in the example above, the parser should
+ * delay setting "a" and "c", because they are in fact keys and
+ * not vals. Until then, the parser would have to store "a" and
+ * "c" in its internal state. The downside is that this complexity
+ * cost would apply even if there is no implicit map -- every val
+ * in a seq would have to be delayed until one of the
+ * disambiguating subsequent tokens `,-]:` is found.
+ * By calling this function, the parser can avoid this complexity,
+ * by preemptively setting the scalar as a val. Then a call to
+ * this function will create the map and rearrange the scalar as
+ * key. Now the cost applies only once: when a seqimap starts. So
+ * the following (easier and cheaper) event sequence below has the
+ * same effect as the event sequence above:
+ * ```cpp
+ * handler.begin_seq_val_flow();
+ * handler.set_val_scalar_plain("notmap");
+ * handler.set_val_scalar_plain("a"); // preemptively set "a" as val!
+ * handler.actually_as_new_map_key(); // create a map, move the "a" val as the key of the first child of the new map
+ * handler.set_val_scalar_plain("b"); // now "a" is a key and "b" the val
+ * handler.end_map();
+ * handler.set_val_scalar_plain("c"); // "c" also as val!
+ * handler.actually_as_block_flow();  // likewise
+ * handler.set_val_scalar_plain("d"); // now "c" is a key and "b" the val
+ * handler.end_map();
+ * handler.end_seq();
+ * ```
+ * This also applies to container keys (although ryml's tree
+ * cannot accomodate these): the parser can preemptively set a
+ * container as a val, and call this event to turn that container
+ * into a key. For example, consider this yaml:
+ * ```yaml
+ *   [aa, bb]: [cc, dd]
+ * # ^       ^ ^
+ * # |       | |
+ * # (2)   (1) (3)     <- event sequence
+ * ```
+ * The standard event sequence for this YAML would be the
+ * following:
+ * ```cpp
+ * handler.begin_map_val_block();       // (1)
+ * handler.begin_seq_key_flow();        // (2)
+ * handler.set_val_scalar_plain("aa");
+ * handler.add_sibling();
+ * handler.set_val_scalar_plain("bb");
+ * handler.end_seq();
+ * handler.begin_seq_val_flow();        // (3)
+ * handler.set_val_scalar_plain("cc");
+ * handler.add_sibling();
+ * handler.set_val_scalar_plain("dd");
+ * handler.end_seq();
+ * handler.end_map();
+ * ```
+ * The problem with the sequence above is that, reading from
+ * left-to-right, the parser can only detect the proper calls at
+ * (1) and (2) once it reaches (1) in the YAML source. So, the
+ * parser would have to buffer the entire event sequence starting
+ * from the beginning until it reaches (1). Using this function,
+ * the parser can do instead:
+ * ```cpp
+ * handler.begin_seq_val_flow();        // (2) -- preemptively as val!
+ * handler.set_val_scalar_plain("aa");
+ * handler.add_sibling();
+ * handler.set_val_scalar_plain("bb");
+ * handler.end_seq();
+ * handler.actually_as_new_map_key();   // (1) -- adjust when finding that the prev val was actually a key.
+ * handler.begin_seq_val_flow();        // (3) -- go on as before
+ * handler.set_val_scalar_plain("cc");
+ * handler.add_sibling();
+ * handler.set_val_scalar_plain("dd");
+ * handler.end_seq();
+ * handler.end_map();
+ * ```
+ */
+
+class Tree;
+class NodeRef;
+class ConstNodeRef;
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** Options to give to the parser to control its behavior. */
+struct RYML_EXPORT ParserOptions
+{
+private:
+
+    typedef enum : uint32_t {
+        SCALAR_FILTERING = (1u << 0u),
+        LOCATIONS = (1u << 1u),
+        DEFAULTS = SCALAR_FILTERING,
+    } Flags_e;
+
+    uint32_t flags = DEFAULTS;
+
+public:
+
+    ParserOptions() = default;
+
+public:
+
+    /** @name source location tracking */
+    /** @{ */
+
+    /** enable/disable source location tracking */
+    ParserOptions& locations(bool enabled) noexcept
+    {
+        if(enabled)
+            flags |= LOCATIONS;
+        else
+            flags &= ~LOCATIONS;
+        return *this;
+    }
+    /** query source location tracking status */
+    C4_ALWAYS_INLINE bool locations() const noexcept { return (flags & LOCATIONS); }
+
+    /** @} */
+
+public:
+
+    /** @name scalar filtering status (experimental; disable at your discretion) */
+    /** @{ */
+
+    /** enable/disable scalar filtering while parsing */
+    ParserOptions& scalar_filtering(bool enabled) noexcept
+    {
+        if(enabled)
+            flags |= SCALAR_FILTERING;
+        else
+            flags &= ~SCALAR_FILTERING;
+        return *this;
+    }
+    /** query scalar filtering status */
+    C4_ALWAYS_INLINE bool scalar_filtering() const noexcept { return (flags & SCALAR_FILTERING); }
+
+    /** @} */
+};
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** This is the main driver of parsing logic: it scans the YAML or
+ * JSON source for tokens, and emits the appropriate sequence of
+ * parsing events to its event handler. The parse engine itself has no
+ * special limitations, and *can* accomodate containers as keys; it is the
+ * event handler may introduce additional constraints.
+ *
+ * There are two implemented handlers (see @ref doc_event_handlers,
+ * which has important notes about the event model):
+ *
+ * - @ref EventHandlerTree is the handler responsible for creating the
+ *   ryml @ref Tree
+ *
+ * - @ref EventHandlerYamlStd is the handler responsible for emitting
+ *   standardized [YAML test suite
+ *   events](https://github.com/yaml/yaml-test-suite), used (only) in
+ *   the CI of this project. This is not part of the library and is
+ *   not installed.
+ */
+template<class EventHandler>
+class ParseEngine
+{
+public:
+
+    using handler_type = EventHandler;
+
+public:
+
+    /** @name construction and assignment */
+    /** @{ */
+
+    ParseEngine(EventHandler *evt_handler, ParserOptions opts={});
+    ~ParseEngine();
+
+    ParseEngine(ParseEngine &&) noexcept;
+    ParseEngine(ParseEngine const&);
+    ParseEngine& operator=(ParseEngine &&) noexcept;
+    ParseEngine& operator=(ParseEngine 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
+     * directly 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 (when different).
+     *
+     * @note for maximum efficiency, the tree and the arena can (and
+     * should) also be reserved. */
+    void reserve_stack(id_type capacity)
+    {
+        m_evt_handler->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);
+    }
+
+    RYML_DEPRECATED("filter arena no longer needed")
+    void reserve_filter_arena(size_t) {}
+
+    /** @} */
+
+public:
+
+    /** @name getters */
+    /** @{ */
+
+    /** Get the options used to build this parser object. */
+    ParserOptions const& options() const { return m_options; }
+
+    /** Get the current callbacks in the parser. */
+    Callbacks const& callbacks() const { RYML_ASSERT(m_evt_handler); return m_evt_handler->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; }
+
+    /** Get the encoding of the latest YAML buffer parsed by this object.
+     * If no encoding was specified, UTF8 is assumed as per the YAML standard. */
+    Encoding_e encoding() const { return m_encoding != NOBOM ? m_encoding : UTF8; }
+
+    id_type stack_capacity() const { RYML_ASSERT(m_evt_handler); return m_evt_handler->m_stack.capacity(); }
+    size_t locations_capacity() const { return m_newline_offsets_capacity; }
+
+    RYML_DEPRECATED("filter arena no longer needed")
+    size_t filter_arena_capacity() const { return 0u; }
+
+    /** @} */
+
+public:
+
+    /** @name parse methods */
+    /** @{ */
+
+    /** parse YAML in place, emitting events to the current handler */
+    void parse_in_place_ev(csubstr filename, substr src);
+
+    /** parse JSON in place, emitting events to the current handler */
+    void parse_json_in_place_ev(csubstr filename, substr src);
+
+    /** @} */
+
+public:
+
+    /** @name deprecated parse methods
+     * @{ */
+
+    /** @cond dev */
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(csubstr filename, substr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(                  substr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(csubstr filename, substr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(                  substr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(csubstr filename, substr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_place(                  substr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_place(csubstr filename, substr yaml                         );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_place(                  substr yaml                         );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, csubstr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  csubstr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, csubstr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  csubstr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, csubstr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  csubstr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_arena(csubstr filename, csubstr yaml                         );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding function in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_arena(                  csubstr yaml                         );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, substr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  substr yaml, Tree *t, size_t node_id);
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, substr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  substr yaml, Tree *t                );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(csubstr filename, substr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, void>::type parse_in_arena(                  substr yaml, NodeRef node           );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_arena(csubstr filename, substr yaml                         );
+    template<class U=EventHandler> RYML_DEPRECATED("removed, deliberately undefined. use the freestanding csubstr version in parse.hpp.") typename std::enable_if<U::is_wtree, Tree>::type parse_in_arena(                  substr yaml                         );
+    /** @endcond */
+
+    /** @} */
+
+public:
+
+    /** @name locations */
+    /** @{ */
+
+    /** Get the location of a node of the last tree to be parsed by this parser. */
+    Location location(Tree const& tree, id_type node_id) const;
+    /** Get the location of a node of the last tree to be parsed by this parser. */
+    Location location(ConstNodeRef 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.
+     * @param[in] val must be pointing to somewhere in the source
+     * buffer that was last parsed by this object. */
+    Location val_location(const char *val) const;
+
+    /** @} */
+
+public:
+
+    /** @name scalar filtering */
+    /** @{*/
+
+    /** filter a plain scalar */
+    FilterResult filter_scalar_plain(csubstr scalar, substr dst, size_t indentation);
+    /** filter a plain scalar in place */
+    FilterResult filter_scalar_plain_in_place(substr scalar, size_t cap, size_t indentation);
+
+    /** filter a single-quoted scalar */
+    FilterResult filter_scalar_squoted(csubstr scalar, substr dst);
+    /** filter a single-quoted scalar in place */
+    FilterResult filter_scalar_squoted_in_place(substr scalar, size_t cap);
+
+    /** filter a double-quoted scalar */
+    FilterResult filter_scalar_dquoted(csubstr scalar, substr dst);
+    /** filter a double-quoted scalar in place */
+    FilterResultExtending filter_scalar_dquoted_in_place(substr scalar, size_t cap);
+
+    /** filter a block-literal scalar */
+    FilterResult filter_scalar_block_literal(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp);
+    /** filter a block-literal scalar in place */
+    FilterResult filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp);
+
+    /** filter a block-folded scalar */
+    FilterResult filter_scalar_block_folded(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp);
+    /** filter a block-folded scalar in place */
+    FilterResult filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp);
+
+    /** @} */
+
+private:
+
+    struct ScannedScalar
+    {
+        substr scalar;
+        bool needs_filter;
+    };
+
+    struct ScannedBlock
+    {
+        substr scalar;
+        size_t indentation;
+        BlockChomp_e chomp;
+    };
+
+    bool    _is_doc_begin(csubstr s);
+    bool    _is_doc_end(csubstr s);
+
+    bool    _scan_scalar_plain_blck(ScannedScalar *C4_RESTRICT sc, size_t indentation);
+    bool    _scan_scalar_plain_seq_flow(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_plain_seq_blck(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_plain_map_flow(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_plain_map_blck(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_map_json(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_seq_json(ScannedScalar *C4_RESTRICT sc);
+    bool    _scan_scalar_plain_unk(ScannedScalar *C4_RESTRICT sc);
+    bool    _is_valid_start_scalar_plain_flow(csubstr s);
+
+    ScannedScalar _scan_scalar_squot();
+    ScannedScalar _scan_scalar_dquot();
+
+    void    _scan_block(ScannedBlock *C4_RESTRICT sb, size_t indref);
+
+    csubstr _scan_anchor();
+    csubstr _scan_ref_seq();
+    csubstr _scan_ref_map();
+    csubstr _scan_tag();
+
+public: // exposed for testing
+
+    /** @cond dev */
+    csubstr _filter_scalar_plain(substr s, size_t indentation);
+    csubstr _filter_scalar_squot(substr s);
+    csubstr _filter_scalar_dquot(substr s);
+    csubstr _filter_scalar_literal(substr s, size_t indentation, BlockChomp_e chomp);
+    csubstr _filter_scalar_folded(substr s, size_t indentation, BlockChomp_e chomp);
+
+    csubstr _maybe_filter_key_scalar_plain(ScannedScalar const& sc, size_t indendation);
+    csubstr _maybe_filter_val_scalar_plain(ScannedScalar const& sc, size_t indendation);
+    csubstr _maybe_filter_key_scalar_squot(ScannedScalar const& sc);
+    csubstr _maybe_filter_val_scalar_squot(ScannedScalar const& sc);
+    csubstr _maybe_filter_key_scalar_dquot(ScannedScalar const& sc);
+    csubstr _maybe_filter_val_scalar_dquot(ScannedScalar const& sc);
+    csubstr _maybe_filter_key_scalar_literal(ScannedBlock const& sb);
+    csubstr _maybe_filter_val_scalar_literal(ScannedBlock const& sb);
+    csubstr _maybe_filter_key_scalar_folded(ScannedBlock const& sb);
+    csubstr _maybe_filter_val_scalar_folded(ScannedBlock const& sb);
+    /** @endcond */
+
+private:
+
+    void  _handle_map_block();
+    void  _handle_seq_block();
+    void  _handle_map_flow();
+    void  _handle_seq_flow();
+    void  _handle_seq_imap();
+    void  _handle_map_json();
+    void  _handle_seq_json();
+
+    void  _handle_unk();
+    void  _handle_unk_json();
+    void  _handle_usty();
+
+    void  _handle_flow_skip_whitespace();
+
+    void  _end_map_blck();
+    void  _end_seq_blck();
+    void  _end2_map();
+    void  _end2_seq();
+
+    void  _begin2_doc();
+    void  _begin2_doc_expl();
+    void  _end2_doc();
+    void  _end2_doc_expl();
+
+    void  _maybe_begin_doc();
+    void  _maybe_end_doc();
+
+    void  _start_doc_suddenly();
+    void  _end_doc_suddenly();
+    void  _end_doc_suddenly__pop();
+    void  _end_stream();
+
+    void  _set_indentation(size_t indentation);
+    void  _save_indentation();
+    void  _handle_indentation_pop_from_block_seq();
+    void  _handle_indentation_pop_from_block_map();
+    void  _handle_indentation_pop(ParserState const* dst);
+
+    void _maybe_skip_comment();
+    void _skip_comment();
+    void _maybe_skip_whitespace_tokens();
+    void _maybe_skipchars(char c);
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    void _maybe_skipchars_up_to(char c, size_t max_to_skip);
+    #endif
+    template<size_t N>
+    void _skipchars(const char (&chars)[N]);
+    bool _maybe_scan_following_colon() noexcept;
+    bool _maybe_scan_following_comma() noexcept;
+
+public:
+
+    /** @cond dev */
+    template<class FilterProcessor> auto _filter_plain(FilterProcessor &C4_RESTRICT proc, size_t indentation) -> decltype(proc.result());
+    template<class FilterProcessor> auto _filter_squoted(FilterProcessor &C4_RESTRICT proc) -> decltype(proc.result());
+    template<class FilterProcessor> auto _filter_dquoted(FilterProcessor &C4_RESTRICT proc) -> decltype(proc.result());
+    template<class FilterProcessor> auto _filter_block_literal(FilterProcessor &C4_RESTRICT proc, size_t indentation, BlockChomp_e chomp) -> decltype(proc.result());
+    template<class FilterProcessor> auto _filter_block_folded(FilterProcessor &C4_RESTRICT proc, size_t indentation, BlockChomp_e chomp) -> decltype(proc.result());
+    /** @endcond */
+
+public:
+
+    /** @cond dev */
+    template<class FilterProcessor> void   _filter_nl_plain(FilterProcessor &C4_RESTRICT proc, size_t indentation);
+    template<class FilterProcessor> void   _filter_nl_squoted(FilterProcessor &C4_RESTRICT proc);
+    template<class FilterProcessor> void   _filter_nl_dquoted(FilterProcessor &C4_RESTRICT proc);
+
+    template<class FilterProcessor> bool   _filter_ws_handle_to_first_non_space(FilterProcessor &C4_RESTRICT proc);
+    template<class FilterProcessor> void   _filter_ws_copy_trailing(FilterProcessor &C4_RESTRICT proc);
+    template<class FilterProcessor> void   _filter_ws_skip_trailing(FilterProcessor &C4_RESTRICT proc);
+
+    template<class FilterProcessor> void   _filter_dquoted_backslash(FilterProcessor &C4_RESTRICT proc);
+
+    template<class FilterProcessor> void   _filter_chomp(FilterProcessor &C4_RESTRICT proc, BlockChomp_e chomp, size_t indentation);
+    template<class FilterProcessor> size_t _handle_all_whitespace(FilterProcessor &C4_RESTRICT proc, BlockChomp_e chomp);
+    template<class FilterProcessor> size_t _extend_to_chomp(FilterProcessor &C4_RESTRICT proc, size_t contents_len);
+    template<class FilterProcessor> void   _filter_block_indentation(FilterProcessor &C4_RESTRICT proc, size_t indentation);
+    template<class FilterProcessor> void   _filter_block_folded_newlines(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len);
+    template<class FilterProcessor> size_t _filter_block_folded_newlines_compress(FilterProcessor &C4_RESTRICT proc, size_t num_newl, size_t wpos_at_first_newl);
+    template<class FilterProcessor> void   _filter_block_folded_newlines_leading(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len);
+    template<class FilterProcessor> void   _filter_block_folded_indented_block(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len, size_t curr_indentation) noexcept;
+
+    /** @endcond */
+
+private:
+
+    void _line_progressed(size_t ahead);
+    void _line_ended();
+    void _line_ended_undo();
+
+    bool  _finished_file() const;
+    bool  _finished_line() const;
+
+    void   _scan_line();
+    substr _peek_next_line(size_t pos=npos) const;
+
+    bool _at_line_begin() const
+    {
+        return m_evt_handler->m_curr->line_contents.rem.begin() == m_evt_handler->m_curr->line_contents.full.begin();
+    }
+
+    void _relocate_arena(csubstr prev_arena, substr next_arena);
+    static void _s_relocate_arena(void*, csubstr prev_arena, substr next_arena);
+
+private:
+
+    C4_ALWAYS_INLINE bool has_all(ParserFlag_t f) const noexcept { return (m_evt_handler->m_curr->flags & f) == f; }
+    C4_ALWAYS_INLINE bool has_any(ParserFlag_t f) const noexcept { return (m_evt_handler->m_curr->flags & f) != 0; }
+    C4_ALWAYS_INLINE bool has_none(ParserFlag_t f) const noexcept { return (m_evt_handler->m_curr->flags & f) == 0; }
+    static C4_ALWAYS_INLINE bool has_all(ParserFlag_t f, ParserState const* C4_RESTRICT s) noexcept { return (s->flags & f) == f; }
+    static C4_ALWAYS_INLINE bool has_any(ParserFlag_t f, ParserState const* C4_RESTRICT s) noexcept { return (s->flags & f) != 0; }
+    static C4_ALWAYS_INLINE bool has_none(ParserFlag_t f, ParserState const* C4_RESTRICT s) noexcept { return (s->flags & f) == 0; }
+
+    #ifndef RYML_DBG
+    C4_ALWAYS_INLINE static void add_flags(ParserFlag_t on, ParserState *C4_RESTRICT s) noexcept { s->flags |= on; }
+    C4_ALWAYS_INLINE static void addrem_flags(ParserFlag_t on, ParserFlag_t off, ParserState *C4_RESTRICT s) noexcept { s->flags &= ~off; s->flags |= on; }
+    C4_ALWAYS_INLINE static void rem_flags(ParserFlag_t off, ParserState *C4_RESTRICT s) noexcept { s->flags &= ~off; }
+    C4_ALWAYS_INLINE void add_flags(ParserFlag_t on) noexcept { m_evt_handler->m_curr->flags |= on; }
+    C4_ALWAYS_INLINE void addrem_flags(ParserFlag_t on, ParserFlag_t off) noexcept { m_evt_handler->m_curr->flags &= ~off; m_evt_handler->m_curr->flags |= on; }
+    C4_ALWAYS_INLINE void rem_flags(ParserFlag_t off) noexcept { m_evt_handler->m_curr->flags &= ~off; }
+    #else
+    static void add_flags(ParserFlag_t on, ParserState *C4_RESTRICT s);
+    static void addrem_flags(ParserFlag_t on, ParserFlag_t off, ParserState *C4_RESTRICT s);
+    static void rem_flags(ParserFlag_t off, ParserState *C4_RESTRICT s);
+    C4_ALWAYS_INLINE void add_flags(ParserFlag_t on) noexcept { add_flags(on, m_evt_handler->m_curr); }
+    C4_ALWAYS_INLINE void addrem_flags(ParserFlag_t on, ParserFlag_t off) noexcept { addrem_flags(on, off, m_evt_handler->m_curr); }
+    C4_ALWAYS_INLINE void rem_flags(ParserFlag_t off) noexcept { rem_flags(off, m_evt_handler->m_curr); }
+    #endif
+
+private:
+
+    void _prepare_locations();
+    void _resize_locations(size_t sz);
+    bool _locations_dirty() const;
+
+    bool _location_from_cont(Tree const& tree, id_type node, Location *C4_RESTRICT loc) const;
+    bool _location_from_node(Tree const& tree, id_type node, Location *C4_RESTRICT loc, id_type level) const;
+
+private:
+
+    void _reset();
+    void _free();
+    void _clr();
+
+    #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 ...Args> void _errloc(csubstr fmt, Location const& loc, Args const& C4_RESTRICT ...args) const;
+
+    template<class DumpFn>  void _fmt_msg(DumpFn &&dumpfn) const;
+
+private:
+
+    /** store pending tag or anchor/ref annotations */
+    struct Annotation
+    {
+        struct Entry
+        {
+            csubstr str;
+            size_t indentation;
+            size_t line;
+        };
+        Entry annotations[2];
+        size_t num_entries;
+    };
+
+    void _handle_colon();
+    void _add_annotation(Annotation *C4_RESTRICT dst, csubstr str, size_t indentation, size_t line);
+    void _clear_annotations(Annotation *C4_RESTRICT dst);
+    bool _has_pending_annotations() const { return m_pending_tags.num_entries || m_pending_anchors.num_entries; }
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    bool _handle_indentation_from_annotations();
+    #endif
+    bool _annotations_require_key_container() const;
+    void _handle_annotations_before_blck_key_scalar();
+    void _handle_annotations_before_blck_val_scalar();
+    void _handle_annotations_before_start_mapblck(size_t current_line);
+    void _handle_annotations_before_start_mapblck_as_key();
+    void _handle_annotations_and_indentation_after_start_mapblck(size_t key_indentation, size_t key_line);
+    size_t _select_indentation_from_annotations(size_t val_indentation, size_t val_line);
+    void _handle_directive(csubstr rem);
+    bool _handle_bom();
+    void _handle_bom(Encoding_e enc);
+
+    void _check_tag(csubstr tag);
+
+private:
+
+    ParserOptions m_options;
+
+    csubstr m_file;
+    substr  m_buf;
+
+public:
+
+    /** @cond dev */
+    EventHandler *C4_RESTRICT m_evt_handler; // NOLINT
+    /** @endcond */
+
+private:
+
+    Annotation m_pending_anchors;
+    Annotation m_pending_tags;
+
+    bool m_was_inside_qmrk;
+    bool m_doc_empty = true;
+    size_t m_prev_colon = npos;
+
+    Encoding_e m_encoding = UTF8;
+
+private:
+
+    size_t *m_newline_offsets;
+    size_t  m_newline_offsets_size;
+    size_t  m_newline_offsets_capacity;
+    csubstr m_newline_offsets_buf;
+
+};
+
+/** @cond dev */
+RYML_EXPORT C4_NO_INLINE size_t _find_last_newline_and_larger_indentation(csubstr s, size_t indentation) noexcept;
+/** @endcond */
+
+
+/** Quickly inspect the source to estimate the number of nodes the
+ * resulting tree is likely have. If a tree is empty before
+ * parsing, considerable time will be spent growing it, so calling
+ * this to reserve the tree size prior to parsing is likely to
+ * result in a time gain. We encourage using this method before
+ * parsing, but as always measure its impact in performance to
+ * obtain a good trade-off.
+ *
+ * @note since this method is meant for optimizing performance, it
+ * is approximate. The result may be actually smaller than the
+ * resulting number of nodes, notably if the YAML uses implicit
+ * maps as flow seq members as in `[these: are, individual:
+ * maps]`. */
+RYML_EXPORT id_type estimate_tree_capacity(csubstr src); // NOLINT(readability-redundant-declaration)
+
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise)
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+#endif /* _C4_YML_PARSE_ENGINE_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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. */
+
+#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 {
+
+/** @addtogroup doc_preprocessors
+ * @{
+ */
+
+/** @cond dev */
+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
+/** @endcond */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_preprocess_rxmap preprocess_rxmap
+ *
+ * @brief 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;
+}
+
+/** @} */ // preprocess_rxmap
+/** @} */ // group
+
+} // namespace yml
+} // namespace c4
+
+#endif /* _C4_YML_PREPROCESS_HPP_ */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/preprocess.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/reference_resolver.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_REFERENCE_RESOLVER_HPP_
+#define _C4_YML_REFERENCE_RESOLVER_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/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_ */
+
+
+
+namespace c4 {
+namespace yml {
+
+/** @addtogroup doc_ref_utils
+ * @{
+ */
+
+/** Reusable object to resolve references/aliases in a @ref Tree. */
+struct RYML_EXPORT ReferenceResolver
+{
+    ReferenceResolver() = default;
+
+    /** Resolve references: for each reference, look for a matching
+     * anchor, and copy its contents to the ref node.
+     *
+     * @p tree the subject tree
+     *
+     * @p clear_anchors whether to clear existing anchors after
+     * resolving
+     *
+     * 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
+     * one of the reasons for requiring an explicit call.
+     *
+     * The @ref Tree has an `Tree::resolve()` overload set forwarding
+     * here. Previously this operation was done there, using a
+     * discarded object; using this separate class offers opportunity
+     * for reuse of the object.
+     *
+     * @warning resolving references opens an attack vector when the
+     * data is malicious or severely malformed, as the tree can expand
+     * exponentially. See for example the [Billion Laughs
+     * Attack](https://en.wikipedia.org/wiki/Billion_laughs_attack).
+     *
+     */
+    void resolve(Tree *tree, bool clear_anchors=true);
+
+public:
+
+    /** @cond dev */
+
+    struct RefData
+    {
+        NodeType type;
+        id_type node;
+        id_type prev_anchor;
+        id_type target;
+        id_type parent_ref;
+        id_type parent_ref_sibling;
+    };
+
+    void reset_(Tree *t_);
+    void resolve_();
+    void gather_anchors_and_refs_();
+    void gather_anchors_and_refs__(id_type n);
+    id_type count_anchors_and_refs_(id_type n);
+
+    id_type lookup_(RefData const* C4_RESTRICT ra);
+
+    Tree *C4_RESTRICT m_tree;
+    /** We're using this stack purely as an array. */
+    detail::stack<RefData> m_refs;
+
+    /** @endcond */
+};
+
+/** @} */
+
+} // namespace ryml
+} // namespace c4
+
+
+#endif // _C4_YML_REFERENCE_RESOLVER_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.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_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
+
+namespace c4 {
+namespace yml {
+
+class Tree;
+class NodeRef;
+template<class EventHandler> class ParseEngine;
+struct EventHandlerTree;
+RYML_EXPORT id_type estimate_tree_capacity(csubstr src); // NOLINT
+
+
+/** @addtogroup doc_parse
+ * @{ */
+
+/** This is the main ryml parser, where the parser events are handled
+ * to create a ryml tree.
+ *
+ * @warning This class cannot parse YAML where there are container
+ * keys. This is not a limitation of the @ref ParseEngine, but of the
+ * @ref EventHandlerTree, which is present because the @ref Tree does
+ * not accept containers as keys. However, the @ref ParseEngine *can*
+ * parse container keys; consult its documentation for more details.
+ *
+ * @see ParserOptions
+ * @see ParseEngine
+ * @see EventHandlerTree
+ * */
+using Parser = RYML_EXPORT ParseEngine<EventHandlerTree>;
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_parse_in_place__with_existing_parser Parse in place with existing parser
+ *
+ * @brief parse a mutable YAML source buffer (re)using an existing
+ * parser. Scalars requiring filtering are mutated in place (except in
+ * the rare cases where the filtered scalar is longer than the
+ * original scalar, or where filtering was disabled before the
+ * call). These overloads accept an existing parser object, and
+ * provide the opportunity to use special parser options.
+ *
+ * @see ParserOptions
+ *
+ * @{
+ */
+
+// this is vertically aligned to highlight the parameter differences.
+
+RYML_EXPORT void parse_in_place(Parser *parser, csubstr filename, substr yaml, Tree *t, id_type node_id); /**< (1) parse YAML into an existing tree node.
+                                                                                                           *
+                                                                                                           * The filename will be used in any error messages
+                                                                                                           * arising during the parse. The callbacks in the
+                                                                                                           * tree are kept, and used to allocate
+                                                                                                           * the tree members, if any allocation is required. */
+RYML_EXPORT void parse_in_place(Parser *parser,                   substr yaml, Tree *t, id_type node_id); /**< (2) like (1) but no filename will be reported */
+RYML_EXPORT void parse_in_place(Parser *parser, csubstr filename, substr yaml, Tree *t                 ); /**< (3) parse YAML into the root node of an existing tree.
+                                                                                                           *
+                                                                                                           * The filename will be used in any error messages
+                                                                                                           * arising during the parse. The callbacks in the
+                                                                                                           * tree are kept, and used to allocate
+                                                                                                           * the tree members, if any allocation is required. */
+RYML_EXPORT void parse_in_place(Parser *parser,                   substr yaml, Tree *t                 ); /**< (4) like (3) but no filename will be reported */
+RYML_EXPORT void parse_in_place(Parser *parser, csubstr filename, substr yaml, NodeRef node            ); /**< (5) like (1) but the node is given as a NodeRef */
+RYML_EXPORT void parse_in_place(Parser *parser,                   substr yaml, NodeRef node            ); /**< (6) like (5) but no filename will be reported */
+RYML_EXPORT Tree parse_in_place(Parser *parser, csubstr filename, substr yaml                          ); /**< (7) create a new tree, and parse YAML into its root node.
+                                                                                                           *
+                                                                                                           * The filename will be used in any error messages
+                                                                                                           * arising during the parse. The tree is created with
+                                                                                                           * the callbacks currently in the parser.
+                                                                                                           */
+RYML_EXPORT Tree parse_in_place(Parser *parser,                   substr yaml                          ); /**< (8) like (7) but no filename will be reported */
+
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_json_in_place(Parser *parser, csubstr filename, substr json, Tree *t, id_type node_id); ///< (1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_json_in_place(Parser *parser,                   substr json, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_json_in_place(Parser *parser, csubstr filename, substr json, Tree *t                 ); ///< (3) parse JSON into an existing tree, into its root node.
+RYML_EXPORT void parse_json_in_place(Parser *parser,                   substr json, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_json_in_place(Parser *parser, csubstr filename, substr json, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_json_in_place(Parser *parser,                   substr json, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_json_in_place(Parser *parser, csubstr filename, substr json                          ); ///< (7) create a new tree, and parse JSON into its root node.
+RYML_EXPORT Tree parse_json_in_place(Parser *parser,                   substr json                          ); ///< (8) like (7) but no filename will be reported
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+/** @defgroup doc_parse_in_place___with_temporary_parser Parse in place with temporary parser
+ *
+ * @brief parse a mutable YAML source buffer. Scalars requiring
+ * filtering are mutated in place (except in the rare cases where the
+ * filtered scalar is longer than the original scalar).
+ *
+ * @note These freestanding functions use a temporary parser object,
+ * and are convenience functions to enable the user to easily parse
+ * YAML without the need to explicitly instantiate a parser and event
+ * handler. Note that some properties (notably node locations in the
+ * original source code) are only available through the parser
+ * class. If you need access to any of these properties, use
+ * the appropriate overload from @ref doc_parse_in_place__with_existing_parser
+ *
+ * @{
+ */
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_in_place(csubstr filename, substr yaml, Tree *t, id_type node_id); ///< (1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_in_place(                  substr yaml, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_in_place(csubstr filename, substr yaml, Tree *t                 ); ///< (3) parse YAML into an existing tree, into its root node.
+RYML_EXPORT void parse_in_place(                  substr yaml, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_in_place(csubstr filename, substr yaml, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_in_place(                  substr yaml, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_in_place(csubstr filename, substr yaml                          ); ///< (7) create a new tree, and parse YAML into its root node.
+RYML_EXPORT Tree parse_in_place(                  substr yaml                          ); ///< (8) like (7) but no filename will be reported
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_json_in_place(csubstr filename, substr json, Tree *t, id_type node_id); ///< (1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_json_in_place(                  substr json, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_json_in_place(csubstr filename, substr json, Tree *t                 ); ///< (3) parse JSON into an existing tree, into its root node.
+RYML_EXPORT void parse_json_in_place(                  substr json, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_json_in_place(csubstr filename, substr json, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_json_in_place(                  substr json, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_json_in_place(csubstr filename, substr json                          ); ///< (7) create a new tree, and parse JSON into its root node.
+RYML_EXPORT Tree parse_json_in_place(                  substr json                          ); ///< (8) like (7) but no filename will be reported
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_parse_in_arena__with_existing_parser Parse in arena with existing parser
+ *
+ * @brief parse a read-only (immutable) YAML source buffer. This is
+ * achieved by first copying the contents of the buffer to the tree's
+ * arena, and then calling @ref parse_in_arena() . All the resulting
+ * scalars will be filtered in the arena. These overloads accept an
+ * existing parser object, and provide the opportunity to use special
+ * parser options.
+ *
+ * @see ParserOptions
+ *
+ *
+ * @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 class. If you need access to any of
+ * these properties, use the appropriate overload from @ref
+ * doc_parse_in_arena__with_existing_parser
+ *
+ * @warning 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 (which is
+ * mutable) is implicitly convertible to csubstr (which is
+ * immutable). 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. To be clear:
+ * ```c++
+ * substr mutable_buffer = ...;
+ * parser.parse_in_arena(mutable_buffer); // linker error
+ *
+ * csubstr immutable_buffer = ...;
+ * parser.parse_in_arena(immutable_buffer); // ok
+ * ```
+ *
+ * @{
+ */
+
+#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, so that calling it "      \
+    "will cause a linker error."
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, Tree *t, id_type node_id); ///< (1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_in_arena(Parser *parser,                   csubstr yaml, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, Tree *t                 ); ///< (3) parse YAML into an existing tree, into its root node.
+RYML_EXPORT void parse_in_arena(Parser *parser,                   csubstr yaml, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_in_arena(Parser *parser,                   csubstr yaml, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_in_arena(Parser *parser, csubstr filename, csubstr yaml                          ); ///< (7) create a new tree, and parse YAML into its root node.
+RYML_EXPORT Tree parse_in_arena(Parser *parser,                   csubstr yaml                          ); ///< (8) like (7) but no filename will be reported
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, Tree *t, id_type node_id); ///< (1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_json_in_arena(Parser *parser,                   csubstr json, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, Tree *t                 ); ///< (3) parse JSON into an existing tree, into its root node.
+RYML_EXPORT void parse_json_in_arena(Parser *parser,                   csubstr json, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_json_in_arena(Parser *parser,                   csubstr json, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_json_in_arena(Parser *parser, csubstr filename, csubstr json                          ); ///< (7) create a new tree, and parse JSON into its root node.
+RYML_EXPORT Tree parse_json_in_arena(Parser *parser,                   csubstr json                          ); ///< (8) like (7) but no filename will be reported
+
+/* READ THE DEPRECATION NOTE!
+ *
+ * All of the functions below are intentionally left undefined, to
+ * prevent them being used.
+ *
+ */
+/** @cond dev */
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser,                   substr yaml, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser, csubstr filename, substr yaml, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser,                   substr yaml, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser, csubstr filename, substr yaml, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser,                   substr yaml, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(Parser *parser, csubstr filename, substr yaml, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_in_arena(Parser *parser,                   substr yaml                          );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_in_arena(Parser *parser, csubstr filename, substr yaml                          );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser,                   substr json, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser, csubstr filename, substr json, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser,                   substr json, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser, csubstr filename, substr json, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser,                   substr json, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(Parser *parser, csubstr filename, substr json, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_json_in_arena(Parser *parser,                   substr json                          );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_json_in_arena(Parser *parser, csubstr filename, substr json                          );
+/** @endcond */
+
+/** @} */
+
+
+//-----------------------------------------------------------------------------
+
+
+/** @defgroup doc_parse_in_arena__with_temporary_parser Parse in arena with temporary parser
+ *
+ * @brief parse a read-only (immutable) YAML source buffer. This is
+ * achieved by first copying the contents of the buffer to the tree's
+ * arena, and then calling @ref parse_in_arena() .
+ *
+ * @note These freestanding functions use a temporary parser object,
+ * and are convenience functions to easily one-off 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 class. If you need access to any
+ * of these properties, use the appropriate overload from @ref
+ * doc_parse_in_arena__with_existing_parser
+ *
+ * @warning 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 (which is
+ * mutable) is implicitly convertible to csubstr (which is
+ * immutable). 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. To be clear:
+ * ```c++
+ * substr mutable_buffer = ...;
+ * parser.parse_in_arena(mutable_buffer); // linker error
+ *
+ * csubstr immutable_buffer = ...;
+ * parser.parse_in_arena(immutable_buffer); // ok
+ * ```
+ *
+ * @{
+ */
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_in_arena(csubstr filename, csubstr yaml, Tree *t, id_type node_id); ///< (1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_in_arena(                  csubstr yaml, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_in_arena(csubstr filename, csubstr yaml, Tree *t                 ); ///< (3) parse YAML into an existing tree, into its root node.
+RYML_EXPORT void parse_in_arena(                  csubstr yaml, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_in_arena(csubstr filename, csubstr yaml, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_in_arena(                  csubstr yaml, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_in_arena(csubstr filename, csubstr yaml                          ); ///< (7) create a new tree, and parse YAML into its root node.
+RYML_EXPORT Tree parse_in_arena(                  csubstr yaml                          ); ///< (8) like (7) but no filename will be reported
+
+// this is vertically aligned to highlight the parameter differences.
+RYML_EXPORT void parse_json_in_arena(csubstr filename, csubstr json, Tree *t, id_type node_id); ///< (1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
+RYML_EXPORT void parse_json_in_arena(                  csubstr json, Tree *t, id_type node_id); ///< (2) like (1) but no filename will be reported
+RYML_EXPORT void parse_json_in_arena(csubstr filename, csubstr json, Tree *t                 ); ///< (3) parse JSON into an existing tree, into its root node.
+RYML_EXPORT void parse_json_in_arena(                  csubstr json, Tree *t                 ); ///< (4) like (3) but no filename will be reported
+RYML_EXPORT void parse_json_in_arena(csubstr filename, csubstr json, NodeRef node            ); ///< (5) like (1) but the node is given as a NodeRef
+RYML_EXPORT void parse_json_in_arena(                  csubstr json, NodeRef node            ); ///< (6) like (5) but no filename will be reported
+RYML_EXPORT Tree parse_json_in_arena(csubstr filename, csubstr json                          ); ///< (7) create a new tree, and parse JSON into its root node.
+RYML_EXPORT Tree parse_json_in_arena(                  csubstr json                          ); ///< (8) like (7) but no filename will be reported
+
+
+/* READ THE DEPRECATION NOTE!
+ *
+ * All of the functions below are intentionally left undefined, to
+ * prevent them being used.
+ */
+/** @cond dev */
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(                  substr yaml, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr yaml, Tree *t, id_type node_id);
+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, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_in_arena(csubstr filename, substr yaml, NodeRef node            );
+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_json_in_arena(                  substr json, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(csubstr filename, substr json, Tree *t, id_type node_id);
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(                  substr json, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(csubstr filename, substr json, Tree *t                 );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(                  substr json, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) void parse_json_in_arena(csubstr filename, substr json, NodeRef node            );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_json_in_arena(                  substr json                          );
+RYML_DEPRECATED(RYML_DONT_PARSE_SUBSTR_IN_ARENA) Tree parse_json_in_arena(csubstr filename, substr json                          );
+/** @endcond */
+
+/** @} */
+/** @} */
+
+} // namespace yml
+} // namespace c4
+
+#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& C4_RESTRICT p : m)
+    {
+        auto ch = n->append_child();
+        ch << c4::yml::key(p.first);
+        ch << p.second;
+    }
+}
+
+/** read the node members, assigning into the existing map. If a key
+ * is already present in the map, then its value will be
+ * move-assigned. */
+template<class K, class V, class Less, class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::map<K, V, Less, Alloc> * m)
+{
+    for(auto const& C4_RESTRICT ch : n)
+    {
+        K k{};
+        ch >> c4::yml::key(k);
+        ch >> (*m)[k];
+    }
+    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(V const& v : vec)
+        n->append_child() << v;
+}
+
+/** read the node members, overwriting existing vector entries. */
+template<class V, class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::vector<V, Alloc> *vec)
+{
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wuseless-cast")
+    vec->resize(static_cast<size_t>(n.num_children()));
+    C4_SUPPRESS_WARNING_GCC_POP
+    size_t pos = 0;
+    for(ConstNodeRef const child : n)
+        child >> (*vec)[pos++];
+    return true;
+}
+
+/** read the node members, overwriting existing vector entries.
+ * specialization: std::vector<bool> uses std::vector<bool>::reference as
+ * the return value of its operator[]. */
+template<class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::vector<bool, Alloc> *vec)
+{
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wuseless-cast")
+    vec->resize(static_cast<size_t>(n.num_children()));
+    C4_SUPPRESS_WARNING_GCC_POP
+    size_t pos = 0;
+    bool tmp = {};
+    for(ConstNodeRef const child : n)
+    {
+        child >> tmp;
+        (*vec)[pos++] = tmp;
+    }
+    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/version.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/version.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/version.hpp
+//#include "c4/yml/version.hpp"
+#if !defined(C4_YML_VERSION_HPP_) && !defined(_C4_YML_VERSION_HPP_)
+#error "amalgamate: file c4/yml/version.hpp must have been included at this point"
+#endif /* C4_YML_VERSION_HPP_ */
+
+
+namespace c4 {
+namespace yml {
+
+csubstr version()
+{
+  return RYML_VERSION;
+}
+
+int version_major()
+{
+  return RYML_VERSION_MAJOR;
+}
+
+int version_minor()
+{
+  return RYML_VERSION_MINOR;
+}
+
+int version_patch()
+{
+  return RYML_VERSION_PATCH;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/version.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// 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>
+#   ifdef RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS
+#       include <stdexcept>
+#   endif
+#endif // RYML_NO_DEFAULT_CALLBACKS
+
+
+namespace c4 {
+namespace yml {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4702/*unreachable code*/) // on the call to the unreachable macro
+
+namespace {
+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())
+        {
+            // this is more portable than using fprintf("%.*s:") which
+            // is not available in some embedded platforms
+            fwrite(loc.name.str, 1, loc.name.len, f); // NOLINT
+            fputc(':', f); // NOLINT
+        }
+        fprintf(f, "%zu:", loc.line); // NOLINT
+        if(loc.col)
+            fprintf(f, "%zu:", loc.col); // NOLINT
+        if(loc.offset)
+            fprintf(f, " (%zuB):", loc.offset); // NOLINT
+        fputc(' ', f); // NOLINT
+    }
+    RYML_ASSERT(!csubstr(msg, length).ends_with('\0'));
+    fwrite(msg, 1, length, f); // NOLINT
+    fputc('\n', f); // NOLINT
+    fflush(f); // NOLINT
+}
+
+[[noreturn]] void error_impl(const char* msg, size_t length, Location loc, void * /*user_data*/)
+{
+    RYML_ASSERT(!csubstr(msg, length).ends_with('\0'));
+    report_error_impl(msg, length, loc, nullptr);
+#ifdef RYML_DEFAULT_CALLBACK_USES_EXCEPTIONS
+    throw std::runtime_error(std::string(msg, length));
+#else
+    ::abort();
+#endif
+}
+
+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() noexcept
+    :
+    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
+{
+    RYML_CHECK(m_allocate);
+    RYML_CHECK(m_free);
+    RYML_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());
+}
+
+// the [[noreturn]] attribute needs to be here as well (UB otherwise)
+// https://en.cppreference.com/w/cpp/language/attributes/noreturn
+[[noreturn]] void error(Callbacks const& cb, const char *msg, size_t msg_len, Location loc)
+{
+    cb.m_error(msg, msg_len, loc, cb.m_user_data);
+    abort(); // call abort in case the error callback didn't interrupt execution
+    C4_UNREACHABLE();
+}
+
+// the [[noreturn]] attribute needs to be here as well (UB otherwise)
+// see https://en.cppreference.com/w/cpp/language/attributes/noreturn
+[[noreturn]] void error(const char *msg, size_t msg_len, Location loc)
+{
+    error(s_default_callbacks, msg, msg_len, loc);
+    C4_UNREACHABLE();
+}
+
+C4_SUPPRESS_WARNING_MSVC_POP
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/common.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/node_type.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.hpp
+//#include "c4/yml/node_type.hpp"
+#if !defined(C4_YML_NODE_TYPE_HPP_) && !defined(_C4_YML_NODE_TYPE_HPP_)
+#error "amalgamate: file c4/yml/node_type.hpp must have been included at this point"
+#endif /* C4_YML_NODE_TYPE_HPP_ */
+
+
+namespace c4 {
+namespace yml {
+
+const char* NodeType::type_str(NodeType_e ty) noexcept
+{
+    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)";
+    }
+}
+
+csubstr NodeType::type_str(substr buf, NodeType_e flags) noexcept
+{
+    size_t pos = 0;
+    bool gotone = false;
+
+    #define _prflag(fl, txt)                                    \
+    do {                                                        \
+        if((flags & (fl)) == (fl))                              \
+        {                                                       \
+            if(gotone)                                          \
+            {                                                   \
+                if(pos + 1 < buf.len)                           \
+                    buf[pos] = '|';                             \
+                ++pos;                                          \
+            }                                                   \
+            csubstr fltxt = txt;                                \
+            if(pos + fltxt.len <= buf.len)                      \
+                memcpy(buf.str + pos, fltxt.str, fltxt.len);    \
+            pos += fltxt.len;                                   \
+            gotone = true;                                      \
+            flags = (flags & ~(fl)); /*remove the flag*/        \
+        }                                                       \
+    } while(0)
+
+    _prflag(STREAM, "STREAM");
+    _prflag(DOC, "DOC");
+    // key properties
+    _prflag(KEY, "KEY");
+    _prflag(KEYNIL, "KNIL");
+    _prflag(KEYTAG, "KTAG");
+    _prflag(KEYANCH, "KANCH");
+    _prflag(KEYREF, "KREF");
+    _prflag(KEY_LITERAL, "KLITERAL");
+    _prflag(KEY_FOLDED, "KFOLDED");
+    _prflag(KEY_SQUO, "KSQUO");
+    _prflag(KEY_DQUO, "KDQUO");
+    _prflag(KEY_PLAIN, "KPLAIN");
+    _prflag(KEY_UNFILT, "KUNFILT");
+    // val properties
+    _prflag(VAL, "VAL");
+    _prflag(VALNIL, "VNIL");
+    _prflag(VALTAG, "VTAG");
+    _prflag(VALANCH, "VANCH");
+    _prflag(VALREF, "VREF");
+    _prflag(VAL_UNFILT, "VUNFILT");
+    _prflag(VAL_LITERAL, "VLITERAL");
+    _prflag(VAL_FOLDED, "VFOLDED");
+    _prflag(VAL_SQUO, "VSQUO");
+    _prflag(VAL_DQUO, "VDQUO");
+    _prflag(VAL_PLAIN, "VPLAIN");
+    _prflag(VAL_UNFILT, "VUNFILT");
+    // container properties
+    _prflag(MAP, "MAP");
+    _prflag(SEQ, "SEQ");
+    _prflag(FLOW_SL, "FLOWSL");
+    _prflag(FLOW_ML, "FLOWML");
+    _prflag(BLOCK, "BLCK");
+    if(pos == 0)
+        _prflag(NOTYPE, "NOTYPE");
+
+    #undef _prflag
+
+    if(pos < buf.len)
+    {
+        buf[pos] = '\0';
+        return buf.first(pos);
+    }
+    else
+    {
+        csubstr failed;
+        failed.len = pos + 1;
+        failed.str = nullptr;
+        return failed;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+// see https://www.yaml.info/learn/quote.html#noplain
+bool scalar_style_query_squo(csubstr s) noexcept
+{
+    return ! s.first_of_any("\n ", "\n\t");
+}
+
+// see https://www.yaml.info/learn/quote.html#noplain
+bool scalar_style_query_plain(csubstr s) noexcept
+{
+    if(s.begins_with("-."))
+    {
+        if(s == "-.inf" || s == "-.INF")
+            return true;
+        else if(s.sub(2).is_number())
+            return true;
+    }
+    else if(s.begins_with_any("0123456789.-+") && s.is_number())
+    {
+        return true;
+    }
+    return s != ':'
+        && ( ! s.begins_with_any("-:?*&,'\"{}[]|>%#@`\r")) // @ and ` are reserved characters
+        && ( ! s.ends_with_any(":#"))
+             // make this check in the last place, as it has linear
+             // complexity, while the previous ones are
+             // constant-time
+        && (s.first_of("\n#:[]{},") == npos);
+}
+
+NodeType_e scalar_style_choose(csubstr s) noexcept
+{
+    if(s.len)
+    {
+        if(s.begins_with_any(" \n\t")
+           ||
+           s.ends_with_any(" \n\t"))
+        {
+            return SCALAR_DQUO;
+        }
+        else if( ! scalar_style_query_plain(s))
+        {
+            return scalar_style_query_squo(s) ? SCALAR_SQUO : SCALAR_DQUO;
+        }
+        // nothing remarkable - use plain
+        return SCALAR_PLAIN;
+    }
+    return s.str ? SCALAR_SQUO : SCALAR_PLAIN;
+}
+
+NodeType_e scalar_style_json_choose(csubstr s) noexcept
+{
+    // do not quote special cases
+    bool plain = (
+        (s == "true" || s == "false" || s == "null")
+        ||
+        (
+            // do not quote numbers
+            s.is_number()
+            &&
+            (
+                // quote integral numbers if they have a leading 0
+                // https://github.com/biojppm/rapidyaml/issues/291
+                (!(s.len > 1 && s.begins_with('0')))
+                // do not quote reals with leading 0
+                // https://github.com/biojppm/rapidyaml/issues/313
+                || (s.find('.') != csubstr::npos)
+            )
+        )
+    );
+    return plain ? SCALAR_PLAIN : SCALAR_DQUO;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/node_type.cpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/tag.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tag.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tag.hpp
+//#include "c4/yml/tag.hpp"
+#if !defined(C4_YML_TAG_HPP_) && !defined(_C4_YML_TAG_HPP_)
+#error "amalgamate: file c4/yml/tag.hpp must have been included at this point"
+#endif /* C4_YML_TAG_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/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_ */
+
+
+
+namespace c4 {
+namespace yml {
+
+bool is_custom_tag(csubstr tag)
+{
+    if((tag.len > 2) && (tag.str[0] == '!'))
+    {
+        size_t pos = tag.find('!', 1);
+        return pos != npos && pos > 1 && tag.str[1] != '<';
+    }
+    return false;
+}
+
+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;
+}
+
+csubstr normalize_tag_long(csubstr tag, substr output)
+{
+    csubstr result = normalize_tag_long(tag);
+    if(result.begins_with("!!"))
+    {
+        tag = tag.sub(2);
+        const csubstr pfx = "<tag:yaml.org,2002:";
+        const size_t len = pfx.len + tag.len + 1;
+        if(len <= output.len)
+        {
+            memcpy(output.str          , pfx.str, pfx.len);
+            memcpy(output.str + pfx.len, tag.str, tag.len);
+            output[pfx.len + tag.len] = '>';
+            result = output.first(len);
+        }
+        else
+        {
+            result.str = nullptr;
+            result.len = len;
+        }
+    }
+    return result;
+}
+
+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;
+    else if(tag == "yaml")
+        return TAG_YAML;
+
+    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:
+    default:
+        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:
+    default:
+        return {""};
+    }
+}
+
+
+bool TagDirective::create_from_str(csubstr directive_)
+{
+    csubstr directive = directive_;
+    directive = directive.sub(4);
+    if(!directive.begins_with(' '))
+        return false;
+    directive = directive.triml(' ');
+    size_t pos = directive.find(' ');
+    if(pos == npos)
+        return false;
+    handle = directive.first(pos);
+    directive = directive.sub(handle.len).triml(' ');
+    pos = directive.find(' ');
+    if(pos != npos)
+        directive = directive.first(pos);
+    prefix = directive;
+    next_node_id = NONE;
+    _c4dbgpf("%TAG: handle={} prefix={}", handle, prefix);
+    return true;
+}
+
+bool TagDirective::create_from_str(csubstr directive_, Tree *tree)
+{
+    _RYML_CB_CHECK(tree->callbacks(), directive_.begins_with("%TAG "));
+    if(!create_from_str(directive_))
+    {
+        _RYML_CB_ERR(tree->callbacks(), "invalid tag directive");
+    }
+    next_node_id = tree->size();
+    if(!tree->empty())
+    {
+        const id_type prev = tree->size() - 1;
+        if(tree->is_root(prev) && tree->type(prev) != NOTYPE && !tree->is_stream(prev))
+            ++next_node_id;
+    }
+    _c4dbgpf("%TAG: handle={} prefix={} next_node={}", handle, prefix, next_node_id);
+    return true;
+}
+
+size_t TagDirective::transform(csubstr tag, substr output, Callbacks const& callbacks) const
+{
+    _c4dbgpf("%TAG: handle={} prefix={} next_node={}. tag={}", handle, prefix, next_node_id, tag);
+    _RYML_CB_ASSERT(callbacks, tag.len >= handle.len);
+    csubstr rest = tag.sub(handle.len);
+    _c4dbgpf("%TAG: rest={}", rest);
+    if(rest.begins_with('<'))
+    {
+        _c4dbgpf("%TAG: begins with <. rest={}", rest);
+        if(C4_UNLIKELY(!rest.ends_with('>')))
+            _RYML_CB_ERR(callbacks, "malformed tag");
+        rest = rest.offs(1, 1);
+        if(rest.begins_with(prefix))
+        {
+            _c4dbgpf("%TAG: already transformed! actual={}", rest.sub(prefix.len));
+            return 0; // return 0 to signal that the tag is local and cannot be resolved
+        }
+    }
+    size_t len = 1u + prefix.len + rest.len + 1u;
+    size_t numpc = rest.count('%');
+    if(numpc == 0)
+    {
+        if(len <= output.len)
+        {
+            output.str[0] = '<';
+            memcpy(1u + output.str, prefix.str, prefix.len);
+            memcpy(1u + output.str + prefix.len, rest.str, rest.len);
+            output.str[1u + prefix.len + rest.len] = '>';
+        }
+    }
+    else
+    {
+        // need to decode URI % sequences
+        size_t pos = rest.find('%');
+        _RYML_CB_ASSERT(callbacks, pos != npos);
+        do {
+            size_t next = rest.first_not_of("0123456789abcdefABCDEF", pos+1);
+            if(next == npos)
+                next = rest.len;
+            _RYML_CB_CHECK(callbacks, pos+1 < next);
+            _RYML_CB_CHECK(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(prefix);
+            pos = rest.find('%');
+            _RYML_CB_ASSERT(callbacks, pos != npos);
+            do {
+                size_t next = rest.first_not_of("0123456789abcdefABCDEF", pos+1);
+                if(next == npos)
+                    next = rest.len;
+                _RYML_CB_CHECK(callbacks, pos+1 < next);
+                _RYML_CB_CHECK(callbacks, pos+1 + 2 <= next);
+                uint8_t val;
+                if(C4_UNLIKELY(!read_hex(rest.range(pos+1, next), &val) || val > 127))
+                    _RYML_CB_ERR(callbacks, "invalid URI character");
+                appendstr(rest.range(prev, pos));
+                appendchar(static_cast<char>(val));
+                prev = next;
+                pos = rest.find('%', pos+1);
+            } while(pos != npos);
+            _RYML_CB_ASSERT(callbacks, pos == npos);
+            _RYML_CB_ASSERT(callbacks, prev > 0);
+            _RYML_CB_ASSERT(callbacks, rest.len >= prev);
+            appendstr(rest.sub(prev));
+            appendchar('>');
+            _RYML_CB_ASSERT(callbacks, wpos == len);
+        }
+    }
+    return len;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/tag.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/reference_resolver.hpp
+//#include "c4/yml/reference_resolver.hpp"
+#if !defined(C4_YML_REFERENCE_RESOLVER_HPP_) && !defined(_C4_YML_REFERENCE_RESOLVER_HPP_)
+#error "amalgamate: file c4/yml/reference_resolver.hpp must have been included at this point"
+#endif /* C4_YML_REFERENCE_RESOLVER_HPP_ */
+
+
+
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4296/*expression is always 'boolean_value'*/)
+C4_SUPPRESS_WARNING_MSVC(4702/*unreachable code*/)
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+C4_SUPPRESS_WARNING_GCC("-Wtype-limits")
+C4_SUPPRESS_WARNING_GCC("-Wuseless-cast")
+
+namespace c4 {
+namespace yml {
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+NodeRef Tree::rootref()
+{
+    return NodeRef(this, root_id());
+}
+ConstNodeRef Tree::rootref() const
+{
+    return ConstNodeRef(this, root_id());
+}
+
+ConstNodeRef Tree::crootref() const
+{
+    return ConstNodeRef(this, root_id());
+}
+
+NodeRef Tree::ref(id_type id)
+{
+    _RYML_CB_ASSERT(m_callbacks, id != NONE && id >= 0 && id < m_cap);
+    return NodeRef(this, id);
+}
+ConstNodeRef Tree::ref(id_type id) const
+{
+    _RYML_CB_ASSERT(m_callbacks, id != NONE && id >= 0 && id < m_cap);
+    return ConstNodeRef(this, id);
+}
+ConstNodeRef Tree::cref(id_type id) const
+{
+    _RYML_CB_ASSERT(m_callbacks, id != NONE && id >= 0 && id < m_cap);
+    return ConstNodeRef(this, id);
+}
+
+NodeRef Tree::operator[] (csubstr key)
+{
+    return rootref()[key];
+}
+ConstNodeRef Tree::operator[] (csubstr key) const
+{
+    return rootref()[key];
+}
+
+NodeRef Tree::operator[] (id_type i)
+{
+    return rootref()[i];
+}
+ConstNodeRef Tree::operator[] (id_type i) const
+{
+    return rootref()[i];
+}
+
+NodeRef Tree::docref(id_type i)
+{
+    return ref(doc(i));
+}
+ConstNodeRef Tree::docref(id_type i) const
+{
+    return cref(doc(i));
+}
+ConstNodeRef Tree::cdocref(id_type i) const
+{
+    return cref(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)
+    , m_tag_directives()
+{
+}
+
+Tree::Tree(id_type 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) : Tree(that.m_callbacks)
+{
+    _copy(that);
+}
+
+Tree& Tree::operator= (Tree const& that)
+{
+    if(&that != this)
+    {
+        _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
+{
+    if(&that != this)
+    {
+        _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, (size_t)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(id_type 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);
+    if(that.m_cap)
+    {
+        m_buf = _RYML_CB_ALLOC_HINT(m_callbacks, NodeData, (size_t)that.m_cap, that.m_buf);
+        memcpy(m_buf, that.m_buf, (size_t)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(id_type i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = that.m_tag_directives[i];
+}
+
+void Tree::_move(Tree & that) noexcept
+{
+    _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(id_type 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);
+    if(m_arena_pos)
+        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(id_type cap)
+{
+    if(cap > m_cap)
+    {
+        NodeData *buf = _RYML_CB_ALLOC_HINT(m_callbacks, NodeData, (size_t)cap, m_buf);
+        if(m_buf)
+        {
+            memcpy(buf, m_buf, (size_t)m_cap * sizeof(NodeData));
+            _RYML_CB_FREE(m_callbacks, m_buf, NodeData, (size_t)m_cap);
+        }
+        id_type 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(id_type i = 0; i < RYML_MAX_TAG_DIRECTIVES; ++i)
+        m_tag_directives[i] = {};
+}
+
+void Tree::_claim_root()
+{
+    id_type r = _claim();
+    _RYML_CB_ASSERT(m_callbacks, r == 0);
+    _set_hierarchy(r, NONE, NONE);
+}
+
+
+//-----------------------------------------------------------------------------
+void Tree::_clear_range(id_type first, id_type 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, (size_t)num * sizeof(NodeData)); // TODO we should not need this
+    for(id_type 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(id_type 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(id_type 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(id_type i)
+{
+    if(m_free_head == i)
+        m_free_head = _p(i)->m_next_sibling;
+    _rem_hierarchy(i);
+}
+
+//-----------------------------------------------------------------------------
+id_type Tree::_claim()
+{
+    if(m_free_head == NONE || m_buf == nullptr)
+    {
+        id_type 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);
+
+    id_type 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__)
+#if (__GNUC__ >= 6)
+C4_SUPPRESS_WARNING_GCC("-Wnull-dereference")
+#endif
+#if (__GNUC__ > 9)
+C4_SUPPRESS_WARNING_GCC("-Wanalyzer-fd-leak")
+#endif
+#endif
+
+void Tree::_set_hierarchy(id_type ichild, id_type iparent, id_type iprev_sibling)
+{
+    _RYML_CB_ASSERT(m_callbacks, ichild >= 0 && ichild < m_cap);
+    _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 = _p(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;
+
+    id_type 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(id_type 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;
+    }
+}
+
+//-----------------------------------------------------------------------------
+/** @cond dev */
+id_type Tree::_do_reorder(id_type *node, id_type 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(id_type 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;
+}
+/** @endcond */
+
+void Tree::reorder()
+{
+    id_type r = root_id();
+    _do_reorder(&r, 0);
+}
+
+
+//-----------------------------------------------------------------------------
+/** @cond dev */
+void Tree::_swap(id_type n_, id_type 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(id_type ia, id_type ib)
+{
+    if(ia == ib) return;
+
+    for(id_type i = first_child(ia); i != NONE; i = next_sibling(i))
+    {
+        if(i == ib || i == ia)
+            continue;
+        _p(i)->m_parent = ib;
+    }
+
+    for(id_type 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;
+            }
+            id_type 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;
+            }
+            id_type 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(id_type dst_, id_type src_)
+{
+    auto const& C4_RESTRICT src = *_p(src_);
+    auto      & C4_RESTRICT dst = *_p(dst_);
+    auto      & C4_RESTRICT prt = *_p(src.m_parent);
+    for(id_type 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(id_type n_, id_type 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);
+}
+/** @endcond */
+
+//-----------------------------------------------------------------------------
+void Tree::move(id_type node, id_type after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, node != after);
+    _RYML_CB_ASSERT(m_callbacks,  ! is_root(node));
+    _RYML_CB_ASSERT(m_callbacks, (after == NONE) || (has_sibling(node, after) && has_sibling(after, node)));
+
+    _rem_hierarchy(node);
+    _set_hierarchy(node, parent(node), after);
+}
+
+//-----------------------------------------------------------------------------
+
+void Tree::move(id_type node, id_type new_parent, id_type after)
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, node != after);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != node);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != after);
+    _RYML_CB_ASSERT(m_callbacks,  ! is_root(node));
+
+    _rem_hierarchy(node);
+    _set_hierarchy(node, new_parent, after);
+}
+
+id_type Tree::move(Tree *src, id_type node, id_type new_parent, id_type after)
+{
+    _RYML_CB_ASSERT(m_callbacks, src != nullptr);
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != NONE);
+    _RYML_CB_ASSERT(m_callbacks, new_parent != after);
+
+    id_type dup = duplicate(src, node, new_parent, after);
+    src->remove(node);
+    return dup;
+}
+
+void Tree::set_root_as_stream()
+{
+    id_type 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);
+            id_type 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));
+    id_type next_doc = append_child(root);
+    _copy_props_wo_key(next_doc, root);
+    _add_flags(next_doc, DOC);
+    for(id_type 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(id_type node)
+{
+    _RYML_CB_ASSERT(m_callbacks, get(node) != nullptr);
+    id_type ich = get(node)->m_first_child;
+    while(ich != NONE)
+    {
+        remove_children(ich);
+        _RYML_CB_ASSERT(m_callbacks, get(ich) != nullptr);
+        id_type next = get(ich)->m_next_sibling;
+        _release(ich);
+        if(ich == get(node)->m_last_child)
+            break;
+        ich = next;
+    }
+}
+
+bool Tree::change_type(id_type 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;
+}
+
+
+//-----------------------------------------------------------------------------
+id_type Tree::duplicate(id_type node, id_type parent, id_type after)
+{
+    return duplicate(this, node, parent, after);
+}
+
+id_type Tree::duplicate(Tree const* src, id_type node, id_type parent, id_type 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));
+
+    id_type copy = _claim();
+
+    _copy_props(copy, src, node);
+    _set_hierarchy(copy, parent, after);
+    duplicate_children(src, node, copy, NONE);
+
+    return copy;
+}
+
+//-----------------------------------------------------------------------------
+id_type Tree::duplicate_children(id_type node, id_type parent, id_type after)
+{
+    return duplicate_children(this, node, parent, after);
+}
+
+id_type Tree::duplicate_children(Tree const* src, id_type node, id_type parent, id_type 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));
+
+    id_type prev = after;
+    for(id_type i = src->first_child(node); i != NONE; i = src->next_sibling(i))
+    {
+        prev = duplicate(src, i, parent, prev);
+    }
+
+    return prev;
+}
+
+//-----------------------------------------------------------------------------
+void Tree::duplicate_contents(id_type node, id_type where)
+{
+    duplicate_contents(this, node, where);
+}
+
+void Tree::duplicate_contents(Tree const *src, id_type node, id_type 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));
+}
+
+//-----------------------------------------------------------------------------
+id_type Tree::duplicate_children_no_rep(id_type node, id_type parent, id_type after)
+{
+    return duplicate_children_no_rep(this, node, parent, after);
+}
+
+id_type Tree::duplicate_children_no_rep(Tree const *src, id_type node, id_type parent, id_type 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
+    id_type after_pos = NONE;
+    if(after != NONE)
+    {
+        for(id_type 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...
+    id_type prev = after;
+    for(id_type i = src->first_child(node); i != NONE; i = src->next_sibling(i))
+    {
+        _c4dbgpf("duplicate_no_rep: {} -> {}/{}", i, parent, prev);
+        _RYML_CB_CHECK(m_callbacks, this != src || (parent != i && !is_ancestor(parent, i)));
+        if(is_seq(parent))
+        {
+            _c4dbgpf("duplicate_no_rep: {} is seq", parent);
+            prev = duplicate(src, i, parent, prev);
+        }
+        else
+        {
+            _c4dbgpf("duplicate_no_rep: {} is map", parent);
+            _RYML_CB_ASSERT(m_callbacks, is_map(parent));
+            // does the parent already have a node with key equal to that of the current duplicate?
+            id_type dstnode_dup = NONE, dstnode_dup_pos = NONE;
+            {
+                csubstr srckey = src->key(i);
+                for(id_type j = first_child(parent), jcount = 0; j != NONE; ++jcount, j = next_sibling(j))
+                {
+                    if(key(j) == srckey)
+                    {
+                        _c4dbgpf("duplicate_no_rep: found matching key '{}' src={}/{} dst={}/{}", srckey, node, i, parent, j);
+                        dstnode_dup = j;
+                        dstnode_dup_pos = jcount;
+                        break;
+                    }
+                }
+            }
+            _c4dbgpf("duplicate_no_rep: dstnode_dup={} dstnode_dup_pos={} after_pos={}", dstnode_dup, dstnode_dup_pos, after_pos);
+            if(dstnode_dup == NONE) // there is no repetition; just duplicate
+            {
+                _c4dbgpf("duplicate_no_rep: no repetition, just duplicate i={} parent={} prev={}", i, parent, prev);
+                prev = duplicate(src, i, parent, prev);
+            }
+            else  // yes, there is a repetition
+            {
+                if(after_pos != NONE && dstnode_dup_pos <= after_pos)
+                {
+                    // the dst duplicate is located before the node which will be inserted,
+                    // and will be overridden by the duplicate. So replace it.
+                    _c4dbgpf("duplicate_no_dstnode_dup: replace {}/{} with {}/{}", parent, dstnode_dup, node, i);
+                    if(prev == dstnode_dup)
+                        prev = prev_sibling(dstnode_dup);
+                    remove(dstnode_dup);
+                    prev = duplicate(src, i, parent, prev);
+                }
+                else if(prev == NONE)
+                {
+                    _c4dbgpf("duplicate_no_dstnode_dup: {}=prev <- {}", prev, dstnode_dup);
+                    // first iteration with prev = after = NONE and dstnode_dupetition
+                    prev = dstnode_dup;
+                }
+                else if(dstnode_dup != prev)
+                {
+                    // dstnode_dup is located after the node which will be inserted
+                    // and overrides it. So move the dstnode_dup into this node's place.
+                    _c4dbgpf("duplicate_no_dstnode_dup: move({}, {})", dstnode_dup, prev);
+                    move(dstnode_dup, prev);
+                    prev = dstnode_dup;
+                }
+            } // there's a dstnode_dupetition
+        }
+    }
+
+    return prev;
+}
+
+
+//-----------------------------------------------------------------------------
+
+void Tree::merge_with(Tree const *src, id_type src_node, id_type 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))
+    {
+        type_bits mask_src = ~STYLE; // keep the existing style if it is already a val
+        if( ! has_val(dst_node))
+        {
+            if(has_children(dst_node))
+                remove_children(dst_node);
+            mask_src |= VAL_STYLE; // copy the src style
+        }
+        if(src->is_keyval(src_node))
+        {
+            _copy_props(dst_node, src, src_node, mask_src);
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_callbacks, src->is_val(src_node));
+            _copy_props_wo_key(dst_node, src, src_node, mask_src);
+        }
+    }
+    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);
+            _p(dst_node)->m_type = src->_p(src_node)->m_type;
+        }
+        for(id_type sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
+        {
+            id_type dch = append_child(dst_node);
+            _copy_props_wo_key(dch, src, sch);
+            merge_with(src, sch, dch);
+        }
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_callbacks, 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);
+            _p(dst_node)->m_type = src->_p(src_node)->m_type;
+        }
+        for(id_type sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
+        {
+            id_type 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);
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+void Tree::resolve(bool clear_anchors)
+{
+    if(m_size == 0)
+        return;
+    ReferenceResolver rr;
+    resolve(&rr, clear_anchors);
+}
+
+void Tree::resolve(ReferenceResolver *C4_RESTRICT rr, bool clear_anchors)
+{
+    if(m_size == 0)
+        return;
+    rr->resolve(this, clear_anchors);
+}
+
+
+//-----------------------------------------------------------------------------
+
+id_type Tree::num_children(id_type node) const
+{
+    id_type count = 0;
+    for(id_type i = first_child(node); i != NONE; i = next_sibling(i))
+        ++count;
+    return count;
+}
+
+id_type Tree::child(id_type node, id_type pos) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    id_type count = 0;
+    for(id_type i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        if(count++ == pos)
+            return i;
+    }
+    return NONE;
+}
+
+id_type Tree::child_pos(id_type node, id_type ch) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    id_type count = 0;
+    for(id_type i = first_child(node); i != NONE; i = next_sibling(i))
+    {
+        if(i == ch)
+            return count;
+        ++count;
+    }
+    return NONE;
+}
+
+#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
+#   if __GNUC__ > 9
+#       pragma GCC diagnostic ignored "-Wanalyzer-null-dereference"
+#   endif
+#endif
+
+id_type Tree::find_child(id_type 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(id_type 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
+
+namespace {
+id_type depth_desc_(Tree const& C4_RESTRICT t, id_type id, id_type currdepth=0, id_type maxdepth=0)
+{
+    maxdepth = currdepth > maxdepth ? currdepth : maxdepth;
+    for(id_type child = t.first_child(id); child != NONE; child = t.next_sibling(child))
+    {
+        const id_type d = depth_desc_(t, child, currdepth+1, maxdepth);
+        maxdepth = d > maxdepth ? d : maxdepth;
+    }
+    return maxdepth;
+}
+}
+
+id_type Tree::depth_desc(id_type node) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    return depth_desc_(*this, node);
+}
+
+id_type Tree::depth_asc(id_type node) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    id_type depth = 0;
+    while(!is_root(node))
+    {
+        ++depth;
+        node = parent(node);
+    }
+    return depth;
+}
+
+bool Tree::is_ancestor(id_type node, id_type ancestor) const
+{
+    _RYML_CB_ASSERT(m_callbacks, node != NONE);
+    id_type p = parent(node);
+    while(p != NONE)
+    {
+        if(p == ancestor)
+            return true;
+        p = parent(p);
+    }
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+
+void Tree::to_val(id_type 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(id_type 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(id_type 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(id_type 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(id_type 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(id_type 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(id_type 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(id_type 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();
+}
+
+
+//-----------------------------------------------------------------------------
+id_type Tree::num_tag_directives() const
+{
+    // this assumes we have a very small number of tag directives
+    for(id_type 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 = {};
+}
+
+id_type 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_CHECK(m_callbacks, td.handle.begins_with('!'));
+    _RYML_CB_CHECK(m_callbacks, td.handle.ends_with('!'));
+    // https://yaml.org/spec/1.2.2/#rule-ns-word-char
+    _RYML_CB_CHECK(m_callbacks, td.handle == '!' || td.handle == "!!" || td.handle.trim('!').first_not_of("01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-") == npos);
+    id_type pos = num_tag_directives();
+    _RYML_CB_CHECK(m_callbacks, pos < RYML_MAX_TAG_DIRECTIVES);
+    m_tag_directives[pos] = td;
+    return pos;
+}
+
+bool Tree::add_tag_directive(csubstr directive_)
+{
+    TagDirective td;
+    if(td.create_from_str(directive_, this))
+    {
+        add_tag_directive(td);
+        return true;
+    }
+    return false;
+}
+
+size_t Tree::resolve_tag(substr output, csubstr tag, id_type 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(id_type i = RYML_MAX_TAG_DIRECTIVES-1; i != (id_type)-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)
+            return td.transform(tag, output, m_callbacks);
+    }
+    if(tag.begins_with('!'))
+    {
+        if(is_custom_tag(tag))
+        {
+            _RYML_CB_ERR(m_callbacks, "tag directive not found");
+        }
+    }
+    return 0; // return 0 to signal that the tag is local and cannot be resolved
+}
+
+namespace {
+csubstr _transform_tag(Tree *t, csubstr tag, id_type node)
+{
+    _c4dbgpf("[{}] resolving tag ~~~{}~~~", node, tag);
+    size_t required_size = t->resolve_tag(substr{}, tag, node);
+    if(!required_size)
+    {
+        if(tag.begins_with("!<"))
+            tag = tag.sub(1);
+        _c4dbgpf("[{}] resolved tag: ~~~{}~~~", node, tag);
+        return tag;
+    }
+    const char *prev_arena = t->arena().str;(void)prev_arena;
+    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);
+    _c4dbgpf("[{}] resolved tag: ~~~{}~~~", node, buf.first(actual_size));
+    return buf.first(actual_size);
+}
+void _resolve_tags(Tree *t, id_type node)
+{
+    NodeData *C4_RESTRICT d = t->_p(node);
+    if(d->m_type & KEYTAG)
+        d->m_key.tag = _transform_tag(t, d->m_key.tag, node);
+    if(d->m_type & VALTAG)
+        d->m_val.tag = _transform_tag(t, d->m_val.tag, node);
+    for(id_type child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+        _resolve_tags(t, child);
+}
+size_t _count_resolved_tags_size(Tree const* t, id_type node)
+{
+    size_t sz = 0;
+    NodeData const* C4_RESTRICT d = t->_p(node);
+    if(d->m_type & KEYTAG)
+        sz += t->resolve_tag(substr{}, d->m_key.tag, node);
+    if(d->m_type & VALTAG)
+        sz += t->resolve_tag(substr{}, d->m_val.tag, node);
+    for(id_type child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+        sz += _count_resolved_tags_size(t, child);
+    return sz;
+}
+void _normalize_tags(Tree *t, id_type node)
+{
+    NodeData *C4_RESTRICT d = t->_p(node);
+    if(d->m_type & KEYTAG)
+        d->m_key.tag = normalize_tag(d->m_key.tag);
+    if(d->m_type & VALTAG)
+        d->m_val.tag = normalize_tag(d->m_val.tag);
+    for(id_type child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+        _normalize_tags(t, child);
+}
+void _normalize_tags_long(Tree *t, id_type node)
+{
+    NodeData *C4_RESTRICT d = t->_p(node);
+    if(d->m_type & KEYTAG)
+        d->m_key.tag = normalize_tag_long(d->m_key.tag);
+    if(d->m_type & VALTAG)
+        d->m_val.tag = normalize_tag_long(d->m_val.tag);
+    for(id_type child = t->first_child(node); child != NONE; child = t->next_sibling(child))
+        _normalize_tags_long(t, child);
+}
+} // namespace
+
+void Tree::resolve_tags()
+{
+    if(empty())
+        return;
+    size_t needed_size = _count_resolved_tags_size(this, root_id());
+    if(needed_size)
+        reserve_arena(arena_size() + needed_size);
+    _resolve_tags(this, root_id());
+}
+
+void Tree::normalize_tags()
+{
+    if(empty())
+        return;
+    _normalize_tags(this, root_id());
+}
+
+void Tree::normalize_tags_long()
+{
+    if(empty())
+        return;
+    _normalize_tags_long(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)
+{
+    r->path_pos += more;
+    if(r->path.sub(r->path_pos).begins_with('.'))
+        ++r->path_pos;
+}
+
+Tree::lookup_result Tree::lookup_path(csubstr path, id_type 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;
+}
+
+id_type Tree::lookup_path_or_modify(csubstr default_value, csubstr path, id_type start)
+{
+    id_type 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;
+}
+
+id_type Tree::lookup_path_or_modify(Tree const *src, id_type src_node, csubstr path, id_type start)
+{
+    id_type target = _lookup_path_or_create(path, start);
+    merge_with(src, src_node, target);
+    return target;
+}
+
+id_type Tree::_lookup_path_or_create(csubstr path, id_type 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)};
+    id_type 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)};
+    id_type 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);
+}
+
+id_type Tree::_next_node(lookup_result * r, _lookup_path_token *parent) const
+{
+    _lookup_path_token token = _next_token(r, *parent);
+    if( ! token)
+        return NONE;
+
+    id_type 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(' ');
+        id_type 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;
+}
+
+id_type Tree::_next_node_modify(lookup_result * r, _lookup_path_token *parent)
+{
+    _lookup_path_token token = _next_token(r, *parent);
+    if( ! token)
+        return NONE;
+
+    id_type 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
+            {
+                id_type 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(' ');
+        id_type 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(id_type 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 yml
+} // namespace c4
+
+
+C4_SUPPRESS_WARNING_GCC_CLANG_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_engine.def.hpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.def.hpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifndef _C4_YML_PARSE_ENGINE_DEF_HPP_
+#define _C4_YML_PARSE_ENGINE_DEF_HPP_
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.hpp
+//#include "c4/yml/parse_engine.hpp"
+#if !defined(C4_YML_PARSE_ENGINE_HPP_) && !defined(_C4_YML_PARSE_ENGINE_HPP_)
+#error "amalgamate: file c4/yml/parse_engine.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_ENGINE_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/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/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_ */
+
+
+//included above:
+//#include <ctype.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_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/filter_processor.hpp
+//#include "c4/yml/filter_processor.hpp"
+#if !defined(C4_YML_FILTER_PROCESSOR_HPP_) && !defined(_C4_YML_FILTER_PROCESSOR_HPP_)
+#error "amalgamate: file c4/yml/filter_processor.hpp must have been included at this point"
+#endif /* C4_YML_FILTER_PROCESSOR_HPP_ */
+
+#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_ */
+
+// 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
+
+
+#if defined(RYML_WITH_TAB_TOKENS)
+#define _RYML_WITH_TAB_TOKENS(...) __VA_ARGS__
+#define _RYML_WITHOUT_TAB_TOKENS(...)
+#define _RYML_WITH_OR_WITHOUT_TAB_TOKENS(with, without) with
+#else
+#define _RYML_WITH_TAB_TOKENS(...)
+#define _RYML_WITHOUT_TAB_TOKENS(...) __VA_ARGS__
+#define _RYML_WITH_OR_WITHOUT_TAB_TOKENS(with, without) without
+#endif
+
+
+// scaffold:
+#define _c4dbgnextline()                           \
+    do {                                           \
+       _c4dbgq("\n-----------");                   \
+       _c4dbgt("handling line={}, offset={}B",     \
+               m_evt_handler->m_curr->pos.line,    \
+               m_evt_handler->m_curr->pos.offset); \
+    } while(0)
+
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4296/*expression is always 'boolean_value'*/)
+#   pragma warning(disable: 4702/*unreachable code*/)
+#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"
+#   pragma clang diagnostic ignored "-Wold-style-cast"
+#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"
+#   pragma GCC diagnostic ignored "-Wold-style-cast"
+#   if __GNUC__ >= 7
+#       pragma GCC diagnostic ignored "-Wduplicated-branches"
+#   endif
+#endif
+
+// NOLINTBEGIN(hicpp-signed-bitwise,cppcoreguidelines-avoid-goto,hicpp-avoid-goto,hicpp-multiway-paths-covered)
+
+namespace c4 {
+namespace yml {
+
+namespace { // NOLINT
+
+C4_HOT C4_ALWAYS_INLINE bool _is_blck_token(csubstr s) noexcept
+{
+    RYML_ASSERT(s.len > 0);
+    RYML_ASSERT(s.str[0] == '-' || s.str[0] == ':' || s.str[0] == '?');
+    return ((s.len == 1) || ((s.str[1] == ' ') _RYML_WITH_TAB_TOKENS( || (s.str[1] == '\t'))));
+}
+
+inline bool _is_doc_begin_token(csubstr s)
+{
+    RYML_ASSERT(s.begins_with('-'));
+    RYML_ASSERT(!s.ends_with("\n"));
+    RYML_ASSERT(!s.ends_with("\r"));
+    return (s.len >= 3 && s.str[1] == '-' && s.str[2] == '-')
+        && (s.len == 3 || (s.str[3] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[3] == '\t')));
+}
+
+inline bool _is_doc_end_token(csubstr s)
+{
+    RYML_ASSERT(s.begins_with('.'));
+    RYML_ASSERT(!s.ends_with("\n"));
+    RYML_ASSERT(!s.ends_with("\r"));
+    return (s.len >= 3 && s.str[1] == '.' && s.str[2] == '.')
+        && (s.len == 3 || (s.str[3] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[3] == '\t')));
+}
+
+inline bool _is_doc_token(csubstr s) noexcept
+{
+    //
+    // NOTE: this function was failing under some scenarios when
+    // compiled with gcc -O2 (but not -O3 or -O1 or -O0), likely
+    // related to optimizer assumptions on the input string and
+    // possibly caused from UB around assignment to that string (the
+    // call site was in _scan_block()). For more details see:
+    //
+    // https://github.com/biojppm/rapidyaml/issues/440
+    //
+    // The current version does not suffer this problem, but it may
+    // appear again.
+    //
+    //
+    // UPDATE. The problem appeared again in gcc12 and gcc13 with -Os
+    // (but not any other optimization level, nor any other compiler
+    // or version), because the assignment to s is being hoisted out
+    // of the loop which calls this function. Then the length doesn't
+    // enter the s.len >= 3 when it should. Adding a
+    // C4_DONT_OPTIMIZE(var) makes the problem go away.
+    //
+    if(s.len >= 3)
+    {
+        switch(s.str[0])
+        {
+        case '-':
+            //return _is_doc_begin_token(s); // this was failing with gcc -O2
+            return (s.str[1] == '-' && s.str[2] == '-')
+                && (s.len == 3 || (s.str[3] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[3] == '\t')));
+        case '.':
+            //return _is_doc_end_token(s); // this was failing with gcc -O2
+            return (s.str[1] == '.' && s.str[2] == '.')
+                && (s.len == 3 || (s.str[3] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[3] == '\t')));
+        }
+    }
+    return false;
+}
+
+inline size_t _is_special_json_scalar(csubstr s)
+{
+    RYML_ASSERT(s.len);
+    switch(s.str[0])
+    {
+    case 'f':
+        if(s.len >= 5 && s.begins_with("false"))
+            return 5u;
+        break;
+    case 't':
+        if(s.len >= 4 && s.begins_with("true"))
+            return 4u;
+        break;
+    case 'n':
+        if(s.len >= 4 && s.begins_with("null"))
+            return 4u;
+        break;
+    }
+    return 0u;
+}
+
+
+//-----------------------------------------------------------------------------
+
+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
+inline substr from_next_line(substr 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;
+}
+
+
+//-----------------------------------------------------------------------------
+
+inline size_t _count_following_newlines(csubstr r, size_t *C4_RESTRICT i)
+{
+    RYML_ASSERT(r[*i] == '\n');
+    size_t numnl_following = 0;
+    ++(*i);
+    for( ; *i < r.len; ++(*i))
+    {
+        if(r.str[*i] == '\n')
+            ++numnl_following;
+        // skip leading whitespace
+        else if(r.str[*i] == ' ' || r.str[*i] == '\t' || r.str[*i] == '\r')
+            ;
+        else
+            break;
+    }
+    return numnl_following;
+}
+
+/** @p i is set to the first non whitespace character after the line
+ * @return the number of empty lines after the initial position */
+inline 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);
+    if(indentation == 0)
+    {
+        for( ; *i < r.len; ++(*i))
+        {
+            if(r.str[*i] == '\n')
+                ++numnl_following;
+            // skip leading whitespace
+            else if(r.str[*i] == ' ' || r.str[*i] == '\t' || r.str[*i] == '\r')
+                ;
+            else
+                break;
+        }
+    }
+    else
+    {
+        for( ; *i < r.len; ++(*i))
+        {
+            if(r.str[*i] == '\n')
+            {
+                ++numnl_following;
+                // 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);
+            }
+            // skip leading whitespace
+            else if(r.str[*i] == ' ' || r.str[*i] == '\t' || r.str[*i] == '\r')
+                ;
+            else
+                break;
+        }
+    }
+    return numnl_following;
+}
+
+} // anon namespace
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+ParseEngine<EventHandler>::~ParseEngine()
+{
+    _free();
+    _clr();
+}
+
+template<class EventHandler>
+ParseEngine<EventHandler>::ParseEngine(EventHandler *evt_handler, ParserOptions opts)
+    : m_options(opts)
+    , m_file()
+    , m_buf()
+    , m_evt_handler(evt_handler)
+    , m_pending_anchors()
+    , m_pending_tags()
+    , m_was_inside_qmrk(false)
+    , m_doc_empty(false)
+    , m_prev_colon(npos)
+    , m_encoding(NOBOM)
+    , m_newline_offsets()
+    , m_newline_offsets_size(0)
+    , m_newline_offsets_capacity(0)
+    , m_newline_offsets_buf()
+{
+    RYML_CHECK(evt_handler);
+}
+
+template<class EventHandler>
+ParseEngine<EventHandler>::ParseEngine(ParseEngine &&that) noexcept
+    : m_options(that.m_options)
+    , m_file(that.m_file)
+    , m_buf(that.m_buf)
+    , m_evt_handler(that.m_evt_handler)
+    , m_pending_anchors(that.m_pending_anchors)
+    , m_pending_tags(that.m_pending_tags)
+    , m_was_inside_qmrk(false)
+    , m_doc_empty(false)
+    , m_prev_colon(npos)
+    , m_encoding(NOBOM)
+    , 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();
+}
+
+template<class EventHandler>
+ParseEngine<EventHandler>::ParseEngine(ParseEngine const& that)
+    : m_options(that.m_options)
+    , m_file(that.m_file)
+    , m_buf(that.m_buf)
+    , m_evt_handler(that.m_evt_handler)
+    , m_pending_anchors(that.m_pending_anchors)
+    , m_pending_tags(that.m_pending_tags)
+    , m_was_inside_qmrk(false)
+    , m_doc_empty(false)
+    , m_prev_colon(npos)
+    , m_encoding(NOBOM)
+    , 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_evt_handler->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;
+    }
+}
+
+template<class EventHandler>
+ParseEngine<EventHandler>& ParseEngine<EventHandler>::operator=(ParseEngine &&that) noexcept
+{
+    _free();
+    m_options = (that.m_options);
+    m_file = (that.m_file);
+    m_buf = (that.m_buf);
+    m_evt_handler = that.m_evt_handler;
+    m_pending_anchors = that.m_pending_anchors;
+    m_pending_tags = that.m_pending_tags;
+    m_was_inside_qmrk = that.m_was_inside_qmrk;
+    m_doc_empty = that.m_doc_empty;
+    m_prev_colon = that.m_prev_colon;
+    m_encoding = that.m_encoding;
+    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;
+}
+
+template<class EventHandler>
+ParseEngine<EventHandler>& ParseEngine<EventHandler>::operator=(ParseEngine const& that)
+{
+    if(&that != this)
+    {
+        _free();
+        m_options = (that.m_options);
+        m_file = (that.m_file);
+        m_buf = (that.m_buf);
+        m_evt_handler = that.m_evt_handler;
+        m_pending_anchors = that.m_pending_anchors;
+        m_pending_tags = that.m_pending_tags;
+        m_was_inside_qmrk = that.m_was_inside_qmrk;
+        m_doc_empty = that.m_doc_empty;
+        m_prev_colon = that.m_prev_colon;
+        m_encoding = that.m_encoding;
+        if(that.m_newline_offsets_capacity > m_newline_offsets_capacity)
+            _resize_locations(that.m_newline_offsets_capacity);
+        _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_capacity >= that.m_newline_offsets_capacity);
+        _RYML_CB_CHECK(m_evt_handler->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;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_clr()
+{
+    m_options = {};
+    m_file = {};
+    m_buf = {};
+    m_evt_handler = {};
+    m_pending_anchors = {};
+    m_pending_tags = {};
+    m_was_inside_qmrk = false;
+    m_doc_empty = true;
+    m_prev_colon = npos;
+    m_encoding = NOBOM;
+    m_newline_offsets = {};
+    m_newline_offsets_size = {};
+    m_newline_offsets_capacity = {};
+    m_newline_offsets_buf = {};
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_free()
+{
+    if(m_newline_offsets)
+    {
+        _RYML_CB_FREE(m_evt_handler->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 = nullptr;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_reset()
+{
+    m_pending_anchors = {};
+    m_pending_tags = {};
+    m_doc_empty = true;
+    m_was_inside_qmrk = false;
+    m_prev_colon = npos;
+    m_encoding = NOBOM;
+    if(m_options.locations())
+    {
+        _prepare_locations();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_relocate_arena(csubstr prev_arena, substr next_arena)
+{
+    #define _ryml_relocate(s)                                   \
+    if((s).is_sub(prev_arena))                                  \
+    {                                                           \
+        (s).str = next_arena.str + ((s).str - prev_arena.str);  \
+    }
+    _ryml_relocate(m_buf);
+    _ryml_relocate(m_newline_offsets_buf);
+    for(size_t i = 0; i < m_pending_tags.num_entries; ++i)
+        _ryml_relocate(m_pending_tags.annotations[i].str);
+    for(size_t i = 0; i < m_pending_anchors.num_entries; ++i)
+        _ryml_relocate(m_pending_anchors.annotations[i].str);
+    #undef _ryml_relocate
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_s_relocate_arena(void* data, csubstr prev_arena, substr next_arena)
+{
+    ((ParseEngine*)data)->_relocate_arena(prev_arena, next_arena);
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+template<class DumpFn>
+void ParseEngine<EventHandler>::_fmt_msg(DumpFn &&dumpfn) const
+{
+    auto const *const C4_RESTRICT st = m_evt_handler->m_curr;
+    auto const& lc = st->line_contents;
+    csubstr contents = lc.stripped;
+    if(contents.len)
+    {
+        // print the yaml src line
+        size_t offs = 3u + to_chars(substr{}, st->pos.line) + to_chars(substr{}, st->pos.col);
+        if(m_file.len)
+        {
+            detail::_dump(std::forward<DumpFn>(dumpfn), "{}:", m_file);
+            offs += m_file.len + 1;
+        }
+        detail::_dump(std::forward<DumpFn>(dumpfn), "{}:{}: ", st->pos.line, st->pos.col);
+        csubstr maybe_full_content = (contents.len < 80u ? contents : contents.first(80u));
+        csubstr maybe_ellipsis = (contents.len < 80u ? csubstr{} : csubstr("..."));
+        detail::_dump(std::forward<DumpFn>(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)
+            std::forward<DumpFn>(dumpfn)(" ");
+        std::forward<DumpFn>(dumpfn)("^");
+        for(size_t i = 1, e = (lc.rem.len < 80u ? lc.rem.len : 80u); i < e; ++i)
+            std::forward<DumpFn>(dumpfn)("~");
+        detail::_dump(std::forward<DumpFn>(dumpfn), "{}  (cols {}-{})\n", maybe_ellipsis, firstcol+1, lastcol+1);
+    }
+    else
+    {
+        std::forward<DumpFn>(dumpfn)("\n");
+    }
+
+#ifdef RYML_DBG
+    // next line: print the state flags
+    {
+        char flagbuf_[128];
+        detail::_dump(std::forward<DumpFn>(dumpfn), "top state: {}\n", detail::_parser_flags_to_str(flagbuf_, m_evt_handler->m_curr->flags));
+    }
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+template<class ...Args>
+void ParseEngine<EventHandler>::_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); };
+    detail::_dump(dumpfn, fmt, args...);
+    writer.append('\n');
+    _fmt_msg(dumpfn);
+    size_t len = writer.pos < RYML_ERRMSG_SIZE ? writer.pos : RYML_ERRMSG_SIZE;
+    m_evt_handler->cancel_parse();
+    m_evt_handler->m_stack.m_callbacks.m_error(errmsg, len, m_evt_handler->m_curr->pos, m_evt_handler->m_stack.m_callbacks.m_user_data);
+}
+
+
+//-----------------------------------------------------------------------------
+#ifdef RYML_DBG
+template<class EventHandler>
+template<class ...Args>
+void ParseEngine<EventHandler>::_dbg(csubstr fmt, Args const& C4_RESTRICT ...args) const
+{
+    if(_dbg_enabled())
+    {
+        auto dumpfn = [](csubstr s){ if(s.str) fwrite(s.str, 1, s.len, stdout); };
+        detail::_dump(dumpfn, fmt, args...);
+        dumpfn("\n");
+        _fmt_msg(dumpfn);
+    }
+}
+#endif
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_finished_file() const
+{
+    bool ret = m_evt_handler->m_curr->pos.offset >= m_buf.len;
+    if(ret)
+    {
+        _c4dbgp("finished file!!!");
+    }
+    return ret;
+}
+
+template<class EventHandler>
+C4_HOT C4_ALWAYS_INLINE bool ParseEngine<EventHandler>::_finished_line() const
+{
+    return m_evt_handler->m_curr->line_contents.rem.empty();
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_skip_whitespace_tokens()
+{
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(rem.len && (rem.str[0] == ' ' _RYML_WITH_TAB_TOKENS(|| rem.str[0] == '\t')))
+    {
+        size_t pos = rem.first_not_of(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+        if(pos == npos)
+            pos = rem.len; // maybe the line is just all whitespace
+        _c4dbgpf("skip {} whitespace characters", pos);
+        _line_progressed(pos);
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_skipchars(char c)
+{
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(rem.len && rem.str[0] == c)
+    {
+        size_t pos = rem.first_not_of(c);
+        if(pos == npos)
+            pos = rem.len; // maybe the line is just all c
+        _c4dbgpf("skip {}x'{}'", pos, c);
+        _line_progressed(pos);
+    }
+}
+
+#ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_skipchars_up_to(char c, size_t max_to_skip)
+{
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(rem.len && rem.str[0] == c)
+    {
+        size_t pos = rem.first_not_of(c);
+        if(pos == npos)
+            pos = rem.len; // maybe the line is just all c
+        if(pos > max_to_skip)
+            pos = max_to_skip;
+        _c4dbgpf("skip {}x'{}'", pos, c);
+        _line_progressed(pos);
+    }
+}
+#endif
+
+template<class EventHandler>
+template<size_t N>
+void ParseEngine<EventHandler>::_skipchars(const char (&chars)[N])
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->line_contents.rem.begins_with_any(chars));
+    size_t pos = m_evt_handler->m_curr->line_contents.rem.first_not_of(chars);
+    if(pos == npos)
+        pos = m_evt_handler->m_curr->line_contents.rem.len; // maybe the line is just whitespace
+    _c4dbgpf("skip {} characters", pos);
+    _line_progressed(pos);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_skip_comment()
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->line_contents.rem.begins_with('#'));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->line_contents.rem.is_sub(m_evt_handler->m_curr->line_contents.full));
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    csubstr full = m_evt_handler->m_curr->line_contents.full;
+    // raise an error if the comment is not preceded by whitespace
+    if(!full.begins_with('#'))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.str > full.str);
+        const char c = full[(size_t)(rem.str - full.str - 1)];
+        if(C4_UNLIKELY(c != ' ' && c != '\t'))
+            _RYML_CB_ERR(m_evt_handler->m_stack.m_callbacks, "comment not preceded by whitespace");
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.str == full.str);
+    }
+    _c4dbgpf("comment was '{}'", rem);
+    _line_progressed(rem.len);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_skip_comment()
+{
+    csubstr s = m_evt_handler->m_curr->line_contents.rem.triml(' ');
+    if(s.begins_with('#'))
+    {
+        _line_progressed((size_t)(s.str - m_evt_handler->m_curr->line_contents.rem.str));
+        _skip_comment();
+    }
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_maybe_scan_following_colon() noexcept
+{
+    if(m_evt_handler->m_curr->line_contents.rem.len)
+    {
+        if(m_evt_handler->m_curr->line_contents.rem.str[0] == ' ' || m_evt_handler->m_curr->line_contents.rem.str[0] == '\t')
+        {
+            size_t pos = m_evt_handler->m_curr->line_contents.rem.first_not_of(" \t");
+            if(pos == npos)
+                pos = m_evt_handler->m_curr->line_contents.rem.len; // maybe the line has only spaces
+            _c4dbgpf("skip {}x'{}'", pos, ' ');
+            _line_progressed(pos);
+        }
+        if(m_evt_handler->m_curr->line_contents.rem.len && (m_evt_handler->m_curr->line_contents.rem.str[0] == ':'))
+        {
+            _c4dbgp("found ':' colon next");
+            _line_progressed(1);
+            return true;
+        }
+    }
+    return false;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_maybe_scan_following_comma() noexcept
+{
+    if(m_evt_handler->m_curr->line_contents.rem.len)
+    {
+        if(m_evt_handler->m_curr->line_contents.rem.str[0] == ' ' || m_evt_handler->m_curr->line_contents.rem.str[0] == '\t')
+        {
+            size_t pos = m_evt_handler->m_curr->line_contents.rem.first_not_of(" \t");
+            if(pos == npos)
+                pos = m_evt_handler->m_curr->line_contents.rem.len; // maybe the line has only spaces
+            _c4dbgpf("skip {}x'{}'", pos, ' ');
+            _line_progressed(pos);
+        }
+        if(m_evt_handler->m_curr->line_contents.rem.len && (m_evt_handler->m_curr->line_contents.rem.str[0] == ','))
+        {
+            _c4dbgp("found ',' comma next");
+            _line_progressed(1);
+            return true;
+        }
+    }
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_scan_anchor()
+{
+    csubstr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begins_with('&'));
+    csubstr anchor = s.range(1, s.first_of(' '));
+    _line_progressed(1u + anchor.len);
+    _maybe_skipchars(' ');
+    return anchor;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_scan_ref_seq()
+{
+    csubstr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begins_with('*'));
+    csubstr ref = s.first(s.first_of(",] :"));
+    _line_progressed(ref.len);
+    return ref;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_scan_ref_map()
+{
+    csubstr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begins_with('*'));
+    csubstr ref = s.first(s.first_of(",} "));
+    _line_progressed(ref.len);
+    return ref;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_scan_tag()
+{
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem.triml(' ');
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.begins_with('!'));
+    csubstr t;
+    if(rem.begins_with("!!"))
+    {
+        _c4dbgp("begins with '!!'");
+        if(has_any(FLOW))
+            t = rem.left_of(rem.first_of(" ,"));
+        else
+            t = rem.left_of(rem.first_of(' '));
+    }
+    else if(rem.begins_with("!<"))
+    {
+        _c4dbgp("begins with '!<'");
+        t = rem.left_of(rem.first_of('>'), true);
+    }
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    else if(rem.begins_with("!h!"))
+    {
+        _c4dbgp("begins with '!h!'");
+        t = rem.left_of(rem.first_of(' '));
+    }
+    #endif
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.begins_with('!'));
+        _c4dbgp("begins with '!'");
+        if(has_any(FLOW))
+            t = rem.left_of(rem.first_of(" ,"));
+        else
+            t = rem.left_of(rem.first_of(' '));
+    }
+    _line_progressed(t.len);
+    _maybe_skip_whitespace_tokens();
+    return t;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_is_valid_start_scalar_plain_flow(csubstr s)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.empty());
+
+    // it's not a scalar if it starts with any of these characters:
+    switch(s.str[0])
+    {
+    // these are all legal tokens which mean no scalar is starting:
+    case '[':
+    case ']':
+    case '{':
+    case '}':
+    case '!':
+    case '&':
+    case '*':
+    case '|':
+    case '>':
+    case '#':
+        _c4dbgpf("not a scalar: found non-scalar token '{}'", _c4prc(s.str[0]));
+        return false;
+    // '-' and ':' are illegal at the beginning if not followed by a scalar character
+    case '-':
+    case ':':
+        if(s.len > 1)
+        {
+            switch(s.str[1])
+            {
+            case '\n':
+            case '\r':
+            case '{':
+            case '[':
+            //_RYML_WITHOUT_TAB_TOKENS(case '\t'):
+                _c4err("invalid token \":{}\"", _c4prc(s.str[1]));
+                break;
+            case ' ':
+            case '}':
+            case ']':
+                if(s.str[0] == ':')
+                {
+                    _c4dbgpf("not a scalar: found non-scalar token '{}{}'", s.str[0], s.str[1]);
+                    return false;
+                }
+                break;
+            default:
+                break;
+            }
+        }
+        else
+        {
+            return false;
+        }
+        break;
+    case '?':
+        if(s.len > 1)
+        {
+            switch(s.str[1])
+            {
+            case ' ':
+            case '\n':
+            case '\r':
+            _RYML_WITHOUT_TAB_TOKENS(case '\t':)
+                _c4dbgpf("not a scalar: found non-scalar token '?{}'", _c4prc(s.str[1]));
+                return false;
+            case '{':
+            case '}':
+            case '[':
+            case ']':
+                _c4err("invalid token \"?{}\"", _c4prc(s.str[1]));
+                break;
+            default:
+                break;
+            }
+        }
+        else
+        {
+            return false;
+        }
+        break;
+    // everything else is a legal starting character
+    default:
+        break;
+    }
+
+    return true;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_seq_flow(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RSEQ|RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL));
+
+    substr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with(' '));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with('\n'));
+
+    if(!s.len)
+        return false;
+
+    if(!_is_valid_start_scalar_plain_flow(s))
+        return false;
+
+    _c4dbgp("scanning seqflow scalar...");
+
+    const size_t start_offset = m_evt_handler->m_curr->pos.offset;
+    bool needs_filter = false;
+    while(true)
+    {
+        _c4dbgpf("scanning scalar: curr line=[{}]~~~{}~~~", s.len, s);
+        for(size_t i = 0; i < s.len; ++i)
+        {
+            const char c = s.str[i];
+            switch(c)
+            {
+            case ',':
+                _c4dbgpf("found terminating character at {}: '{}'", i, c);
+                _line_progressed(i);
+                if(m_evt_handler->m_curr->pos.offset + i > start_offset)
+                {
+                    goto ended_scalar;
+                }
+                else
+                {
+                    _c4dbgp("at the beginning. no scalar here.");
+                    return false;
+                }
+                break;
+            case ']':
+                _c4dbgpf("found terminating character at {}: '{}'", i, c);
+                _line_progressed(i);
+                goto ended_scalar;
+                break;
+            case '#':
+                _c4dbgp("found suspicious '#'");
+                if(!i || (s.str[i-1] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[i-1] == '\t')))
+                {
+                    _c4dbgpf("found terminating character at {}: '{}'", i, c);
+                    _line_progressed(i);
+                    goto ended_scalar;
+                }
+                break;
+            case ':':
+                _c4dbgp("found suspicious ':'");
+                if(s.len > i+1)
+                {
+                    const char next = s.str[i+1];
+                    _c4dbgpf("next char is '{}'", _c4prc(next));
+                    if(next == ' ' || next == ',' _RYML_WITH_TAB_TOKENS(|| next == '\t'))
+                    {
+                        _c4dbgp("map starting!");
+                        if(m_evt_handler->m_curr->pos.offset + i > start_offset)
+                        {
+                            _c4dbgp("scalar finished!");
+                            _line_progressed(i);
+                            goto ended_scalar;
+                        }
+                        else
+                        {
+                            _c4dbgp("at the beginning. no scalar here.");
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        _c4dbgp("it's a scalar indeed.");
+                        ++i; // skip the next char
+                    }
+                }
+                else if(s.len == i+1)
+                {
+                    _c4dbgp("':' at line end. map starting!");
+                    return false;
+                }
+                break;
+            case '[':
+            case '{':
+            case '}':
+                _line_progressed(i);
+                _c4err("invalid character: '{}'", c); // noreturn
+            default:
+                ;
+            }
+        }
+        _line_progressed(s.len);
+        if(!_finished_file())
+        {
+            _c4dbgp("next line!");
+            _line_ended();
+            _scan_line();
+        }
+        else
+        {
+            _c4dbgp("file finished!");
+            goto ended_scalar;
+        }
+        s = m_evt_handler->m_curr->line_contents.rem;
+        needs_filter = true;
+    }
+
+ended_scalar:
+
+    sc->scalar = m_buf.range(start_offset, m_evt_handler->m_curr->pos.offset).trimr(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \t", ' '));
+    sc->needs_filter = needs_filter;
+
+    _c4prscalar("scanned plain scalar", sc->scalar, /*keep_newlines*/true);
+
+    return true;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_map_flow(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RSEQ) || has_any(RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RMAP|RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RVAL|QMRK));
+
+    substr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with(' '));
+
+    if(!s.len)
+        return false;
+
+    if(!_is_valid_start_scalar_plain_flow(s))
+        return false;
+
+    _c4dbgp("scanning scalar...");
+
+    const size_t start_offset = m_evt_handler->m_curr->pos.offset;
+    bool needs_filter = false;
+    while(true)
+    {
+        for(size_t i = 0; i < s.len; ++i)
+        {
+            const char c = s.str[i];
+            switch(c)
+            {
+            case ',':
+            case '}':
+                _line_progressed(i);
+                _c4dbgpf("found terminating character: '{}'", c);
+                goto ended_scalar;
+            case ':':
+                if(s.len == i+1 || s.str[i+1] == ' ' || s.str[i+1] == ',' || s.str[i+1] == '}' _RYML_WITH_TAB_TOKENS(|| s.str[i+1] == '\t'))
+                {
+                    _line_progressed(i);
+                    _c4dbgpf("found terminating character: '{}'", c);
+                    goto ended_scalar;
+                }
+                break;
+            case '{':
+            case '[':
+                _line_progressed(i);
+                _c4err("invalid character: '{}'", c); // noreturn
+                break;
+            case ']':
+                _line_progressed(i);
+                if(has_any(RSEQIMAP))
+                    goto ended_scalar;
+                else
+                    _c4err("invalid character: '{}'", c); // noreturn
+                break;
+            case '#':
+                if(!i || s.str[i-1] == ' ' _RYML_WITH_TAB_TOKENS(|| s.str[i-1] == '\t'))
+                {
+                    _line_progressed(i);
+                    _c4dbgpf("found terminating character: '{}'", c);
+                    goto ended_scalar;
+                }
+                break;
+            default:
+                ;
+            }
+        }
+        _c4dbgp("next line!");
+        _line_progressed(s.len);
+        if(!_finished_file())
+        {
+            _c4dbgp("next line!");
+            _line_ended();
+            _scan_line();
+        }
+        else
+        {
+            _c4dbgp("file finished!");
+            goto ended_scalar;
+        }
+        s = m_evt_handler->m_curr->line_contents.rem;
+        needs_filter = true;
+    }
+
+ended_scalar:
+
+    sc->scalar = m_buf.range(start_offset, m_evt_handler->m_curr->pos.offset).trimr(_RYML_WITH_OR_WITHOUT_TAB_TOKENS(" \n\t\r", " \n\r"));
+    sc->needs_filter = needs_filter;
+
+    _c4dbgpf("scalar was [{}]~~~{}~~~", sc->scalar.len, sc->scalar);
+
+    return sc->scalar.len > 0u;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_seq_json(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(FLOW));
+
+    substr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with(' '));
+
+    if(!s.len)
+        return false;
+
+    _c4dbgp("scanning scalar...");
+
+    switch(s.str[0])
+    {
+    case ']':
+    case '{':
+    case ',':
+        _c4dbgp("not a scalar.");
+        return false;
+    }
+
+    {
+        const size_t len = _is_special_json_scalar(s);
+        if(len)
+        {
+            sc->scalar = s.first(len);
+            sc->needs_filter = false;
+            _c4dbgpf("special json scalar: '{}'", sc->scalar);
+            _line_progressed(len);
+            return true;
+        }
+    }
+
+    // must be a number
+    size_t i = 0;
+    for( ; i < s.len; ++i)
+    {
+        const char c = s.str[i];
+        switch(c)
+        {
+        case ',':
+        case ']':
+        case ' ':
+        case '\t':
+            _c4dbgpf("found terminating character: '{}'", c);
+            goto ended_scalar;
+        case '#':
+            if(!i || s.str[i-1] == ' ')
+            {
+                _c4dbgpf("found terminating character: '{}'", c);
+                goto ended_scalar;
+            }
+            break;
+        default:
+            ;
+        }
+    }
+
+ended_scalar:
+
+    if(C4_LIKELY(i > 0))
+    {
+        _line_progressed(i);
+        sc->scalar = s.first(i);
+        sc->needs_filter = false;
+        _c4dbgpf("scalar was [{}]~~~{}~~~", sc->scalar.len, sc->scalar);
+        return true;
+    }
+
+    return false;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_map_json(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RVAL));
+
+    substr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with(' '));
+
+    if(!s.len)
+        return false;
+
+    _c4dbgp("scanning scalar...");
+
+    {
+        const size_t len = _is_special_json_scalar(s);
+        if(len)
+        {
+            sc->scalar = s.first(len);
+            sc->needs_filter = false;
+            _c4dbgpf("special json scalar: '{}'", sc->scalar);
+            _line_progressed(len);
+            return true;
+        }
+    }
+
+    // must be a number
+    size_t i = 0;
+    for( ; i < s.len; ++i)
+    {
+        const char c = s.str[i];
+        switch(c)
+        {
+        case ',':
+        case '}':
+        case ' ':
+        case '\t':
+            _c4dbgpf("found terminating character: '{}'", c);
+            goto ended_scalar;
+        case '#':
+            if(!i || s.str[i-1] == ' ')
+            {
+                _c4dbgpf("found terminating character: '{}'", c);
+                goto ended_scalar;
+            }
+            break;
+        default:
+            ;
+        }
+    }
+
+ended_scalar:
+
+    if(C4_LIKELY(i > 0))
+    {
+        _line_progressed(i);
+        sc->scalar = s.first(i);
+        sc->needs_filter = false;
+        _c4dbgpf("scalar was [{}]~~~{}~~~", sc->scalar.len, sc->scalar);
+        return true;
+    }
+
+    return false;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_is_doc_begin(csubstr s)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s[0] == '-');
+    return (m_evt_handler->m_curr->line_contents.indentation == 0u && _at_line_begin() && _is_doc_begin_token(s));
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_is_doc_end(csubstr s)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s[0] == '.');
+    return (m_evt_handler->m_curr->line_contents.indentation == 0u && _at_line_begin() && _is_doc_end_token(s));
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_blck(ScannedScalar *C4_RESTRICT sc, size_t indentation)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(BLCK|RUNK|USTY));
+
+    substr s = m_evt_handler->m_curr->line_contents.rem;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !s.begins_with(' '));
+
+    if(!s.len)
+        return false;
+
+    switch(s.str[0])
+    {
+    case '-':
+        if(_is_blck_token(s))
+        {
+            return false;
+        }
+        else if(_is_doc_begin(s))
+        {
+            _c4dbgp("token is doc start");
+            return false;
+        }
+        break;
+    case ':':
+    case '?':
+        if(_is_blck_token(s))
+            return false;
+        break;
+    case '[':
+    case '{':
+    case '&':
+    case '*':
+    case '!':
+    _RYML_WITH_TAB_TOKENS(case '\t':)
+        return false;
+    case '.':
+        if(_is_doc_end(s))
+        {
+            _c4dbgp("token is doc end");
+            return false;
+        }
+        break;
+    }
+
+    _c4dbgpf("plain scalar! indentation={}", indentation);
+
+    const size_t start_offset = m_evt_handler->m_curr->pos.offset;
+    const size_t start_line = m_evt_handler->m_curr->pos.line;
+
+    bool needs_filter = false;
+    while(true)
+    {
+        _c4dbgpf("plain scalar line: [{}]~~~{}~~~", s.len, s);
+        for(size_t i = 0; i < s.len; ++i)
+        {
+            const char curr = s.str[i];
+            //_c4dbgpf("[{}]='{}'", i, _c4prc(curr));
+            switch(curr)
+            {
+            case ':':
+                _c4dbgpf("[{}]: got suspicious ':'", i);
+                // are there more characters?
+                if((i + 1 == s.len) || ((s.str[i+1] == ' ') _RYML_WITH_TAB_TOKENS( || (s.str[i+1] == '\t'))))
+                {
+                    _c4dbgpf("followed by '{}'", i+1 == s.len ? csubstr("\\n") : _c4prc(s.str[i+1]));
+                    _line_progressed(i);
+                    // ': ' is accepted only on the first line
+                    if(C4_LIKELY(m_evt_handler->m_curr->pos.line == start_line))
+                    {
+                        _c4dbgp("start line. scalar ends here");
+                        goto ended_scalar;
+                    }
+                    else
+                    {
+                        _c4err("parse error");
+                    }
+                }
+                else
+                {
+                    size_t j = i;
+                    while(j + 1 < s.len && s.str[j+1] == ':')
+                    {
+                        _c4dbgp("skip colon");
+                        ++j;
+                    }
+                    i = j > i ? j-1 : i;
+                    _c4dbgp("nothing to see here");
+                }
+                break;
+            case '#':
+                _c4dbgp("got suspicious '#'");
+                if(!i || (s.str[i-1] == ' ' || s.str[i-1] == '\t'))
+                {
+                    _c4dbgp("comment! scalar ends here");
+                    _line_progressed(i);
+                    goto ended_scalar;
+                }
+                else
+                {
+                    _c4dbgp("nothing to see here");
+                }
+                break;
+            }
+        }
+        _line_progressed(s.len);
+        csubstr next_peeked = _peek_next_line(m_evt_handler->m_curr->pos.offset);
+        next_peeked = next_peeked.trimr("\n\r");
+        const size_t next_indentation = next_peeked.first_not_of(' ');
+        _c4dbgpf("indentation curr={} next={}", indentation, next_indentation);
+        if(next_indentation < indentation)
+        {
+            _c4dbgp("smaller indentation! scalar ended");
+            goto ended_scalar;
+        }
+        else if(next_indentation == 0 && next_peeked.len > 0)
+        {
+            const char first = next_peeked.str[0];
+            switch(first)
+            {
+            case '-':
+                next_peeked = next_peeked.trimr("\n\r");
+                _c4dbgpf("doc begin? peeked=[{}]~~~{}{}~~~", next_peeked.len, next_peeked.len >= 3 ? next_peeked.first(3) : next_peeked, next_peeked.len > 3 ? "..." : "");
+                if(_is_doc_begin_token(next_peeked))
+                {
+                    _c4dbgp("doc begin! scalar ended");
+                    goto ended_scalar;
+                }
+                break;
+            case '.':
+                next_peeked = next_peeked.trimr("\n\r");
+                _c4dbgpf("doc end? peeked=[{}]~~~{}{}~~~", next_peeked.len, next_peeked.len >= 3 ? next_peeked.first(3) : next_peeked, next_peeked.len > 3 ? "..." : "");
+                if(_is_doc_end_token(next_peeked))
+                {
+                    _c4dbgp("doc end! scalar ended");
+                    goto ended_scalar;
+                }
+                break;
+            }
+        }
+        // load with next line
+        _c4dbgp("next line!");
+        if(!_finished_file())
+        {
+            _c4dbgp("next line!");
+            _line_ended();
+            _scan_line();
+        }
+        else
+        {
+            _c4dbgp("file finished!");
+            goto ended_scalar;
+        }
+        s = m_evt_handler->m_curr->line_contents.rem;
+        needs_filter = true;
+    }
+
+ended_scalar:
+
+    sc->scalar = m_buf.range(start_offset, m_evt_handler->m_curr->pos.offset).trimr(" \n\r\t");
+    sc->needs_filter = needs_filter;
+
+    _c4dbgpf("scalar was [{}]~~~{}~~~", sc->scalar.len, sc->scalar);
+
+    return true;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_seq_blck(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL));
+    return _scan_scalar_plain_blck(sc, m_evt_handler->m_curr->indref + 1u);
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_map_blck(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RVAL|QMRK));
+    return _scan_scalar_plain_blck(sc, m_evt_handler->m_curr->indref + 1u);
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_scan_scalar_plain_unk(ScannedScalar *C4_RESTRICT sc)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  has_any(RUNK|USTY));
+    return _scan_scalar_plain_blck(sc, m_evt_handler->m_curr->indref);
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+substr ParseEngine<EventHandler>::_peek_next_line(size_t pos) const
+{
+    substr rem{}; // declare here because of the goto
+    size_t nlpos{}; // declare here because of the goto
+    pos = pos == npos ? m_evt_handler->m_curr->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 {};
+}
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_scan_line()
+{
+    if(C4_LIKELY(m_evt_handler->m_curr->pos.offset < m_buf.len))
+        m_evt_handler->m_curr->line_contents.reset_with_next_line(m_buf, m_evt_handler->m_curr->pos.offset);
+    else
+        m_evt_handler->m_curr->line_contents.reset(m_buf.last(0), m_buf.last(0));
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_line_progressed(size_t ahead)
+{
+    _c4dbgpf("line[{}] ({} cols) progressed by {}:  col {}-->{}   offset {}-->{}", m_evt_handler->m_curr->pos.line, m_evt_handler->m_curr->line_contents.full.len, ahead, m_evt_handler->m_curr->pos.col, m_evt_handler->m_curr->pos.col+ahead, m_evt_handler->m_curr->pos.offset, m_evt_handler->m_curr->pos.offset+ahead);
+    m_evt_handler->m_curr->pos.offset += ahead;
+    m_evt_handler->m_curr->pos.col += ahead;
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.col <= m_evt_handler->m_curr->line_contents.stripped.len+1);
+    m_evt_handler->m_curr->line_contents.rem = m_evt_handler->m_curr->line_contents.rem.sub(ahead);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_line_ended()
+{
+    _c4dbgpf("line[{}] ({} cols) ended! offset {}-->{} / col {}-->{}",
+             m_evt_handler->m_curr->pos.line,
+             m_evt_handler->m_curr->line_contents.full.len,
+             m_evt_handler->m_curr->pos.offset, m_evt_handler->m_curr->pos.offset + m_evt_handler->m_curr->line_contents.full.len - m_evt_handler->m_curr->line_contents.stripped.len,
+             m_evt_handler->m_curr->pos.col, 1);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.col == m_evt_handler->m_curr->line_contents.stripped.len + 1);
+    m_evt_handler->m_curr->pos.offset += m_evt_handler->m_curr->line_contents.full.len - m_evt_handler->m_curr->line_contents.stripped.len;
+    ++m_evt_handler->m_curr->pos.line;
+    m_evt_handler->m_curr->pos.col = 1;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_line_ended_undo()
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.col == 1u);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.line > 0u);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.offset >= m_evt_handler->m_curr->line_contents.full.len - m_evt_handler->m_curr->line_contents.stripped.len);
+    const size_t delta = m_evt_handler->m_curr->line_contents.full.len - m_evt_handler->m_curr->line_contents.stripped.len;
+    _c4dbgpf("line[{}] undo ended! line {}-->{}, offset {}-->{}", m_evt_handler->m_curr->pos.line, m_evt_handler->m_curr->pos.line, m_evt_handler->m_curr->pos.line - 1, m_evt_handler->m_curr->pos.offset, m_evt_handler->m_curr->pos.offset - delta);
+    m_evt_handler->m_curr->pos.offset -= delta;
+    --m_evt_handler->m_curr->pos.line;
+    m_evt_handler->m_curr->pos.col = m_evt_handler->m_curr->line_contents.stripped.len + 1u;
+    // don't forget to undo also the changes to the remainder of the line
+    //_RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.offset >= m_buf.len || m_buf[m_evt_handler->m_curr->pos.offset] == '\n' || m_buf[m_evt_handler->m_curr->pos.offset] == '\r');
+    m_evt_handler->m_curr->line_contents.rem = m_buf.sub(m_evt_handler->m_curr->pos.offset, 0);
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+void ParseEngine<EventHandler>::_set_indentation(size_t indentation)
+{
+    m_evt_handler->m_curr->indref = indentation;
+    _c4dbgpf("state[{}]: saving indentation: {}", m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_save_indentation()
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->line_contents.rem.begin() >= m_evt_handler->m_curr->line_contents.full.begin());
+    m_evt_handler->m_curr->indref = m_evt_handler->m_curr->line_contents.current_col();
+    _c4dbgpf("state[{}]: saving indentation: {}", m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end_map_blck()
+{
+    _c4dbgp("mapblck: end");
+    if(has_any(RKCL|RVAL))
+    {
+        _c4dbgp("mapblck: set missing val");
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+    }
+    else if(has_any(QMRK))
+    {
+        _c4dbgp("mapblck: set missing keyval");
+        _handle_annotations_before_blck_key_scalar();
+        m_evt_handler->set_key_scalar_plain_empty();
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+    }
+    m_evt_handler->end_map();
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end_seq_blck()
+{
+    if(has_any(RVAL))
+    {
+        _c4dbgp("seqblck: set missing val");
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+    }
+    m_evt_handler->end_seq();
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end2_map()
+{
+    _c4dbgp("map: end");
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RMAP));
+    if(has_any(BLCK))
+    {
+        _end_map_blck();
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(FLOW));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(USTY));
+        m_evt_handler->_pop();
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end2_seq()
+{
+    _c4dbgp("seq: end");
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RSEQ));
+    if(has_any(BLCK))
+    {
+        _end_seq_blck();
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(FLOW));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(USTY));
+        m_evt_handler->_pop();
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_begin2_doc()
+{
+    m_doc_empty = true;
+    add_flags(RDOC);
+    m_evt_handler->begin_doc();
+    m_evt_handler->m_curr->indref = 0; // ?
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_begin2_doc_expl()
+{
+    m_doc_empty = true;
+    add_flags(RDOC);
+    m_evt_handler->begin_doc_expl();
+    m_evt_handler->m_curr->indref = 0; // ?
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end2_doc()
+{
+    _c4dbgp("doc: end");
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RDOC));
+    if(m_doc_empty || (m_pending_tags.num_entries || m_pending_anchors.num_entries))
+    {
+        _c4dbgp("doc was empty; add empty val");
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+    }
+    m_evt_handler->end_doc();
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end2_doc_expl()
+{
+    _c4dbgp("doc: end");
+    if(m_doc_empty || (m_pending_tags.num_entries || m_pending_anchors.num_entries))
+    {
+        _c4dbgp("doc: no children; add empty val");
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+    }
+    m_evt_handler->end_doc_expl();
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_begin_doc()
+{
+    if(has_none(RDOC))
+    {
+        _c4dbgp("doc must be started");
+        _begin2_doc();
+    }
+}
+template<class EventHandler>
+void ParseEngine<EventHandler>::_maybe_end_doc()
+{
+    if(has_any(RDOC))
+    {
+        _c4dbgp("doc must be finished");
+        _end2_doc();
+    }
+    else if(m_doc_empty && (m_pending_tags.num_entries || m_pending_anchors.num_entries))
+    {
+        _c4dbgp("no doc to finish, but pending annotations");
+        m_evt_handler->begin_doc();
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->set_val_scalar_plain_empty();
+        m_evt_handler->end_doc();
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end_doc_suddenly__pop()
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 1);
+    if(m_evt_handler->m_stack[0].flags & RDOC)
+    {
+        _c4dbgp("root is RDOC");
+        if(m_evt_handler->m_curr->level != 0)
+            _handle_indentation_pop(&m_evt_handler->m_stack[0]);
+    }
+    else if((m_evt_handler->m_stack.size() > 1) && (m_evt_handler->m_stack[1].flags & RDOC))
+    {
+        _c4dbgp("root is STREAM");
+        if(m_evt_handler->m_curr->level != 1)
+            _handle_indentation_pop(&m_evt_handler->m_stack[1]);
+    }
+    else
+    {
+        _c4err("internal error");
+    }
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RDOC));
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end_doc_suddenly()
+{
+    _c4dbgp("end doc suddenly");
+    _end_doc_suddenly__pop();
+    _end2_doc_expl();
+    addrem_flags(RUNK|RTOP|NDOC, RMAP|RSEQ|RDOC);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_start_doc_suddenly()
+{
+    _c4dbgp("start doc suddenly");
+    _end_doc_suddenly__pop();
+    _end2_doc();
+    _begin2_doc_expl();
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_end_stream()
+{
+    _c4dbgpf("end_stream, level={} node_id={}", m_evt_handler->m_curr->level, m_evt_handler->m_curr->node_id);
+    if(has_all(RSEQ|FLOW))
+        _c4err("missing terminating ]");
+    else if(has_all(RMAP|FLOW))
+        _c4err("missing terminating }");
+    if(m_evt_handler->m_stack.size() > 1)
+        _handle_indentation_pop(m_evt_handler->m_stack.begin());
+    if(has_all(RDOC))
+    {
+        _end2_doc();
+    }
+    else if(has_all(RTOP|RUNK))
+    {
+        if(m_pending_anchors.num_entries || m_pending_tags.num_entries)
+        {
+            if(m_doc_empty)
+            {
+                m_evt_handler->begin_doc();
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->end_doc();
+            }
+        }
+    }
+    m_evt_handler->end_stream();
+}
+
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_indentation_pop(ParserState const* popto)
+{
+    _c4dbgpf("popping {} level{}: from level {}(@ind={}) to level {}(@ind={})", m_evt_handler->m_curr->level - popto->level, (((m_evt_handler->m_curr->level - popto->level) > 1) ? "s" : ""), m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref, popto->level, popto->indref);
+    while(m_evt_handler->m_curr != popto)
+    {
+        if(has_any(RSEQ))
+        {
+            _c4dbgpf("popping seq at level {} (indentation={},addr={})", m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref, m_evt_handler->m_curr);
+            _end2_seq();
+        }
+        else if(has_any(RMAP))
+        {
+            _c4dbgpf("popping map at level {} (indentation={},addr={})", m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref, m_evt_handler->m_curr);
+            _end2_map();
+        }
+        else
+        {
+            break;
+        }
+    }
+    _c4dbgpf("current level is {} (indentation={})", m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_indentation_pop_from_block_seq()
+{
+    // search the stack frame to jump to based on its indentation
+    using state_type = typename EventHandler::state;
+    state_type const* popto = nullptr;
+    auto &stack = m_evt_handler->m_stack;
+    _RYML_CB_ASSERT(stack.m_callbacks, stack.is_contiguous()); // this search relies on the stack being contiguous
+    _RYML_CB_ASSERT(stack.m_callbacks, m_evt_handler->m_curr >= stack.begin() && m_evt_handler->m_curr < stack.end());
+    const size_t ind = m_evt_handler->m_curr->line_contents.indentation;
+    #ifdef RYML_DBG
+    if(_dbg_enabled())
+    {
+        char flagbuf_[128];
+        for(state_type const& s : stack)
+            _dbg_printf("state[{}]: ind={} node={} flags={}\n", s.level, s.indref, s.node_id, detail::_parser_flags_to_str(flagbuf_, s.flags));
+    }
+    #endif
+    for(state_type const* s = m_evt_handler->m_curr-1; s >= 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;
+            break;
+        }
+    }
+    if(!popto || popto >= m_evt_handler->m_curr || popto->level >= m_evt_handler->m_curr->level)
+    {
+        _c4err("parse error: incorrect indentation?");
+    }
+    _handle_indentation_pop(popto);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_indentation_pop_from_block_map()
+{
+    // search the stack frame to jump to based on its indentation
+    using state_type = typename EventHandler::state;
+    auto &stack = m_evt_handler->m_stack;
+    _RYML_CB_ASSERT(stack.m_callbacks, stack.is_contiguous()); // this search relies on the stack being contiguous
+    _RYML_CB_ASSERT(stack.m_callbacks, m_evt_handler->m_curr >= stack.begin() && m_evt_handler->m_curr < stack.end());
+    const size_t ind = m_evt_handler->m_curr->line_contents.indentation;
+    state_type const* popto = nullptr;
+    #ifdef RYML_DBG
+    char flagbuf_[128];
+    if(_dbg_enabled())
+    {
+        for(state_type const& s : stack)
+            _dbg_printf("state[{}]: ind={} node={} flags={}\n", s.level, s.indref, s.node_id, detail::_parser_flags_to_str(flagbuf_, s.flags));
+    }
+    #endif
+    for(state_type const* s = m_evt_handler->m_curr-1; s > stack.begin(); --s) // never go to the stack bottom. that's the root
+    {
+        _c4dbgpf("searching for state with indentation {}. current: ind={},level={},node={},flags={}", ind, s->indref, s->level, s->node_id, detail::_parser_flags_to_str(flagbuf_, s->flags));
+        if(s->indref < ind)
+        {
+            break;
+        }
+        else if(s->indref == ind)
+        {
+            _c4dbgpf("same indentation!!! level={} node={}", s->level, s->node_id);
+            if(popto && has_any(RTOP, s) && has_none(RMAP|RSEQ, s))
+            {
+                break;
+            }
+            popto = s;
+            if(has_all(RSEQ|BLCK, s))
+            {
+                csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+                const size_t first = rem.first_not_of(' ');
+                _RYML_CB_ASSERT(stack.m_callbacks, first == ind || first == npos);
+                rem = rem.right_of(first, true);
+                _c4dbgpf("indentless? rem='{}' first={}", rem, first);
+                if(rem.begins_with('-') && _is_blck_token(rem))
+                {
+                    _c4dbgp("parent was indentless seq");
+                    break;
+                }
+            }
+        }
+    }
+    if(!popto || popto >= m_evt_handler->m_curr || popto->level >= m_evt_handler->m_curr->level)
+    {
+        _c4err("parse error: incorrect indentation?");
+    }
+    _handle_indentation_pop(popto);
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+typename ParseEngine<EventHandler>::ScannedScalar ParseEngine<EventHandler>::_scan_scalar_squot()
+{
+    // 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_evt_handler->m_curr->pos.offset;
+    substr s = m_buf.sub(b);
+    if(s.begins_with(' '))
+    {
+        s = s.triml(' ');
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.sub(b).is_super(s));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begin() >= m_buf.sub(b).begin());
+        _line_progressed((size_t)(s.begin() - m_buf.sub(b).begin()));
+    }
+    b = m_evt_handler->m_curr->pos.offset; // take this into account
+    _RYML_CB_ASSERT(m_evt_handler->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_evt_handler->m_curr->line_contents.rem;
+        bool line_is_blank = true;
+        _c4dbgpf("scanning single quoted scalar @ line[{}]: ~~~{}~~~", m_evt_handler->m_curr->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(' '));
+
+        if(pos == npos)
+        {
+            _line_progressed(line.len);
+            ++numlines;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, pos >= 0 && pos < m_buf.len);
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf[m_evt_handler->m_curr->pos.offset + pos] == '\'');
+            _line_progressed(pos + 1); // progress beyond the quote
+            pos = m_evt_handler->m_curr->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_evt_handler->m_stack.m_callbacks, pos > 0);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.end() >= m_buf.begin() && s.end() <= m_buf.end());
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.end() == m_buf.end() || *s.end() == '\'');
+        s = s.sub(0, pos-1);
+    }
+
+    _c4prscalar("scanned squoted scalar", s, /*keep_newlines*/true);
+
+    return ScannedScalar { s, needs_filter };
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+typename ParseEngine<EventHandler>::ScannedScalar ParseEngine<EventHandler>::_scan_scalar_dquot()
+{
+    // 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_evt_handler->m_curr->pos.offset;
+    substr s = m_buf.sub(b);
+    if(s.begins_with(' '))
+    {
+        s = s.triml(' ');
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.sub(b).is_super(s));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begin() >= m_buf.sub(b).begin());
+        _line_progressed((size_t)(s.begin() - m_buf.sub(b).begin()));
+    }
+    b = m_evt_handler->m_curr->pos.offset; // take this into account
+    _RYML_CB_ASSERT(m_evt_handler->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_evt_handler->m_curr->line_contents.rem;
+        #if defined(__GNUC__) && __GNUC__ == 11
+        C4_DONT_OPTIMIZE(line); // prevent erroneous hoist of the assignment out of the loop
+        #endif
+        bool line_is_blank = true;
+        _c4dbgpf("scanning double quoted scalar @ line[{}]:  line='{}'", m_evt_handler->m_curr->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(' '));
+
+        if(pos == npos)
+        {
+            _line_progressed(line.len);
+            ++numlines;
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, pos >= 0 && pos < m_buf.len);
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf[m_evt_handler->m_curr->pos.offset + pos] == '"');
+            _line_progressed(pos + 1); // progress beyond the quote
+            pos = m_evt_handler->m_curr->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_evt_handler->m_stack.m_callbacks, pos > 0);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.end() == m_buf.end() || *s.end() == '"');
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.end() >= m_buf.begin() && s.end() <= m_buf.end());
+        s = s.sub(0, pos-1);
+    }
+
+    _c4prscalar("scanned dquoted scalar", s, /*keep_newlines*/true);
+
+    return ScannedScalar { s, needs_filter };
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+void ParseEngine<EventHandler>::_scan_block(ScannedBlock *C4_RESTRICT sb, size_t indref)
+{
+    _c4dbgpf("blck: indref={}", indref);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, indref != npos);
+
+    // nice explanation here: http://yaml-multiline.info/
+    csubstr s = m_evt_handler->m_curr->line_contents.rem;
+    csubstr trimmed = s.triml(' ');
+    if(trimmed.str > s.str)
+    {
+        _c4dbgp("skipping whitespace");
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, trimmed.str >= s.str);
+        _line_progressed(static_cast<size_t>(trimmed.str - s.str));
+        s = trimmed;
+    }
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, s.begins_with('|') || s.begins_with('>'));
+
+    _c4dbgpf("blck: specs=[{}]~~~{}~~~", s.len, s);
+
+    // parse the spec
+    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_evt_handler->m_stack.m_callbacks, s.begins_with_any("|>"));
+        csubstr t = s.sub(1);
+        _c4dbgpf("blck: spec is multichar: '{}'", t);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, t.len >= 1);
+        size_t pos = t.first_of("-+");
+        _c4dbgpf("blck: 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_UNLIKELY(digits.len > 1))
+                _c4err("parse error: invalid indentation");
+            _c4dbgpf("blck: parse indentation digits: [{}]~~~{}~~~", digits.len, digits);
+            if(C4_UNLIKELY( ! c4::atou(digits, &indentation)))
+                _c4err("parse error: could not read indentation as decimal");
+            if(C4_UNLIKELY( ! indentation))
+                _c4err("parse error: null indentation");
+            _c4dbgpf("blck: indentation specified: {}. add {} from curr state -> {}", indentation, m_evt_handler->m_curr->indref, indentation+indref);
+            indentation += m_evt_handler->m_curr->indref;
+        }
+    }
+
+    _c4dbgpf("blck: style={}  chomp={}  indentation={}", s.begins_with('>') ? "fold" : "literal", chomp==CHOMP_CLIP ? "clip" : (chomp==CHOMP_STRIP ? "strip" : "keep"), indentation);
+
+    // finish the current line
+    _line_progressed(s.len);
+    _line_ended();
+    _scan_line();
+
+    // start with a zero-length block, already pointing at the right place
+    substr raw_block(m_buf.data() + m_evt_handler->m_curr->pos.offset, size_t(0));// m_evt_handler->m_curr->line_contents.full.sub(0, 0);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, raw_block.begin() == m_evt_handler->m_curr->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;
+    size_t first = m_evt_handler->m_curr->pos.line;
+    size_t provisional_indentation = npos;
+    LineContents lc;
+    while(( ! _finished_file()))
+    {
+        // peek next line, but do not advance immediately
+        lc.reset_with_next_line(m_buf, m_evt_handler->m_curr->pos.offset);
+        #if defined(__GNUC__) && (__GNUC__ == 12 || __GNUC__ == 13)
+        C4_DONT_OPTIMIZE(lc.rem);
+        #endif
+        _c4dbgpf("blck: peeking at [{}]~~~{}~~~", lc.stripped.len, lc.stripped);
+        // evaluate termination conditions
+        if(indentation != npos)
+        {
+            _c4dbgpf("blck: indentation={}", indentation);
+            // stop when the line is deindented and not empty
+            if(lc.indentation < indentation && ( ! lc.rem.trim(" \t").empty()))
+            {
+                if(raw_block.len)
+                {
+                    _c4dbgpf("blck: indentation decreased ref={} thisline={}", indentation, lc.indentation);
+                }
+                else
+                {
+                    _c4err("indentation decreased without any scalar");
+                }
+                break;
+            }
+            else if(indentation == 0)
+            {
+                _c4dbgpf("blck: noindent. lc.rem=[{}]~~~{}~~~", lc.rem.len, lc.rem);
+                if(_is_doc_token(lc.rem))
+                {
+                    _c4dbgp("blck: stop. indentation=0 and doc ended");
+                    break;
+                }
+            }
+        }
+        else
+        {
+            const size_t fns = lc.stripped.first_not_of(' ');
+            _c4dbgpf("blck: indentation ref not set. firstnonws={}", fns);
+            if(fns != npos) // non-empty line
+            {
+                _RYML_WITH_TAB_TOKENS(
+                    if(C4_UNLIKELY(lc.stripped.begins_with('\t')))
+                        _c4err("parse error");
+                )
+                _c4dbgpf("blck: line not empty. indref={} indprov={} indentation={}", indref, provisional_indentation, lc.indentation);
+                if(provisional_indentation == npos)
+                {
+                    if(lc.indentation < indref)
+                    {
+                        _c4dbgpf("blck: block terminated indentation={} < indref={}", lc.indentation, indref);
+                        if(raw_block.len == 0)
+                        {
+                            _c4dbgp("blck: was empty, undo next line");
+                            _line_ended_undo();
+                        }
+                        break;
+                    }
+                    else if(lc.indentation == m_evt_handler->m_curr->indref)
+                    {
+                        if(has_any(RSEQ|RMAP))
+                        {
+                            _c4dbgpf("blck: block terminated. reading container and indentation={}==indref={}", lc.indentation, m_evt_handler->m_curr->indref);
+                            break;
+                        }
+                    }
+                    _c4dbgpf("blck: set indentation ref from this line: ref={}", lc.indentation);
+                    indentation = lc.indentation;
+                }
+                else
+                {
+                    if(lc.indentation >= provisional_indentation)
+                    {
+                        _c4dbgpf("blck: 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("blck: 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("blck: 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("blck: increase provisional_ref {} -> {}", provisional_indentation, lc.indentation);
+                        provisional_indentation = lc.indentation;
+                    }
+                    #endif
+                }
+                else
+                {
+                    provisional_indentation = lc.indentation ? lc.indentation : has_any(RSEQ|RVAL);
+                    _c4dbgpf("blck: initialize provisional_ref={}", provisional_indentation);
+                    if(provisional_indentation == npos)
+                    {
+                        provisional_indentation = lc.stripped.len ? lc.stripped.len : has_any(RSEQ|RVAL);
+                        _c4dbgpf("blck: initialize provisional_ref={}", provisional_indentation);
+                    }
+                    if(provisional_indentation < indref)
+                    {
+                        provisional_indentation = indref;
+                        _c4dbgpf("blck: initialize provisional_ref={}", provisional_indentation);
+                    }
+                }
+            }
+        }
+        // advance now that we know the folded scalar continues
+        m_evt_handler->m_curr->line_contents = lc;
+        _c4dbgpf("blck: append '{}'", m_evt_handler->m_curr->line_contents.rem);
+        raw_block.len += m_evt_handler->m_curr->line_contents.full.len;
+        _line_progressed(m_evt_handler->m_curr->line_contents.rem.len);
+        _line_ended();
+        ++num_lines;
+    }
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->pos.line == (first + num_lines) || (raw_block.len == 0));
+    C4_UNUSED(num_lines);
+    C4_UNUSED(first);
+
+    if(indentation == npos)
+    {
+        _c4dbgpf("blck: set indentation from provisional: {}", provisional_indentation);
+        indentation = provisional_indentation;
+    }
+
+    if(num_lines)
+        _line_ended_undo();
+
+    _c4prscalar("scanned block", raw_block, /*keep_newlines*/true);
+
+    sb->scalar = raw_block;
+    sb->indentation = indentation;
+    sb->chomp = chomp;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/** @cond dev */
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfws(fmt, ...) _c4dbgpf("filt_ws[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfws(...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+bool ParseEngine<EventHandler>::_filter_ws_handle_to_first_non_space(FilterProcessor &proc)
+{
+    _c4dbgfws("found whitespace '{}'", _c4prc(proc.curr()));
+    _RYML_CB_ASSERT(this->callbacks(), proc.curr() == ' ' || proc.curr() == '\t');
+
+    const size_t first_pos = proc.rpos > 0 ? proc.src.first_not_of(" \t", proc.rpos) : proc.src.first_not_of(' ', proc.rpos);
+    if(first_pos != npos)
+    {
+        const char first_char = proc.src[first_pos];
+        _c4dbgfws("firstnonws='{}'@{}", _c4prc(first_char), first_pos);
+        if(first_char == '\n' || first_char == '\r') // skip trailing whitespace
+        {
+            _c4dbgfws("whitespace is trailing on line", "");
+            proc.skip(first_pos - proc.rpos);
+        }
+        else // a legit whitespace
+        {
+            proc.copy();
+            _c4dbgfws("legit whitespace. sofar=[{}]~~~{}~~~", proc.wpos, proc.sofar());
+        }
+        return true;
+    }
+    _c4dbgfws("whitespace is trailing on line", "");
+    return false;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_ws_copy_trailing(FilterProcessor &proc)
+{
+    if(!_filter_ws_handle_to_first_non_space(proc))
+    {
+        _c4dbgfws("... everything else is trailing whitespace - copy {} chars", proc.src.len - proc.rpos);
+        proc.copy(proc.src.len - proc.rpos);
+    }
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_ws_skip_trailing(FilterProcessor &proc)
+{
+    if(!_filter_ws_handle_to_first_non_space(proc))
+    {
+        _c4dbgfws("... everything else is trailing whitespace - skip {} chars", proc.src.len - proc.rpos);
+        proc.skip(proc.src.len - proc.rpos);
+    }
+}
+
+#undef _c4dbgfws
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/* plain scalars */
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfps(fmt, ...) _c4dbgpf("filt_plain[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfps(fmt, ...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_nl_plain(FilterProcessor &C4_RESTRICT proc, size_t indentation)
+{
+    _RYML_CB_ASSERT(this->callbacks(), proc.curr() == '\n');
+
+    _c4dbgfps("found newline. sofar=[{}]~~~{}~~~", proc.wpos, proc.sofar());
+    size_t ii = proc.rpos;
+    const size_t numnl_following = _count_following_newlines(proc.src, &ii, indentation);
+    if(numnl_following)
+    {
+        proc.set('\n', numnl_following);
+        _c4dbgfps("{} consecutive (empty) lines {}. totalws={}", 1+numnl_following, ii < proc.src.len ? "in the middle" : "at the end", proc.rpos-ii);
+    }
+    else
+    {
+        const size_t ret = proc.src.first_not_of(" \t", proc.rpos+1);
+        if(ret != npos)
+        {
+            proc.set(' ');
+             _c4dbgfps("single newline. convert to space. ret={}/{}. sofar=[{}]~~~{}~~~", ii, proc.src.len, proc.wpos, proc.sofar());
+        }
+        else
+        {
+            _c4dbgfps("last newline, everything else is whitespace. ii={}/{}", ii, proc.src.len);
+            ii = proc.src.len;
+        }
+    }
+    proc.rpos = ii;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+auto ParseEngine<EventHandler>::_filter_plain(FilterProcessor &C4_RESTRICT proc, size_t indentation) -> decltype(proc.result())
+{
+    _RYML_CB_ASSERT(this->callbacks(), indentation != npos);
+    _c4dbgfps("before=[{}]~~~{}~~~", proc.src.len, proc.src);
+
+    while(proc.has_more_chars())
+    {
+        const char curr = proc.curr();
+        _c4dbgfps("'{}', sofar=[{}]~~~{}~~~", _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case ' ':
+        _RYML_WITH_TAB_TOKENS(case '\t':)
+            _c4dbgfps("whitespace", curr);
+            _filter_ws_skip_trailing(proc);
+            break;
+        case '\n':
+            _c4dbgfps("newline", curr);
+            _filter_nl_plain(proc, /*indentation*/indentation);
+            break;
+        case '\r':  // skip \r --- https://stackoverflow.com/questions/1885900
+            _c4dbgfps("carriage return, ignore", curr);
+            proc.skip();
+            break;
+        default:
+            proc.copy();
+            break;
+        }
+    }
+
+    _c4dbgfps("after[{}]=~~~{}~~~", proc.wpos, proc.sofar());
+
+    return proc.result();
+}
+
+#undef _c4dbgfps
+
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_plain(csubstr scalar, substr dst, size_t indentation)
+{
+    FilterProcessorSrcDst proc(scalar, dst);
+    return _filter_plain(proc, indentation);
+}
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_plain_in_place(substr dst, size_t cap, size_t indentation)
+{
+    FilterProcessorInplaceEndExtending proc(dst, cap);
+    return _filter_plain(proc, indentation);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/* single quoted */
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfsq(fmt, ...) _c4dbgpf("filt_squo[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfsq(fmt, ...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_nl_squoted(FilterProcessor &C4_RESTRICT proc)
+{
+    _RYML_CB_ASSERT(this->callbacks(), proc.curr() == '\n');
+
+    _c4dbgfsq("found newline. sofar=[{}]~~~{}~~~", proc.wpos, proc.sofar());
+    size_t ii = proc.rpos;
+    const size_t numnl_following = _count_following_newlines(proc.src, &ii);
+    if(numnl_following)
+    {
+        proc.set('\n', numnl_following);
+        _c4dbgfsq("{} consecutive (empty) lines {}. totalws={}", 1+numnl_following, ii < proc.src.len ? "in the middle" : "at the end", proc.rpos-ii);
+    }
+    else
+    {
+        const size_t ret = proc.src.first_not_of(" \t", proc.rpos+1);
+        if(ret != npos)
+        {
+            proc.set(' ');
+            _c4dbgfsq("single newline. convert to space. ret={}/{}. sofar=[{}]~~~{}~~~", ii, proc.src.len, proc.wpos, proc.sofar());
+        }
+        else
+        {
+            proc.set(' ');
+            _c4dbgfsq("single newline. convert to space. ii={}/{}. sofar=[{}]~~~{}~~~", ii, proc.src.len, proc.wpos, proc.sofar());
+        }
+    }
+    proc.rpos = ii;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+auto ParseEngine<EventHandler>::_filter_squoted(FilterProcessor &C4_RESTRICT proc) -> decltype(proc.result())
+{
+    _c4dbgfsq("before=[{}]~~~{}~~~", proc.src.len, proc.src);
+
+    // from the YAML spec for double-quoted scalars:
+    // https://yaml.org/spec/1.2-old/spec.html#style/flow/single-quoted
+    while(proc.has_more_chars())
+    {
+        const char curr = proc.curr();
+        _c4dbgfsq("'{}', sofar=[{}]~~~{}~~~", _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case ' ':
+        case '\t':
+            _c4dbgfsq("whitespace", curr);
+            _filter_ws_copy_trailing(proc);
+            break;
+        case '\n':
+            _c4dbgfsq("newline", curr);
+            _filter_nl_squoted(proc);
+            break;
+        case '\r':  // skip \r --- https://stackoverflow.com/questions/1885900
+            _c4dbgfsq("skip cr", curr);
+            proc.skip();
+            break;
+        case '\'':
+            _c4dbgfsq("squote", curr);
+            if(proc.next() == '\'')
+            {
+                _c4dbgfsq("two consecutive squotes", curr);
+                proc.skip();
+                proc.copy();
+            }
+            else
+            {
+                _c4err("filter error");
+            }
+            break;
+        default:
+            proc.copy();
+            break;
+        }
+    }
+
+    _c4dbgfsq(": #filteredchars={} after=~~~[{}]{}~~~", proc.src.len-proc.sofar().len, proc.sofar().len, proc.sofar());
+
+    return proc.result();
+}
+
+#undef _c4dbgfsq
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_squoted(csubstr scalar, substr dst)
+{
+    FilterProcessorSrcDst proc(scalar, dst);
+    return _filter_squoted(proc);
+}
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_squoted_in_place(substr dst, size_t cap)
+{
+    FilterProcessorInplaceEndExtending proc(dst, cap);
+    return _filter_squoted(proc);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+/* double quoted */
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfdq(fmt, ...) _c4dbgpf("filt_dquo[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfdq(...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_nl_dquoted(FilterProcessor &C4_RESTRICT proc)
+{
+    _RYML_CB_ASSERT(this->callbacks(), proc.curr() == '\n');
+
+    _c4dbgfdq("found newline. sofar=[{}]~~~{}~~~", proc.wpos, proc.sofar());
+    size_t ii = proc.rpos;
+    const size_t numnl_following = _count_following_newlines(proc.src, &ii);
+    if(numnl_following)
+    {
+        proc.set('\n', numnl_following);
+        _c4dbgfdq("{} consecutive (empty) lines {}. totalws={}", 1+numnl_following, ii < proc.src.len ? "in the middle" : "at the end", proc.rpos-ii);
+    }
+    else
+    {
+        const size_t ret = proc.src.first_not_of(" \t", proc.rpos+1);
+        if(ret != npos)
+        {
+            proc.set(' ');
+            _c4dbgfdq("single newline. convert to space. ret={}/{}. sofar=[{}]~~~{}~~~", ii, proc.src.len, proc.wpos, proc.sofar());
+        }
+        else
+        {
+            proc.set(' ');
+            _c4dbgfdq("single newline. convert to space. ii={}/{}. sofar=[{}]~~~{}~~~", ii, proc.src.len, proc.wpos, proc.sofar());
+        }
+        if(ii < proc.src.len && proc.src.str[ii] == '\\')
+        {
+            _c4dbgfdq("backslash at [{}]", ii);
+            const char next = ii+1 < proc.src.len ? proc.src.str[ii+1] : '\0';
+            if(next == ' ' || next == '\t')
+            {
+                _c4dbgfdq("extend skip to backslash", "");
+                ++ii;
+            }
+        }
+    }
+    proc.rpos = ii;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_dquoted_backslash(FilterProcessor &C4_RESTRICT proc)
+{
+    char next = proc.next();
+    _c4dbgfdq("backslash, next='{}'", _c4prc(next));
+    if(next == '\r')
+    {
+        if(proc.rpos+2 < proc.src.len && proc.src.str[proc.rpos+2] == '\n')
+        {
+            proc.skip(); // newline escaped with \ -- skip both (add only one as i is loop-incremented)
+            next = '\n';
+            _c4dbgfdq("[{}]: was \\r\\n, now next='\\n'", proc.rpos);
+        }
+    }
+
+    if(next == '\n')
+    {
+        size_t ii = proc.rpos + 2;
+        for( ; ii < proc.src.len; ++ii)
+        {
+            // skip leading whitespace
+            if(proc.src.str[ii] == ' ' || proc.src.str[ii] == '\t')
+                ;
+            else
+                break;
+        }
+        proc.skip(ii - proc.rpos);
+    }
+    else if(next == '"' || next == '/' || next == ' ' || next == '\t')
+    {
+        // escapes for json compatibility
+        proc.translate_esc(next);
+        _c4dbgfdq("here, used '{}'", _c4prc(next));
+    }
+    else if(next == '\r')
+    {
+        proc.skip();
+    }
+    else if(next == 'n')
+    {
+        proc.translate_esc('\n');
+    }
+    else if(next == 'r')
+    {
+        proc.translate_esc('\r');
+    }
+    else if(next == 't')
+    {
+        proc.translate_esc('\t');
+    }
+    else if(next == '\\')
+    {
+        proc.translate_esc('\\');
+    }
+    else if(next == 'x') // UTF8
+    {
+        if(C4_UNLIKELY(proc.rpos + 1u + 2u >= proc.src.len))
+            _c4err("\\x requires 2 hex digits. scalar pos={}", proc.rpos);
+        csubstr codepoint = proc.src.sub(proc.rpos + 2u, 2u);
+        _c4dbgfdq("utf8 ~~~{}~~~ rpos={} rem=~~~{}~~~", codepoint, proc.rpos, proc.src.sub(proc.rpos));
+        uint8_t byteval = {};
+        if(C4_UNLIKELY(!read_hex(codepoint, &byteval)))
+            _c4err("failed to read \\x codepoint. scalar pos={}", proc.rpos);
+        proc.translate_esc_bulk((const char*)&byteval, 1u, /*nread*/3u);
+        _c4dbgfdq("utf8 after rpos={} rem=~~~{}~~~", proc.rpos, proc.src.sub(proc.rpos));
+    }
+    else if(next == 'u') // UTF16
+    {
+        if(C4_UNLIKELY(proc.rpos + 1u + 4u >= proc.src.len))
+            _c4err("\\u requires 4 hex digits. scalar pos={}", proc.rpos);
+        char readbuf[8];
+        csubstr codepoint = proc.src.sub(proc.rpos + 2u, 4u);
+        uint32_t codepoint_val = {};
+        if(C4_UNLIKELY(!read_hex(codepoint, &codepoint_val)))
+            _c4err("failed to parse \\u codepoint. scalar pos={}", proc.rpos);
+        const size_t numbytes = decode_code_point((uint8_t*)readbuf, sizeof(readbuf), codepoint_val);
+        if(C4_UNLIKELY(numbytes == 0))
+            _c4err("failed to decode code point={}", proc.rpos);
+        _RYML_CB_ASSERT(callbacks(), numbytes <= 4);
+        proc.translate_esc_bulk(readbuf, numbytes, /*nread*/5u);
+    }
+    else if(next == 'U') // UTF32
+    {
+        if(C4_UNLIKELY(proc.rpos + 1u + 8u >= proc.src.len))
+            _c4err("\\U requires 8 hex digits. scalar pos={}", proc.rpos);
+        char readbuf[8];
+        csubstr codepoint = proc.src.sub(proc.rpos + 2u, 8u);
+        uint32_t codepoint_val = {};
+        if(C4_UNLIKELY(!read_hex(codepoint, &codepoint_val)))
+            _c4err("failed to parse \\U codepoint. scalar pos={}", proc.rpos);
+        const size_t numbytes = decode_code_point((uint8_t*)readbuf, sizeof(readbuf), codepoint_val);
+        if(C4_UNLIKELY(numbytes == 0))
+            _c4err("failed to decode code point={}", proc.rpos);
+        _RYML_CB_ASSERT(callbacks(), numbytes <= 4);
+        proc.translate_esc_bulk(readbuf, numbytes, /*nread*/9u);
+    }
+    // https://yaml.org/spec/1.2.2/#rule-c-ns-esc-char
+    else if(next == '0')
+    {
+        proc.translate_esc('\0');
+    }
+    else if(next == 'b') // backspace
+    {
+        proc.translate_esc('\b');
+    }
+    else if(next == 'f') // form feed
+    {
+        proc.translate_esc('\f');
+    }
+    else if(next == 'a') // bell character
+    {
+        proc.translate_esc('\a');
+    }
+    else if(next == 'v') // vertical tab
+    {
+        proc.translate_esc('\v');
+    }
+    else if(next == 'e') // escape character
+    {
+        proc.translate_esc('\x1b');
+    }
+    else if(next == '_') // unicode non breaking space \u00a0
+    {
+        // https://www.compart.com/en/unicode/U+00a0
+        const char payload[] = {
+            _RYML_CHCONST(-0x3e, 0xc2),
+            _RYML_CHCONST(-0x60, 0xa0),
+        };
+        proc.translate_esc_bulk(payload, /*nwrite*/2, /*nread*/1);
+    }
+    else if(next == 'N') // unicode next line \u0085
+    {
+        // https://www.compart.com/en/unicode/U+0085
+        const char payload[] = {
+            _RYML_CHCONST(-0x3e, 0xc2),
+            _RYML_CHCONST(-0x7b, 0x85),
+        };
+        proc.translate_esc_bulk(payload, /*nwrite*/2, /*nread*/1);
+    }
+    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
+        const char payload[] = {
+            _RYML_CHCONST(-0x1e, 0xe2),
+            _RYML_CHCONST(-0x80, 0x80),
+            _RYML_CHCONST(-0x58, 0xa8),
+        };
+        proc.translate_esc_extending(payload, /*nwrite*/3, /*nread*/1);
+    }
+    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
+        const char payload[] = {
+            _RYML_CHCONST(-0x1e, 0xe2),
+            _RYML_CHCONST(-0x80, 0x80),
+            _RYML_CHCONST(-0x57, 0xa9),
+        };
+        proc.translate_esc_extending(payload, /*nwrite*/3, /*nread*/1);
+    }
+    else if(next == '\0')
+    {
+        proc.skip();
+    }
+    else
+    {
+        _c4err("unknown character '{}' after '\\' pos={}", _c4prc(next), proc.rpos);
+    }
+    _c4dbgfdq("backslash...sofar=[{}]~~~{}~~~", proc.wpos, proc.sofar());
+}
+
+
+template<class EventHandler>
+template<class FilterProcessor>
+auto ParseEngine<EventHandler>::_filter_dquoted(FilterProcessor &C4_RESTRICT proc) -> decltype(proc.result())
+{
+    _c4dbgfdq("before=[{}]~~~{}~~~", proc.src.len, proc.src);
+    // from the YAML spec for double-quoted scalars:
+    // https://yaml.org/spec/1.2-old/spec.html#style/flow/double-quoted
+    while(proc.has_more_chars())
+    {
+        const char curr = proc.curr();
+        _c4dbgfdq("'{}' sofar=[{}]~~~{}~~~", _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case ' ':
+        case '\t':
+        {
+            _c4dbgfdq("whitespace", curr);
+            _filter_ws_copy_trailing(proc);
+            break;
+        }
+        case '\n':
+        {
+            _c4dbgfdq("newline", curr);
+            _filter_nl_dquoted(proc);
+            break;
+        }
+        case '\r':  // skip \r --- https://stackoverflow.com/questions/1885900
+        {
+            _c4dbgfdq("carriage return, ignore", curr);
+            proc.skip();
+            break;
+        }
+        case '\\':
+        {
+            _filter_dquoted_backslash(proc);
+            break;
+        }
+        default:
+        {
+            proc.copy();
+            break;
+        }
+        }
+    }
+    _c4dbgfdq("after[{}]=~~~{}~~~", proc.wpos, proc.sofar());
+    return proc.result();
+}
+
+#undef _c4dbgfdq
+
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_dquoted(csubstr scalar, substr dst)
+{
+    FilterProcessorSrcDst proc(scalar, dst);
+    return _filter_dquoted(proc);
+}
+
+template<class EventHandler>
+FilterResultExtending ParseEngine<EventHandler>::filter_scalar_dquoted_in_place(substr dst, size_t cap)
+{
+    FilterProcessorInplaceMidExtending proc(dst, cap);
+    return _filter_dquoted(proc);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// block filtering helpers
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_chomp(FilterProcessor &C4_RESTRICT proc, BlockChomp_e chomp, size_t indentation)
+{
+    _RYML_CB_ASSERT(this->callbacks(), chomp == CHOMP_CLIP || chomp == CHOMP_KEEP || chomp == CHOMP_STRIP);
+    _RYML_CB_ASSERT(this->callbacks(), proc.rem().first_not_of(" \n\r") == npos);
+
+    // a debugging scaffold:
+    #if 0
+    #define _c4dbgchomp(fmt, ...) _c4dbgpf("chomp[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+    #else
+    #define _c4dbgchomp(...)
+    #endif
+
+    // advance to the last line having spaces beyond the indentation
+    {
+        size_t last = _find_last_newline_and_larger_indentation(proc.rem(), indentation);
+        if(last != npos)
+        {
+            _c4dbgchomp("found newline and larger indentation. last={}", last);
+            last = proc.rpos + last + size_t(1) + indentation;  // last started at to-be-read.
+            _RYML_CB_ASSERT(this->callbacks(), last <= proc.src.len);
+            // remove indentation spaces, copy the rest
+            while((proc.rpos < last) && proc.has_more_chars())
+            {
+                const char curr = proc.curr();
+                _c4dbgchomp("curr='{}'", _c4prc(curr));
+                switch(curr)
+                {
+                case '\n':
+                    {
+                        _c4dbgchomp("newline! remlen={}", proc.rem().len);
+                        proc.copy();
+                        // are there spaces after the newline?
+                        csubstr at_next_line = proc.rem();
+                        if(at_next_line.begins_with(' '))
+                        {
+                            _c4dbgchomp("next line begins with spaces. indentation={}", indentation);
+                            // there are spaces.
+                            size_t first_non_space = at_next_line.first_not_of(' ');
+                            _c4dbgchomp("first_non_space={}", first_non_space);
+                            if(first_non_space == npos)
+                            {
+                                _c4dbgchomp("{} spaces, to the end", at_next_line.len);
+                                first_non_space = at_next_line.len;
+                            }
+                            if(first_non_space <= indentation)
+                            {
+                                _c4dbgchomp("skip spaces={}<=indentation={}", first_non_space, indentation);
+                                proc.skip(first_non_space);
+                            }
+                            else
+                            {
+                                _c4dbgchomp("skip indentation={}<spaces={}", indentation, first_non_space);
+                                proc.skip(indentation);
+                                // copy the spaces after the indentation
+                                _c4dbgchomp("copy {}={}-{} spaces", first_non_space - indentation, first_non_space, indentation);
+                                proc.copy(first_non_space - indentation);
+                            }
+                        }
+                        break;
+                    }
+                case '\r':
+                    proc.skip();
+                    break;
+                default:
+                    _c4err("parse error");
+                    break;
+                }
+            }
+        }
+    }
+
+    // from now on, we only have line ends (or indentation spaces)
+    switch(chomp)
+    {
+    case CHOMP_CLIP:
+    {
+        bool had_one = false;
+        while(proc.has_more_chars())
+        {
+            const char curr = proc.curr();
+            _c4dbgchomp("CLIP: '{}'", _c4prc(curr));
+            switch(curr)
+            {
+            case '\n':
+            {
+                _c4dbgchomp("copy newline!", curr);
+                proc.copy();
+                proc.set_at_end();
+                had_one = true;
+                break;
+            }
+            case ' ':
+            case '\r':
+                _c4dbgchomp("skip!", curr);
+                proc.skip();
+                break;
+            }
+        }
+        if(!had_one) // there were no newline characters. add one.
+        {
+            _c4dbgchomp("chomp=CLIP: add missing newline @{}", proc.wpos);
+            proc.set('\n');
+        }
+        break;
+    }
+    case CHOMP_KEEP:
+    {
+        _c4dbgchomp("chomp=KEEP: copy all remaining new lines of {} characters", proc.rem().len);
+        while(proc.has_more_chars())
+        {
+            const char curr = proc.curr();
+            _c4dbgchomp("KEEP: '{}'", _c4prc(curr));
+            switch(curr)
+            {
+            case '\n':
+                _c4dbgchomp("copy newline!", curr);
+                proc.copy();
+                break;
+            case ' ':
+            case '\r':
+                _c4dbgchomp("skip!", curr);
+                proc.skip();
+                break;
+            }
+        }
+        break;
+    }
+    case CHOMP_STRIP:
+    {
+        _c4dbgchomp("chomp=STRIP: strip {} characters", proc.rem().len);
+        // nothing to do!
+        break;
+    }
+    }
+
+    #undef _c4dbgchomp
+}
+
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfb(fmt, ...) _c4dbgpf("filt_block[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfb(...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_block_indentation(FilterProcessor &C4_RESTRICT proc, size_t indentation)
+{
+    csubstr rem = proc.rem(); // remaining
+    if(rem.len)
+    {
+        size_t first = rem.first_not_of(' ');
+        if(first != npos)
+        {
+            _c4dbgfb("{} spaces follow before next nonws character", first);
+            if(first < indentation)
+            {
+                _c4dbgfb("skip {}<{} spaces from indentation", first, indentation);
+                proc.skip(first);
+            }
+            else
+            {
+                _c4dbgfb("skip {} spaces from indentation", indentation);
+                proc.skip(indentation);
+            }
+        }
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        else
+        {
+            _c4dbgfb("all spaces to the end: {} spaces", first);
+            first = rem.len;
+            if(first)
+            {
+                if(first < indentation)
+                {
+                    _c4dbgfb("skip everything", first);
+                    proc.skip(proc.src.len - proc.rpos);
+                }
+                else
+                {
+                    _c4dbgfb("skip {} spaces from indentation", indentation);
+                    proc.skip(indentation);
+                }
+            }
+        }
+        #endif
+    }
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+size_t ParseEngine<EventHandler>::_handle_all_whitespace(FilterProcessor &C4_RESTRICT proc, BlockChomp_e chomp)
+{
+    csubstr contents = proc.src.trimr(" \n\r");
+    _c4dbgfb("ws: contents_len={} wslen={}", contents.len, proc.src.len-contents.len);
+    if(!contents.len)
+    {
+        _c4dbgfb("ws: all whitespace: len={}", proc.src.len);
+        if(chomp == CHOMP_KEEP && proc.src.len)
+        {
+            _c4dbgfb("ws: chomp=KEEP all {} newlines", proc.src.count('\n'));
+            while(proc.has_more_chars())
+            {
+                const char curr = proc.curr();
+                if(curr == '\n')
+                    proc.copy();
+                else
+                    proc.skip();
+            }
+            if(!proc.wpos)
+            {
+                proc.set('\n');
+            }
+        }
+    }
+    return contents.len;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+size_t ParseEngine<EventHandler>::_extend_to_chomp(FilterProcessor &C4_RESTRICT proc, size_t contents_len)
+{
+    _c4dbgfb("contents_len={}", contents_len);
+
+    _RYML_CB_ASSERT(this->callbacks(), contents_len > 0u);
+
+    // extend contents to just before the first newline at the end,
+    // in case it is preceded by spaces
+    size_t firstnewl = proc.src.first_of('\n', contents_len);
+    if(firstnewl != npos)
+    {
+        contents_len = firstnewl;
+        _c4dbgfb("contents_len={}  <--- firstnewl={}", contents_len, firstnewl);
+    }
+    else
+    {
+        contents_len = proc.src.len;
+        _c4dbgfb("contents_len={}  <--- src.len={}", contents_len, proc.src.len);
+    }
+
+    return contents_len;
+}
+
+#undef _c4dbgfb
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfbl(fmt, ...) _c4dbgpf("filt_block_lit[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfbl(...)
+#endif
+
+template<class EventHandler>
+template<class FilterProcessor>
+auto ParseEngine<EventHandler>::_filter_block_literal(FilterProcessor &C4_RESTRICT proc, size_t indentation, BlockChomp_e chomp) -> decltype(proc.result())
+{
+    _c4dbgfbl("indentation={} before=[{}]~~~{}~~~", indentation, proc.src.len, proc.src);
+
+    size_t contents_len = _handle_all_whitespace(proc, chomp);
+    if(!contents_len)
+        return proc.result();
+
+    contents_len = _extend_to_chomp(proc, contents_len);
+
+    _c4dbgfbl("to filter=[{}]~~~{}~~~", contents_len, proc.src.first(contents_len));
+
+    _filter_block_indentation(proc, indentation);
+
+    // now filter the bulk
+    while(proc.has_more_chars(/*maxpos*/contents_len))
+    {
+        const char curr = proc.curr();
+        _c4dbgfbl("'{}' sofar=[{}]~~~{}~~~",  _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case '\n':
+        {
+            _c4dbgfbl("found newline. skip indentation on the next line", curr);
+            proc.copy();  // copy the newline
+            _filter_block_indentation(proc, indentation);
+            break;
+        }
+        case '\r':
+            proc.skip();
+            break;
+        default:
+            proc.copy();
+            break;
+        }
+    }
+
+    _c4dbgfbl("before chomp: #tochomp={}   sofar=[{}]~~~{}~~~", proc.rem().len, proc.sofar().len, proc.sofar());
+
+    _filter_chomp(proc, chomp, indentation);
+
+    _c4dbgfbl("final=[{}]~~~{}~~~", proc.sofar().len, proc.sofar());
+
+    return proc.result();
+}
+
+#undef _c4dbgfbl
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_block_literal(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp)
+{
+    FilterProcessorSrcDst proc(scalar, dst);
+    return _filter_block_literal(proc, indentation, chomp);
+}
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_block_literal_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp)
+{
+    FilterProcessorInplaceEndExtending proc(scalar, cap);
+    return _filter_block_literal(proc, indentation, chomp);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+// a debugging scaffold:
+#if 0
+#define _c4dbgfbf(fmt, ...) _c4dbgpf("filt_block_folded[{}->{}]: " fmt, proc.rpos, proc.wpos, __VA_ARGS__)
+#else
+#define _c4dbgfbf(...)
+#endif
+
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_block_folded_newlines_leading(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len)
+{
+    _filter_block_indentation(proc, indentation);
+    while(proc.has_more_chars(len))
+    {
+        const char curr = proc.curr();
+        _c4dbgfbf("'{}' sofar=[{}]~~~{}~~~",  _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case '\n':
+            _c4dbgfbf("newline.", curr);
+            proc.copy();
+            _filter_block_indentation(proc, indentation);
+            break;
+        case '\r':
+            proc.skip();
+            break;
+        case ' ':
+        case '\t':
+        {
+            size_t first = proc.rem().first_not_of(" \t");
+            _c4dbgfbf("space. first={}", first);
+            if(first == npos)
+                first = proc.rem().len;
+            _c4dbgfbf("... indentation increased to {}",  first);
+            _filter_block_folded_indented_block(proc, indentation, len, first);
+            break;
+        }
+        default:
+            _c4dbgfbf("newl leading: not space, not newline. stop.", 0);
+            return;
+        }
+    }
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+size_t ParseEngine<EventHandler>::_filter_block_folded_newlines_compress(FilterProcessor &C4_RESTRICT proc, size_t num_newl, size_t wpos_at_first_newl)
+{
+    switch(num_newl)
+    {
+    case 1u:
+        _c4dbgfbf("... this is the first newline. turn into space. wpos={}", proc.wpos);
+        wpos_at_first_newl = proc.wpos;
+        proc.skip();
+        proc.set(' ');
+        break;
+    case 2u:
+        _c4dbgfbf("... this is the second newline. prev space (at wpos={}) must be newline", wpos_at_first_newl);
+        _RYML_CB_ASSERT(this->callbacks(), wpos_at_first_newl != npos);
+        _RYML_CB_ASSERT(this->callbacks(), proc.sofar()[wpos_at_first_newl] == ' ');
+        _RYML_CB_ASSERT(this->callbacks(), wpos_at_first_newl + 1u == proc.wpos);
+        proc.skip();
+        proc.set_at(wpos_at_first_newl, '\n');
+        _RYML_CB_ASSERT(this->callbacks(), proc.sofar()[wpos_at_first_newl] == '\n');
+        break;
+    default:
+        _c4dbgfbf("... subsequent newline (num_newl={}). copy", num_newl);
+        proc.copy();
+        break;
+    }
+    return wpos_at_first_newl;
+}
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_block_folded_newlines(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len)
+{
+    _RYML_CB_ASSERT(this->callbacks(), proc.curr() == '\n');
+    size_t num_newl = 0;
+    size_t wpos_at_first_newl = npos;
+    while(proc.has_more_chars(len))
+    {
+        const char curr = proc.curr();
+        _c4dbgfbf("'{}' sofar=[{}]~~~{}~~~",  _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case '\n':
+        {
+            _c4dbgfbf("newline. sofar={}", num_newl);
+            // NOTE: vs2022-32bit-release builds were giving wrong
+            // results in this block, if it was written as either
+            // as a  switch(num_newl) or its equivalent if-form.
+            //
+            // For this reason, we're using a dedicated function
+            // (**_compress), which seems to work around the issue.
+            //
+            // The manifested problem was that somewhere between the
+            // assignment to curr and this point, proc.wpos (the
+            // write-position of the processor) jumped to npos, which
+            // made the write wrap-around! To make things worse,
+            // enabling prints via _c4dbgpf() and _c4dbgfbf() made the
+            // problem go away!
+            //
+            // The only way to make the problem appear with prints
+            // enabled was by disabling all prints in this function
+            // (including in the block which was moved to the compress
+            // function) and then selectively enabling only some of
+            // those prints.
+            //
+            // This may be due to some bug in the cl-x86 optimizer; or
+            // it may be triggered by some UB which may be
+            // inadvertedly present in this function or in the filter
+            // processor. This is despite our best efforts to weed out
+            // any such UB problem: neither clang-tidy nor none of the
+            // sanitizers, or gcc's -fanalyzer pointed to any problems
+            // in this code.
+            //
+            // In the end, moving this block to a separate function
+            // was the only way to bury the problem. But it may
+            // resurface again, as The Undead, rising to from the
+            // grave to haunt us with his terrible presence.
+            //
+            // We may have to revisit this. With a stake, and lots of
+            // garlic.
+            wpos_at_first_newl = _filter_block_folded_newlines_compress(proc, ++num_newl, wpos_at_first_newl);
+            _filter_block_indentation(proc, indentation);
+            break;
+        }
+        case ' ':
+        case '\t':
+            {
+                size_t first = proc.rem().first_not_of(" \t");
+                _c4dbgfbf("space. first={}", first);
+                if(first == npos)
+                    first = proc.rem().len;
+                _c4dbgfbf("... indentation increased to {}",  first);
+                if(num_newl)
+                {
+                    _c4dbgfbf("... prev space (at wpos={}) must be newline", wpos_at_first_newl);
+                    proc.set_at(wpos_at_first_newl, '\n');
+                }
+                if(num_newl > 1u)
+                {
+                    _c4dbgfbf("... add missing newline", wpos_at_first_newl);
+                    proc.set('\n');
+                }
+                _filter_block_folded_indented_block(proc, indentation, len, first);
+                num_newl = 0;
+                wpos_at_first_newl = npos;
+                break;
+            }
+        case '\r':
+            proc.skip();
+            break;
+        default:
+            _c4dbgfbf("not space, not newline. stop.", 0);
+            return;
+        }
+    }
+}
+
+
+template<class EventHandler>
+template<class FilterProcessor>
+void ParseEngine<EventHandler>::_filter_block_folded_indented_block(FilterProcessor &C4_RESTRICT proc, size_t indentation, size_t len, size_t curr_indentation) noexcept
+{
+    _RYML_CB_ASSERT(this->callbacks(), (proc.rem().first_not_of(" \t") == curr_indentation) || (proc.rem().first_not_of(" \t") == npos));
+    if(curr_indentation)
+        proc.copy(curr_indentation);
+    while(proc.has_more_chars(len))
+    {
+        const char curr = proc.curr();
+        _c4dbgfbf("'{}' sofar=[{}]~~~{}~~~",  _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case '\n':
+            {
+                proc.copy();
+                _filter_block_indentation(proc, indentation);
+                csubstr rem = proc.rem();
+                const size_t first = rem.first_not_of(' ');
+                _c4dbgfbf("newline. firstns={}",  first);
+                if(first == 0)
+                {
+                    const char c = rem[first];
+                    _c4dbgfbf("firstns={}='{}'", first, _c4prc(c));
+                    if(c == '\n' || c == '\r')
+                    {
+                        ;
+                    }
+                    else
+                    {
+                        _c4dbgfbf("done with indented block",  first);
+                        goto endloop;
+                    }
+                }
+                else if(first != npos)
+                {
+                    proc.copy(first);
+                    _c4dbgfbf("copy all {} spaces",  first);
+                }
+                break;
+            }
+            break;
+        case '\r':
+            proc.skip();
+            break;
+        default:
+            proc.copy();
+            break;
+        }
+    }
+ endloop:
+    return;
+}
+
+
+template<class EventHandler>
+template<class FilterProcessor>
+auto ParseEngine<EventHandler>::_filter_block_folded(FilterProcessor &C4_RESTRICT proc, size_t indentation, BlockChomp_e chomp) -> decltype(proc.result())
+{
+    _c4dbgfbf("indentation={} before=[{}]~~~{}~~~", indentation, proc.src.len, proc.src);
+
+    size_t contents_len = _handle_all_whitespace(proc, chomp);
+    if(!contents_len)
+        return proc.result();
+
+    contents_len = _extend_to_chomp(proc, contents_len);
+
+    _c4dbgfbf("to filter=[{}]~~~{}~~~", contents_len, proc.src.first(contents_len));
+
+    _filter_block_folded_newlines_leading(proc, indentation, contents_len);
+
+    // now filter the bulk
+    while(proc.has_more_chars(/*maxpos*/contents_len))
+    {
+        const char curr = proc.curr();
+        _c4dbgfbf("'{}' sofar=[{}]~~~{}~~~",  _c4prc(curr), proc.wpos, proc.sofar());
+        switch(curr)
+        {
+        case '\n':
+        {
+            _c4dbgfbf("found newline", curr);
+            _filter_block_folded_newlines(proc, indentation, contents_len);
+            break;
+        }
+        case '\r':
+            proc.skip();
+            break;
+        default:
+            proc.copy();
+            break;
+        }
+    }
+
+    _c4dbgfbf("before chomp: #tochomp={}   sofar=[{}]~~~{}~~~", proc.rem().len, proc.sofar().len, proc.sofar());
+
+    _filter_chomp(proc, chomp, indentation);
+
+    _c4dbgfbf("final=[{}]~~~{}~~~", proc.sofar().len, proc.sofar());
+
+    return proc.result();
+}
+
+#undef _c4dbgfbf
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_block_folded(csubstr scalar, substr dst, size_t indentation, BlockChomp_e chomp)
+{
+    FilterProcessorSrcDst proc(scalar, dst);
+    return _filter_block_folded(proc, indentation, chomp);
+}
+
+template<class EventHandler>
+FilterResult ParseEngine<EventHandler>::filter_scalar_block_folded_in_place(substr scalar, size_t cap, size_t indentation, BlockChomp_e chomp)
+{
+    FilterProcessorInplaceEndExtending proc(scalar, cap);
+    return _filter_block_folded(proc, indentation, chomp);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_filter_scalar_plain(substr s, size_t indentation)
+{
+    _c4dbgpf("filtering plain scalar: s=[{}]~~~{}~~~", s.len, s);
+    FilterResult r = this->filter_scalar_plain_in_place(s, s.len, indentation);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, r.valid());
+    _c4dbgpf("filtering plain scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
+    return r.get();
+}
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_filter_scalar_squot(substr s)
+{
+    _c4dbgpf("filtering squo scalar: s=[{}]~~~{}~~~", s.len, s);
+    FilterResult r = this->filter_scalar_squoted_in_place(s, s.len);
+    _RYML_CB_ASSERT(this->callbacks(), r.valid());
+    _c4dbgpf("filtering squo scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
+    return r.get();
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_filter_scalar_dquot(substr s)
+{
+    _c4dbgpf("filtering dquo scalar: s=[{}]~~~{}~~~", s.len, s);
+    FilterResultExtending r = this->filter_scalar_dquoted_in_place(s, s.len);
+    if(C4_LIKELY(r.valid()))
+    {
+        _c4dbgpf("filtering dquo scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
+        return r.get();
+    }
+    else
+    {
+        const size_t len = r.required_len();
+        _c4dbgpf("filtering dquo scalar: not enough space: needs {}, have {}", len, s.len);
+        substr dst = m_evt_handler->alloc_arena(len, &s);
+        _c4dbgpf("filtering dquo scalar: dst.len={}", dst.len);
+        _RYML_CB_ASSERT(this->callbacks(), dst.len == len);
+        FilterResult rsd = this->filter_scalar_dquoted(s, dst);
+        _c4dbgpf("filtering dquo scalar: ... result now needs {} was {}", rsd.required_len(), len);
+        _RYML_CB_ASSERT(this->callbacks(), rsd.required_len() <= len); // may be smaller!
+        _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, rsd.valid());
+        _c4dbgpf("filtering dquo scalar: success! s=[{}]~~~{}~~~", rsd.get().len, rsd.get());
+        return rsd.get();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_filter_scalar_literal(substr s, size_t indentation, BlockChomp_e chomp)
+{
+    _c4dbgpf("filtering block literal scalar: s=[{}]~~~{}~~~", s.len, s);
+    FilterResult r = this->filter_scalar_block_literal_in_place(s, s.len, indentation, chomp);
+    if(C4_LIKELY(r.valid()))
+    {
+        _c4dbgpf("filtering block literal scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
+        return r.get();
+    }
+    else
+    {
+        _c4dbgpf("filtering block literal scalar: not enough space: needs {}, have {}", r.required_len(), s.len);
+        substr dst = m_evt_handler->alloc_arena(r.required_len(), &s);
+        FilterResult rsd = this->filter_scalar_block_literal(s, dst, indentation, chomp);
+        _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, rsd.valid());
+        _c4dbgpf("filtering block literal scalar: success! s=[{}]~~~{}~~~", rsd.get().len, rsd.get());
+        return rsd.get();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_filter_scalar_folded(substr s, size_t indentation, BlockChomp_e chomp)
+{
+    _c4dbgpf("filtering block folded scalar: s=[{}]~~~{}~~~", s.len, s);
+    FilterResult r = this->filter_scalar_block_folded_in_place(s, s.len, indentation, chomp);
+    if(C4_LIKELY(r.valid()))
+    {
+        _c4dbgpf("filtering block folded scalar: success! s=[{}]~~~{}~~~", r.get().len, r.get());
+        return r.get();
+    }
+    else
+    {
+        _c4dbgpf("filtering block folded scalar: not enough space: needs {}, have {}", r.required_len(), s.len);
+        substr dst = m_evt_handler->alloc_arena(r.required_len(), &s);
+        FilterResult rsd = this->filter_scalar_block_folded(s, dst, indentation, chomp);
+        _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, rsd.valid());
+        _c4dbgpf("filtering block folded scalar: success! s=[{}]~~~{}~~~", rsd.get().len, rsd.get());
+        return rsd.get();
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_key_scalar_plain(ScannedScalar const& C4_RESTRICT sc, size_t indentation)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_plain(sc.scalar, indentation);
+        }
+        else
+        {
+            _c4dbgp("plain scalar left unfiltered");
+            m_evt_handler->mark_key_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("plain scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_val_scalar_plain(ScannedScalar const& C4_RESTRICT sc, size_t indentation)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_plain(sc.scalar, indentation);
+        }
+        else
+        {
+            _c4dbgp("plain scalar left unfiltered");
+            m_evt_handler->mark_val_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("plain scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_key_scalar_squot(ScannedScalar const& C4_RESTRICT sc)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_squot(sc.scalar);
+        }
+        else
+        {
+            _c4dbgp("squo key scalar left unfiltered");
+            m_evt_handler->mark_key_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("squo key scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_val_scalar_squot(ScannedScalar const& C4_RESTRICT sc)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_squot(sc.scalar);
+        }
+        else
+        {
+            _c4dbgp("squo val scalar left unfiltered");
+            m_evt_handler->mark_val_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("squo val scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_key_scalar_dquot(ScannedScalar const& C4_RESTRICT sc)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_dquot(sc.scalar);
+        }
+        else
+        {
+            _c4dbgp("dquo scalar left unfiltered");
+            m_evt_handler->mark_key_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("dquo scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_val_scalar_dquot(ScannedScalar const& C4_RESTRICT sc)
+{
+    if(sc.needs_filter)
+    {
+        if(m_options.scalar_filtering())
+        {
+            return _filter_scalar_dquot(sc.scalar);
+        }
+        else
+        {
+            _c4dbgp("dquo scalar left unfiltered");
+            m_evt_handler->mark_val_scalar_unfiltered();
+        }
+    }
+    else
+    {
+        _c4dbgp("dquo scalar doesn't need filtering");
+    }
+    return sc.scalar;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_key_scalar_literal(ScannedBlock const& C4_RESTRICT sb)
+{
+    if(m_options.scalar_filtering())
+    {
+        return _filter_scalar_literal(sb.scalar, sb.indentation, sb.chomp);
+    }
+    else
+    {
+        _c4dbgp("literal scalar left unfiltered");
+        m_evt_handler->mark_key_scalar_unfiltered();
+    }
+    return sb.scalar;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_val_scalar_literal(ScannedBlock const& C4_RESTRICT sb)
+{
+    if(m_options.scalar_filtering())
+    {
+        return _filter_scalar_literal(sb.scalar, sb.indentation, sb.chomp);
+    }
+    else
+    {
+        _c4dbgp("literal scalar left unfiltered");
+        m_evt_handler->mark_val_scalar_unfiltered();
+    }
+    return sb.scalar;
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_key_scalar_folded(ScannedBlock const& C4_RESTRICT sb)
+{
+    if(m_options.scalar_filtering())
+    {
+        return _filter_scalar_folded(sb.scalar, sb.indentation, sb.chomp);
+    }
+    else
+    {
+        _c4dbgp("folded scalar left unfiltered");
+        m_evt_handler->mark_key_scalar_unfiltered();
+    }
+    return sb.scalar;
+}
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::_maybe_filter_val_scalar_folded(ScannedBlock const& C4_RESTRICT sb)
+{
+    if(m_options.scalar_filtering())
+    {
+        return _filter_scalar_folded(sb.scalar, sb.indentation, sb.chomp);
+    }
+    else
+    {
+        _c4dbgp("folded scalar left unfiltered");
+        m_evt_handler->mark_val_scalar_unfiltered();
+    }
+    return sb.scalar;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+#ifdef RYML_DBG  //   !!! <----------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::add_flags(ParserFlag_t on, ParserState * s)
+{
+    char buf1_[64], buf2_[64], buf3_[64];
+    csubstr buf1 = detail::_parser_flags_to_str(buf1_, on);
+    csubstr buf2 = detail::_parser_flags_to_str(buf2_, s->flags);
+    csubstr buf3 = detail::_parser_flags_to_str(buf3_, s->flags|on);
+    _c4dbgpf("state[{}]: add {}: before={} after={}", s->level, buf1, buf2, buf3);
+    s->flags |= on;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::addrem_flags(ParserFlag_t on, ParserFlag_t off, ParserState * s)
+{
+    char buf1_[64], buf2_[64], buf3_[64], buf4_[64];
+    csubstr buf1 = detail::_parser_flags_to_str(buf1_, on);
+    csubstr buf2 = detail::_parser_flags_to_str(buf2_, off);
+    csubstr buf3 = detail::_parser_flags_to_str(buf3_, s->flags);
+    csubstr buf4 = detail::_parser_flags_to_str(buf4_, ((s->flags|on)&(~off)));
+    _c4dbgpf("state[{}]: add {} / rem {}: before={} after={}", s->level, buf1, buf2, buf3, buf4);
+    s->flags |= on;
+    s->flags &= ~off;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::rem_flags(ParserFlag_t off, ParserState * s)
+{
+    char buf1_[64], buf2_[64], buf3_[64];
+    csubstr buf1 = detail::_parser_flags_to_str(buf1_, off);
+    csubstr buf2 = detail::_parser_flags_to_str(buf2_, s->flags);
+    csubstr buf3 = detail::_parser_flags_to_str(buf3_, s->flags&(~off));
+    _c4dbgpf("state[{}]: rem {}: before={} after={}", s->level, buf1, buf2, buf3);
+    s->flags &= ~off;
+}
+
+inline C4_NO_INLINE csubstr detail::_parser_flags_to_str(substr buf, ParserFlag_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(BLCK);
+    _prflag(QMRK);
+    _prflag(RKEY);
+    _prflag(RVAL);
+    _prflag(RKCL);
+    _prflag(RNXT);
+    _prflag(SSCL);
+    _prflag(QSCL);
+    _prflag(RSET);
+    _prflag(RDOC);
+    _prflag(NDOC);
+    _prflag(USTY);
+    _prflag(RSEQIMAP);
+
+    #undef _prflag
+
+    if(pos == 0)
+        if(buf.len > 0)
+            buf[pos++] = '0';
+
+    RYML_CHECK(pos <= buf.len);
+
+    return buf.first(pos);
+}
+
+#endif // RYML_DBG   !!! <----------------------------------
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+csubstr ParseEngine<EventHandler>::location_contents(Location const& loc) const
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, loc.offset < m_buf.len);
+    return m_buf.sub(loc.offset);
+}
+
+template<class EventHandler>
+Location ParseEngine<EventHandler>::location(ConstNodeRef node) const
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, node.readable());
+    return location(*node.tree(), node.id());
+}
+
+template<class EventHandler>
+Location ParseEngine<EventHandler>::location(Tree const& tree, id_type node) const
+{
+    // try hard to avoid getting the location from a null string.
+    Location loc;
+    if(_location_from_node(tree, node, &loc, 0))
+        return loc;
+    return val_location(m_buf.str);
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_location_from_node(Tree const& tree, id_type node, Location *C4_RESTRICT loc, id_type level) const
+{
+    if(tree.has_key(node))
+    {
+        csubstr k = tree.key(node);
+        if(C4_LIKELY(k.str != nullptr))
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, k.is_sub(m_buf));
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.is_super(k));
+            *loc = val_location(k.str);
+            return true;
+        }
+    }
+
+    if(tree.has_val(node))
+    {
+        csubstr v = tree.val(node);
+        if(C4_LIKELY(v.str != nullptr))
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, v.is_sub(m_buf));
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.is_super(v));
+            *loc = val_location(v.str);
+            return true;
+        }
+    }
+
+    if(tree.is_container(node))
+    {
+        if(_location_from_cont(tree, node, loc))
+            return true;
+    }
+
+    if(tree.type(node) != NOTYPE && level == 0)
+    {
+        // try the prev sibling
+        {
+            const id_type prev = tree.prev_sibling(node);
+            if(prev != NONE)
+            {
+                if(_location_from_node(tree, prev, loc, level+1))
+                    return true;
+            }
+        }
+        // try the next sibling
+        {
+            const id_type next = tree.next_sibling(node);
+            if(next != NONE)
+            {
+                if(_location_from_node(tree, next, loc, level+1))
+                    return true;
+            }
+        }
+        // try the parent
+        {
+            const id_type parent = tree.parent(node);
+            if(parent != NONE)
+            {
+                if(_location_from_node(tree, parent, loc, level+1))
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_location_from_cont(Tree const& tree, id_type node, Location *C4_RESTRICT loc) const
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, tree.is_container(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))
+        {
+            id_type 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(k.str && node_start > k.str)
+                    node_start = k.str;
+            }
+        }
+        *loc = val_location(node_start);
+        return true;
+    }
+    else // it's a stream
+    {
+        *loc = val_location(m_buf.str); // just return the front of the buffer
+    }
+    return true;
+}
+
+
+template<class EventHandler>
+Location ParseEngine<EventHandler>::val_location(const char *val) const
+{
+    if(C4_UNLIKELY(val == nullptr))
+        return {m_file, 0, 0, 0};
+    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_options.locations());
+    // NOTE: if any of these checks fails, the parser needs to be
+    // instantiated with locations enabled.
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.str == m_newline_offsets_buf.str);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_buf.len == m_newline_offsets_buf.len);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_options.locations());
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, !_locations_dirty());
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_newline_offsets != nullptr);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_newline_offsets_size > 0);
+    // NOTE: the pointer needs to belong to the buffer that was used to parse.
+    csubstr src = m_buf;
+    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, val != nullptr || src.str == nullptr);
+    _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, (val >= src.begin() && val <= src.end()) || (src.str == nullptr && val == nullptr));
+    // ok. search the first stored newline after the given ptr
+    using lineptr_type = size_t const* C4_RESTRICT;
+    lineptr_type lineptr = nullptr;
+    size_t offset = (size_t)(val - src.begin());
+    if(m_newline_offsets_size < RYML_LOCATIONS_SMALL_THRESHOLD)
+    {
+        // just do a linear search if the size is small.
+        for(lineptr_type curr = m_newline_offsets, last = m_newline_offsets + m_newline_offsets_size; curr < last; ++curr)
+        {
+            if(*curr > offset)
+            {
+                lineptr = 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 costly include of <algorithm>.
+        size_t count = m_newline_offsets_size;
+        size_t step;
+        lineptr_type it;
+        lineptr = m_newline_offsets;
+        while(count)
+        {
+            step = count >> 1;
+            it = lineptr + step;
+            if(*it < offset)
+            {
+                lineptr = ++it;
+                count -= step + 1;
+            }
+            else
+            {
+                count = step;
+            }
+        }
+    }
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, lineptr >= m_newline_offsets);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, lineptr <= m_newline_offsets + m_newline_offsets_size);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, *lineptr > offset);
+    Location loc;
+    loc.name = m_file;
+    loc.offset = offset;
+    loc.line = (size_t)(lineptr - m_newline_offsets);
+    if(lineptr > m_newline_offsets)
+        loc.col = (offset - *(lineptr-1) - 1u);
+    else
+        loc.col = offset;
+    return loc;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_prepare_locations()
+{
+    m_newline_offsets_buf = m_buf;
+    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_evt_handler->m_stack.m_callbacks, m_newline_offsets_size == numnewlines);
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_resize_locations(size_t numnewlines)
+{
+    if(numnewlines > m_newline_offsets_capacity)
+    {
+        if(m_newline_offsets)
+            _RYML_CB_FREE(m_evt_handler->m_stack.m_callbacks, m_newline_offsets, size_t, m_newline_offsets_capacity);
+        m_newline_offsets = _RYML_CB_ALLOC_HINT(m_evt_handler->m_stack.m_callbacks, size_t, numnewlines, m_newline_offsets);
+        m_newline_offsets_capacity = numnewlines;
+    }
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_locations_dirty() const
+{
+    return !m_newline_offsets_size;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_flow_skip_whitespace()
+{
+    // don't assign to csubstr rem: otherwise, gcc12,13,14 -O3 -m32 misbuilds
+    if(m_evt_handler->m_curr->line_contents.rem.len > 0)
+    {
+        if(m_evt_handler->m_curr->line_contents.rem.str[0] == ' ' || m_evt_handler->m_curr->line_contents.rem.str[0] == '\t')
+        {
+            _c4dbgpf("starts with whitespace: '{}'", _c4prc(m_evt_handler->m_curr->line_contents.rem.str[0]));
+            _skipchars(" \t");
+        }
+        // comments
+        if(m_evt_handler->m_curr->line_contents.rem.begins_with('#'))
+        {
+            _c4dbgpf("it's a comment: {}", m_evt_handler->m_curr->line_contents.rem);
+            _line_progressed(m_evt_handler->m_curr->line_contents.rem.len);
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_colon()
+{
+    size_t curr = m_evt_handler->m_curr->pos.line;
+    if(m_prev_colon != npos)
+    {
+        if(curr == m_prev_colon)
+            _c4err("two colons on same line");
+    }
+    m_prev_colon = curr;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_add_annotation(Annotation *C4_RESTRICT dst, csubstr str, size_t indentation, size_t line)
+{
+    _c4dbgpf("store annotation[{}]: '{}' indentation={} line={}", dst->num_entries, str, indentation, line);
+    if(C4_UNLIKELY(dst->num_entries >= C4_COUNTOF(dst->annotations))) // NOLINT(bugprone-sizeof-expression)
+        _c4err("too many annotations");
+    dst->annotations[dst->num_entries].str = str;
+    dst->annotations[dst->num_entries].indentation = indentation;
+    dst->annotations[dst->num_entries].line = line;
+    ++dst->num_entries;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_clear_annotations(Annotation *C4_RESTRICT dst)
+{
+    dst->num_entries = 0;
+}
+
+#ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_handle_indentation_from_annotations()
+{
+    if(m_pending_anchors.num_entries == 1u || m_pending_tags.num_entries == 1u)
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_anchors.num_entries < 2u && m_pending_tags.num_entries < 2u);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_anchors.annotations[0].line < m_evt_handler->m_curr->pos.line);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_tags.annotations[1].line < m_evt_handler->m_curr->pos.line);
+        size_t to_skip = m_evt_handler->m_curr->indref;
+        if(m_pending_anchors.num_entries)
+            to_skip = m_pending_anchors.annotations[0].indentation > to_skip ? m_pending_anchors.annotations[0].indentation : to_skip;
+        if(m_pending_tags.num_entries)
+            to_skip = m_pending_tags.annotations[0].indentation > to_skip ? m_pending_tags.annotations[0].indentation : to_skip;
+        _c4dbgpf("annotations pending, skip indentation up to {}!", to_skip);
+        _maybe_skipchars_up_to(' ', to_skip);
+        return true;
+    }
+    return false;
+}
+#endif
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_annotations_require_key_container() const
+{
+    return m_pending_tags.num_entries > 1 || m_pending_anchors.num_entries > 1;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_check_tag(csubstr tag)
+{
+    if(!tag.begins_with("!<"))
+    {
+        if(C4_UNLIKELY(tag.first_of("[]{},") != npos))
+            _RYML_CB_ERR_(m_evt_handler->m_stack.m_callbacks, "tags must not contain any of '[]{},'", m_evt_handler->m_curr->pos);
+    }
+    else
+    {
+        if(C4_UNLIKELY(!tag.ends_with('>')))
+            _RYML_CB_ERR_(m_evt_handler->m_stack.m_callbacks, "malformed tag", m_evt_handler->m_curr->pos);
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_annotations_before_blck_key_scalar()
+{
+    _c4dbgpf("annotations_before_blck_key_scalar, node={}", m_evt_handler->m_curr->node_id);
+    if(m_pending_tags.num_entries)
+    {
+        _c4dbgpf("annotations_before_blck_key_scalar, #tags={}", m_pending_tags.num_entries);
+        if(C4_LIKELY(m_pending_tags.num_entries == 1))
+        {
+            _check_tag(m_pending_tags.annotations[0].str);
+            m_evt_handler->set_key_tag(m_pending_tags.annotations[0].str);
+            _clear_annotations(&m_pending_tags);
+        }
+        else
+        {
+            _c4err("too many tags");
+        }
+    }
+    if(m_pending_anchors.num_entries)
+    {
+        _c4dbgpf("annotations_before_blck_key_scalar, #anchors={}", m_pending_anchors.num_entries);
+        if(C4_LIKELY(m_pending_anchors.num_entries == 1))
+        {
+            m_evt_handler->set_key_anchor(m_pending_anchors.annotations[0].str);
+            _clear_annotations(&m_pending_anchors);
+        }
+        else
+        {
+            _c4err("too many anchors");
+        }
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_annotations_before_blck_val_scalar()
+{
+    _c4dbgpf("annotations_before_blck_val_scalar, node={}", m_evt_handler->m_curr->node_id);
+    if(m_pending_tags.num_entries)
+    {
+        _c4dbgpf("annotations_before_blck_val_scalar, #tags={}", m_pending_tags.num_entries);
+        if(C4_LIKELY(m_pending_tags.num_entries == 1))
+        {
+            _check_tag(m_pending_tags.annotations[0].str);
+            m_evt_handler->set_val_tag(m_pending_tags.annotations[0].str);
+            _clear_annotations(&m_pending_tags);
+        }
+        else
+        {
+            _c4err("too many tags");
+        }
+    }
+    if(m_pending_anchors.num_entries)
+    {
+        _c4dbgpf("annotations_before_blck_val_scalar, #anchors={}", m_pending_anchors.num_entries);
+        if(C4_LIKELY(m_pending_anchors.num_entries == 1))
+        {
+            m_evt_handler->set_val_anchor(m_pending_anchors.annotations[0].str);
+            _clear_annotations(&m_pending_anchors);
+        }
+        else
+        {
+            _c4err("too many anchors");
+        }
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_annotations_before_start_mapblck(size_t current_line)
+{
+    _c4dbgpf("annotations_before_start_mapblck, current_line={}", current_line);
+    if(m_pending_tags.num_entries == 2)
+    {
+        _c4dbgp("2 tags, setting entry 0");
+        _check_tag(m_pending_tags.annotations[0].str);
+        m_evt_handler->set_val_tag(m_pending_tags.annotations[0].str);
+    }
+    else if(m_pending_tags.num_entries == 1)
+    {
+        _c4dbgpf("1 tag. line={}, curr={}", m_pending_tags.annotations[0].line);
+        if(m_pending_tags.annotations[0].line < current_line)
+        {
+            _c4dbgp("...tag is for the map. setting it.");
+            _check_tag(m_pending_tags.annotations[0].str);
+            m_evt_handler->set_val_tag(m_pending_tags.annotations[0].str);
+            _clear_annotations(&m_pending_tags);
+        }
+    }
+    //
+    if(m_pending_anchors.num_entries == 2)
+    {
+        _c4dbgp("2 anchors, setting entry 0");
+        m_evt_handler->set_val_anchor(m_pending_anchors.annotations[0].str);
+    }
+    else if(m_pending_anchors.num_entries == 1)
+    {
+        _c4dbgpf("1 anchor. line={}, curr={}", m_pending_anchors.annotations[0].line);
+        if(m_pending_anchors.annotations[0].line < current_line)
+        {
+            _c4dbgp("...anchor is for the map. setting it.");
+            m_evt_handler->set_val_anchor(m_pending_anchors.annotations[0].str);
+            _clear_annotations(&m_pending_anchors);
+        }
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_annotations_before_start_mapblck_as_key()
+{
+    _c4dbgp("annotations_before_start_mapblck_as_key");
+    if(m_pending_tags.num_entries == 2)
+    {
+        _check_tag(m_pending_tags.annotations[0].str);
+        m_evt_handler->set_key_tag(m_pending_tags.annotations[0].str);
+    }
+    if(m_pending_anchors.num_entries == 2)
+    {
+        m_evt_handler->set_key_anchor(m_pending_anchors.annotations[0].str);
+    }
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_annotations_and_indentation_after_start_mapblck(size_t key_indentation, size_t key_line)
+{
+    _c4dbgp("annotations_after_start_mapblck");
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_tags.num_entries <= 2);
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_anchors.num_entries <= 2);
+    if(m_pending_anchors.num_entries || m_pending_tags.num_entries)
+    {
+        key_indentation = _select_indentation_from_annotations(key_indentation, key_line);
+        switch(m_pending_tags.num_entries)
+        {
+        case 1u:
+            _check_tag(m_pending_tags.annotations[0].str);
+            m_evt_handler->set_key_tag(m_pending_tags.annotations[0].str);
+            _clear_annotations(&m_pending_tags);
+            break;
+        case 2u:
+            _check_tag(m_pending_tags.annotations[1].str);
+            m_evt_handler->set_key_tag(m_pending_tags.annotations[1].str);
+            _clear_annotations(&m_pending_tags);
+            break;
+        }
+        switch(m_pending_anchors.num_entries)
+        {
+        case 1u:
+            m_evt_handler->set_key_anchor(m_pending_anchors.annotations[0].str);
+            _clear_annotations(&m_pending_anchors);
+            break;
+        case 2u:
+            m_evt_handler->set_key_anchor(m_pending_anchors.annotations[1].str);
+            _clear_annotations(&m_pending_anchors);
+            break;
+        }
+    }
+    _set_indentation(key_indentation);
+}
+
+template<class EventHandler>
+size_t ParseEngine<EventHandler>::_select_indentation_from_annotations(size_t val_indentation, size_t val_line)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_pending_tags.num_entries || m_pending_anchors.num_entries);
+    // select the left-most annotation on the max line
+    auto const *C4_RESTRICT curr = m_pending_anchors.num_entries ? &m_pending_anchors.annotations[0] : &m_pending_tags.annotations[0];
+    for(size_t i = 0; i < m_pending_anchors.num_entries; ++i)
+    {
+        auto const& C4_RESTRICT ann = m_pending_anchors.annotations[i];
+        if(ann.line > curr->line)
+            curr = &ann;
+        else if(ann.indentation < curr->indentation)
+            curr = &ann;
+    }
+    for(size_t j = 0; j < m_pending_tags.num_entries; ++j)
+    {
+        auto const& C4_RESTRICT ann = m_pending_tags.annotations[j];
+        if(ann.line > curr->line)
+            curr = &ann;
+        else if(ann.indentation < curr->indentation)
+            curr = &ann;
+    }
+    return curr->line < val_line ? val_indentation : curr->indentation;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_directive(csubstr rem)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.is_sub(m_evt_handler->m_curr->line_contents.rem));
+    const size_t pos = rem.find('#');
+    _c4dbgpf("handle_directive: pos={} rem={}", pos, rem);
+    if(pos == npos) // no comments
+    {
+        m_evt_handler->add_directive(rem);
+        _line_progressed(rem.len);
+    }
+    else
+    {
+        csubstr to_comment = rem.first(pos);
+        csubstr trimmed = to_comment.trimr(" \t");
+        m_evt_handler->add_directive(trimmed);
+        _line_progressed(pos);
+        _skip_comment();
+    }
+}
+
+template<class EventHandler>
+bool ParseEngine<EventHandler>::_handle_bom()
+{
+    const csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(rem.len)
+    {
+        const csubstr rest = rem.sub(1);
+        // https://yaml.org/spec/1.2.2/#52-character-encodings
+        #define _rymlisascii(c) ((c) > '\0' && (c) <= '\x7f') // is the character ASCII?
+        if(rem.begins_with({"\x00\x00\xfe\xff", 4}) || (rem.begins_with({"\x00\x00\x00", 3}) && rem.len >= 4u && _rymlisascii(rem.str[3])))
+        {
+            _c4dbgp("byte order mark: UTF32BE");
+            _handle_bom(UTF32BE);
+            _line_progressed(4);
+            return true;
+        }
+        else if(rem.begins_with("\xff\xfe\x00\x00") || (rest.begins_with({"\x00\x00\x00", 3}) && rem.len >= 4u && _rymlisascii(rem.str[0])))
+        {
+            _c4dbgp("byte order mark: UTF32LE");
+            _handle_bom(UTF32LE);
+            _line_progressed(4);
+            return true;
+        }
+        else if(rem.begins_with("\xfe\xff") || (rem.begins_with('\x00') && rem.len >= 2u && _rymlisascii(rem.str[1])))
+        {
+            _c4dbgp("byte order mark: UTF16BE");
+            _handle_bom(UTF16BE);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with("\xff\xfe") || (rest.begins_with('\x00') && rem.len >= 2u && _rymlisascii(rem.str[0])))
+        {
+            _c4dbgp("byte order mark: UTF16LE");
+            _handle_bom(UTF16LE);
+            _line_progressed(2);
+            return true;
+        }
+        else if(rem.begins_with("\xef\xbb\xbf"))
+        {
+            _c4dbgp("byte order mark: UTF8");
+            _handle_bom(UTF8);
+            _line_progressed(3);
+            return true;
+        }
+        #undef _rymlisascii
+    }
+    return false;
+}
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_bom(Encoding_e enc)
+{
+    if(m_encoding == NOBOM)
+    {
+        const bool is_beginning_of_file = m_evt_handler->m_curr->line_contents.rem.str == m_buf.str;
+        if(enc == UTF8 || is_beginning_of_file)
+            m_encoding = enc;
+        else
+            _c4err("non-UTF8 byte order mark can appear only at the beginning of the file");
+    }
+    else if(enc != m_encoding)
+    {
+        _c4err("byte order mark can only be set once");
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_seq_json()
+{
+seqjson_start:
+    _c4dbgpf("handle2_seq_json: node_id={} level={} indentation={}", m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL|RNXT));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RVAL) != has_all(RNXT));
+
+    _handle_flow_skip_whitespace();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto seqjson_again;
+
+    if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        const char first = rem.str[0];
+        _c4dbgpf("mapjson[RVAL]: '{}'", first);
+        switch(first)
+        {
+        case '"':
+        {
+            _c4dbgp("seqjson[RVAL]: scanning double-quoted scalar");
+            ScannedScalar sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+            break;
+        }
+        case '[':
+        {
+            _c4dbgp("seqjson[RVAL]: start child seqjson");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(1);
+            break;
+        }
+        case '{':
+        {
+            _c4dbgp("seqjson[RVAL]: start child mapjson");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RMAP|RKEY, RSEQ|RVAL|RNXT);
+            _line_progressed(1);
+            goto seqjson_finish;
+        }
+        case ']': // this happens on a trailing comma like ", ]"
+        {
+            _c4dbgp("seqjson[RVAL]: end!");
+            rem_flags(RSEQ);
+            m_evt_handler->end_seq();
+            _line_progressed(1);
+            if(!has_all(RSEQ|FLOW))
+                goto seqjson_finish;
+            break;
+        }
+        default:
+        {
+            ScannedScalar sc;
+            if(_scan_scalar_seq_json(&sc))
+            {
+                _c4dbgp("seqjson[RVAL]: it's a plain scalar.");
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        }
+    }
+    else // RNXT
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        const char first = rem.str[0];
+        _c4dbgpf("mapjson[RNXT]: '{}'", first);
+        switch(first)
+        {
+        case ',':
+        {
+            _c4dbgp("seqjson[RNXT]: expect next val");
+            addrem_flags(RVAL, RNXT);
+            m_evt_handler->add_sibling();
+            _line_progressed(1);
+            break;
+        }
+        case ']':
+        {
+            _c4dbgp("seqjson[RNXT]: end!");
+            m_evt_handler->end_seq();
+            _line_progressed(1);
+            goto seqjson_finish;
+        }
+        default:
+            _c4err("parse error");
+        }
+    }
+
+ seqjson_again:
+    _c4dbgt("seqjson: go again", 0);
+    if(_finished_line())
+    {
+        if(C4_LIKELY(!_finished_file()))
+        {
+            _line_ended();
+            _scan_line();
+            _c4dbgnextline();
+        }
+        else
+        {
+            _c4err("missing terminating ]");
+        }
+    }
+    goto seqjson_start;
+
+ seqjson_finish:
+    _c4dbgp("seqjson: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_map_json()
+{
+mapjson_start:
+    _c4dbgpf("handle2_map_json: node_id={} level={} indentation={}", m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RKCL|RVAL|RNXT));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, 1 == (has_any(RKEY) + has_any(RKCL) + has_any(RVAL) + has_any(RNXT)));
+
+    _handle_flow_skip_whitespace();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto mapjson_again;
+
+    if(has_any(RKEY))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapjson[RKEY]: '{}'", first);
+        switch(first)
+        {
+        case '"':
+        {
+            _c4dbgp("mapjson[RKEY]: scanning double-quoted scalar");
+            ScannedScalar sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+            m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+            addrem_flags(RKCL, RKEY);
+            break;
+        }
+        case '}': // this happens on a trailing comma like ", }"
+        {
+            _c4dbgp("mapjson[RKEY]: end!");
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapjson_finish;
+        }
+        default:
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapjson[RVAL]: '{}'", first);
+        switch(first)
+        {
+        case '"':
+        {
+            _c4dbgp("mapjson[RVAL]: scanning double-quoted scalar");
+            ScannedScalar sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+            break;
+        }
+        case '[':
+        {
+            _c4dbgp("mapjson[RVAL]: start val seqjson");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_seq_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RSEQ|RVAL, RMAP|RNXT);
+            _line_progressed(1);
+            goto mapjson_finish;
+        }
+        case '{':
+        {
+            _c4dbgp("mapjson[RVAL]: start val mapjson");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(1);
+            // keep going in this function
+            break;
+        }
+        default:
+        {
+            ScannedScalar sc;
+            if(_scan_scalar_map_json(&sc))
+            {
+                _c4dbgp("mapjson[RVAL]: plain scalar.");
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+            break;
+        }
+        }
+    }
+    else if(has_any(RKCL)) // read the key colon
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapjson[RKCL]: '{}'", first);
+        if(first == ':')
+        {
+            _c4dbgp("mapjson[RKCL]: found the colon");
+            addrem_flags(RVAL, RKCL);
+            _line_progressed(1);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _c4dbgpf("mapjson[RNXT]: '{}'", rem.str[0]);
+        if(rem.begins_with(','))
+        {
+            _c4dbgp("mapjson[RNXT]: expect next keyval");
+            m_evt_handler->add_sibling();
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(1);
+        }
+        else if(rem.begins_with('}'))
+        {
+            _c4dbgp("mapjson[RNXT]: end!");
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapjson_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+ mapjson_again:
+    _c4dbgt("mapjson: go again", 0);
+    if(_finished_line())
+    {
+        if(C4_LIKELY(!_finished_file()))
+        {
+            _line_ended();
+            _scan_line();
+            _c4dbgnextline();
+        }
+        else
+        {
+            _c4err("missing terminating }");
+        }
+    }
+    goto mapjson_start;
+
+ mapjson_finish:
+    _c4dbgp("mapjson: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_seq_imap()
+{
+seqimap_start:
+    _c4dbgpf("handle2_seq_imap: node_id={} level={} indref={}", m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RSEQIMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL|RNXT|QMRK|RKCL));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, 1 == has_all(RVAL) + has_all(RNXT) + has_all(QMRK) + has_all(RKCL));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 3);
+
+    _handle_flow_skip_whitespace();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto seqimap_again;
+
+    if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        const char first = rem.str[0];
+        _c4dbgpf("seqimap[RVAL]: '{}'", _c4prc(first));
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("seqimap[RVAL]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+            m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("seqimap[RVAL]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_map_flow(&sc))
+        {
+            _c4dbgp("seqimap[RVAL]: it's a scalar.");
+            csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_val_scalar_plain(maybe_filtered);
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("seqimap[RVAL]: start child seqflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(RVAL, RNXT|RSEQIMAP);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto seqimap_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("seqimap[RVAL]: start child mapflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RMAP|RKEY, RSEQ|RVAL|RSEQIMAP|RNXT);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto seqimap_finish;
+        }
+        else if(first == ',' || first == ']')
+        {
+            _c4dbgp("seqimap[RVAL]: finish without val.");
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgp("seqimap[RVAL]: anchor!");
+            m_evt_handler->set_val_anchor(anchor);
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_seq();
+            _c4dbgp("seqimap[RVAL]: ref!");
+            m_evt_handler->set_val_ref(ref);
+            addrem_flags(RNXT, RVAL);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        const char first = rem.str[0];
+        _c4dbgpf("seqimap[RNXT]: '{}'", _c4prc(first));
+        if(first == ',' || first == ']')
+        {
+            // we may get here because a map or a seq started and we
+            // return later
+            _c4dbgp("seqimap: done");
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(QMRK))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(QMRK));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        const char first = rem.str[0];
+        _c4dbgpf("seqimap[QMRK]: '{}'", _c4prc(first));
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("seqimap[QMRK]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+            m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+            goto seqimap_again;
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("seqimap[QMRK]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+            m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+            goto seqimap_again;
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_map_flow(&sc))
+        {
+            _c4dbgp("seqimap[QMRK]: it's a scalar.");
+            csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_key_scalar_plain(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+            goto seqimap_again;
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("seqimap[QMRK]: start child seqflow");
+            addrem_flags(RKCL, QMRK);
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RSEQ|RVAL, RKCL|RSEQIMAP);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto seqimap_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("seqimap[QMRK]: start child mapflow");
+            addrem_flags(RKCL, QMRK);
+            m_evt_handler->begin_map_key_flow();
+            addrem_flags(RMAP|RKEY, RSEQ|RKCL|RSEQIMAP);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto seqimap_finish;
+        }
+        else if(first == ',' || first == ']')
+        {
+            _c4dbgp("seqimap[QMRK]: finish without key.");
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgp("seqimap[QMRK]: anchor!");
+            m_evt_handler->set_key_anchor(anchor);
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_seq();
+            _c4dbgp("seqimap[QMRK]: ref!");
+            m_evt_handler->set_key_ref(ref);
+            addrem_flags(RKCL, QMRK);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RKCL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKCL));
+        const char first = rem.str[0];
+        _c4dbgpf("seqimap[RKCL]: '{}'", _c4prc(first));
+        if(first == ':')
+        {
+            _c4dbgp("seqimap[RKCL]: found ':'");
+            addrem_flags(RVAL, RKCL);
+            _line_progressed(1);
+            goto seqimap_again;
+        }
+        else if(first == ',' || first == ']')
+        {
+            _c4dbgp("seqimap[RKCL]: found ','. finish without val");
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            goto seqimap_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+ seqimap_again:
+    _c4dbgt("seqimap: go again", 0);
+    if(_finished_line())
+    {
+        if(C4_LIKELY(!_finished_file()))
+        {
+            _line_ended();
+            _scan_line();
+            _c4dbgnextline();
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    goto seqimap_start;
+
+ seqimap_finish:
+    _c4dbgp("seqimap: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_seq_flow()
+{
+seqflow_start:
+    _c4dbgpf("handle2_seq_flow: node_id={} level={} indentation={}", m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL|RNXT));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RVAL) != has_all(RNXT));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->indref != npos);
+
+    _handle_flow_skip_whitespace();
+    // don't assign to csubstr rem: otherwise, gcc12,13,14 -O3 -m32 misbuilds
+    if(!m_evt_handler->m_curr->line_contents.rem.len)
+        goto seqflow_again;
+
+    if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        const char first = m_evt_handler->m_curr->line_contents.rem.str[0];
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("seqflow[RVAL]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+            m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("seqflow[RVAL]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_seq_flow(&sc))
+        {
+            _c4dbgp("seqflow[RVAL]: it's a scalar.");
+            csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_val_scalar_plain(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("seqflow[RVAL]: start child seqflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_seq_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RVAL, RNXT);
+            _line_progressed(1);
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("seqflow[RVAL]: start child mapflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RMAP|RKEY, RSEQ|RVAL|RNXT);
+            _line_progressed(1);
+            goto seqflow_finish;
+        }
+        else if(first == ']') // this happens on a trailing comma like ", ]"
+        {
+            _c4dbgp("seqflow[RVAL]: end!");
+            _line_progressed(1);
+            m_evt_handler->end_seq();
+            goto seqflow_finish;
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_seq();
+            _c4dbgpf("seqflow[RVAL]: ref! [{}]~~~{}~~~", ref.len, ref);
+            m_evt_handler->set_val_ref(ref);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("seqflow[RVAL]: anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            m_evt_handler->set_val_anchor(anchor);
+            if(_maybe_scan_following_comma())
+            {
+                _c4dbgp("seqflow[RVAL]: empty scalar!");
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+            }
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("seqflow[RVAL]: tag! [{}]~~~{}~~~", tag.len, tag);
+            _check_tag(tag);
+            m_evt_handler->set_val_tag(tag);
+            if(_maybe_scan_following_comma())
+            {
+                _c4dbgp("seqflow[RVAL]: empty scalar!");
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+            }
+        }
+        else if(first == ':')
+        {
+            _c4dbgpf("seqflow[RVAL]: actually seqimap at node[{}], with empty key", m_evt_handler->m_curr->node_id);
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RSEQIMAP|RVAL, RSEQ|RNXT);
+            _line_progressed(1);
+            goto seqflow_finish;
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("seqflow[RVAL]: start child mapflow, explicit key");
+            addrem_flags(RNXT, RVAL);
+            m_was_inside_qmrk = true;
+            m_evt_handler->begin_map_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RSEQIMAP|QMRK, RSEQ|RNXT);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            goto seqflow_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else // RNXT
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        const char first = m_evt_handler->m_curr->line_contents.rem.str[0];
+        if(first == ',')
+        {
+            _c4dbgp("seqflow[RNXT]: expect next val");
+            addrem_flags(RVAL, RNXT);
+            m_evt_handler->add_sibling();
+            _line_progressed(1);
+        }
+        else if(first == ']')
+        {
+            _c4dbgp("seqflow[RNXT]: end!");
+            m_evt_handler->end_seq();
+            _line_progressed(1);
+            goto seqflow_finish;
+        }
+        else if(first == ':')
+        {
+            _c4dbgpf("seqflow[RNXT]: actually seqimap at node[{}]", m_evt_handler->m_curr->node_id);
+            m_evt_handler->actually_val_is_first_key_of_new_map_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            addrem_flags(RSEQIMAP|RVAL, RNXT);
+            goto seqflow_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+ seqflow_again:
+    _c4dbgt("seqflow: go again", 0);
+    if(_finished_line())
+    {
+        if(C4_LIKELY(!_finished_file()))
+        {
+            _line_ended();
+            _scan_line();
+            _c4dbgnextline();
+        }
+        else
+        {
+            _c4err("missing terminating ]");
+        }
+    }
+    goto seqflow_start;
+
+ seqflow_finish:
+    _c4dbgp("seqflow: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_map_flow()
+{
+mapflow_start:
+    _c4dbgpf("handle2_map_flow: node_id={} level={} indentation={}", m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(FLOW));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RKCL|RVAL|RNXT|QMRK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, 1 == (has_any(RKEY) + has_any(RKCL) + has_any(RVAL) + has_any(RNXT) + has_any(QMRK)));
+
+    _handle_flow_skip_whitespace();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto mapflow_again;
+
+    if(has_any(RKEY))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapflow[RKEY]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapflow[RKEY]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+            m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+            addrem_flags(RKCL, RKEY|QMRK);
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapflow[RKEY]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+            m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+            addrem_flags(RKCL, RKEY|QMRK);
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_map_flow(&sc))
+        {
+            _c4dbgp("mapflow[RKEY]: plain scalar");
+            csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_key_scalar_plain(maybe_filtered);
+            addrem_flags(RKCL, RKEY|QMRK);
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("mapflow[RKEY]: explicit key");
+            _line_progressed(1);
+            addrem_flags(QMRK, RKEY);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == ':')
+        {
+            _c4dbgp("mapflow[RKEY]: setting empty key");
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RVAL, RKEY|QMRK);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == ',')
+        {
+            _c4dbgp("mapflow[RKEY]: empty key+val!");
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_evt_handler->set_val_scalar_plain_empty();
+            addrem_flags(RNXT, RKEY|QMRK);
+            // keep going in this function
+        }
+        else if(first == '}') // this happens on a trailing comma like ", }"
+        {
+            _c4dbgp("mapflow[RKEY]: end!");
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapflow[RKEY]: key anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            m_evt_handler->set_key_anchor(anchor);
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapflow[RKEY]: key ref! [{}]~~~{}~~~", ref.len, ref);
+            m_evt_handler->set_key_ref(ref);
+            addrem_flags(RKCL, RKEY);
+        }
+        else if(first == '[')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree sink. Other sink types may be
+            // able to handle it.
+            _c4dbgp("mapflow[RKEY]: start child seqflow (!)");
+            addrem_flags(RKCL, RKEY);
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RSEQ|RVAL, RMAP|RKCL);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == '{')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree sink. Other sink types may be
+            // able to handle it.
+            _c4dbgp("mapflow[RKEY]: start child mapflow (!)");
+            addrem_flags(RKCL, RKEY);
+            m_evt_handler->begin_map_key_flow();
+            addrem_flags(RKEY, RVAL|RKCL);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            // keep going in this function
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapflow[RKEY]: tag! [{}]~~~{}~~~", tag.len, tag);
+            _check_tag(tag);
+            m_evt_handler->set_key_tag(tag);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RKCL)) // read the key colon
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapflow[RKCL]: '{}'", first);
+        if(first == ':')
+        {
+            _c4dbgp("mapflow[RKCL]: found the colon");
+            addrem_flags(RVAL, RKCL);
+            _line_progressed(1);
+        }
+        else if(first == '}')
+        {
+            _c4dbgp("mapflow[RKCL]: end with missing val!");
+            addrem_flags(RVAL, RKCL);
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == ',')
+        {
+            _c4dbgp("mapflow[RKCL]: got comma. val is missing");
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->add_sibling();
+            addrem_flags(RKEY, RKCL);
+            _line_progressed(1);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        const char first = rem.str[0];
+        _c4dbgpf("mapflow[RVAL]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapflow[RVAL]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+            m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapflow[RVAL]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_map_flow(&sc))
+        {
+            _c4dbgp("mapflow[RVAL]: plain scalar.");
+            csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_val_scalar_plain(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("mapflow[RVAL]: start val seqflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_seq_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RSEQ|RVAL, RMAP|RNXT);
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("mapflow[RVAL]: start val mapflow");
+            addrem_flags(RNXT, RVAL);
+            m_evt_handler->begin_map_val_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(1);
+            // keep going in this function
+        }
+        else if(first == '}')
+        {
+            _c4dbgp("mapflow[RVAL]: end!");
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == ',')
+        {
+            _c4dbgp("mapflow[RVAL]: empty val!");
+            m_evt_handler->set_val_scalar_plain_empty();
+            addrem_flags(RNXT, RVAL);
+            // keep going in this function
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapflow[RVAL]: key ref! [{}]~~~{}~~~", ref.len, ref);
+            m_evt_handler->set_val_ref(ref);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapflow[RVAL]: key anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            m_evt_handler->set_val_anchor(anchor);
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapflow[RVAL]: tag! [{}]~~~{}~~~", tag.len, tag);
+            _check_tag(tag);
+            m_evt_handler->set_val_tag(tag);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _c4dbgpf("mapflow[RNXT]: '{}'", rem.str[0]);
+        if(rem.begins_with(','))
+        {
+            _c4dbgp("mapflow[RNXT]: expect next keyval");
+            m_evt_handler->add_sibling();
+            addrem_flags(RKEY, RNXT);
+            _line_progressed(1);
+        }
+        else if(rem.begins_with('}'))
+        {
+            _c4dbgp("mapflow[RNXT]: end!");
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(QMRK))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        const char first = rem.str[0];
+        _c4dbgpf("mapflow[QMRK]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapflow[QMRK]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+            m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapflow[QMRK]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+            m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+        }
+        // block scalars (ie | and >) cannot appear in flow containers
+        else if(_scan_scalar_plain_map_flow(&sc))
+        {
+            _c4dbgp("mapflow[QMRK]: plain scalar");
+            csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            m_evt_handler->set_key_scalar_plain(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+        }
+        else if(first == ':')
+        {
+            _c4dbgp("mapflow[QMRK]: setting empty key");
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RVAL, QMRK);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '}') // this happens on a trailing comma like ", }"
+        {
+            _c4dbgp("mapflow[QMRK]: end!");
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->end_map();
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == ',')
+        {
+            _c4dbgp("mapflow[QMRK]: empty key+val!");
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_evt_handler->set_val_scalar_plain_empty();
+            addrem_flags(RNXT, QMRK);
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapflow[QMRK]: key anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            m_evt_handler->set_key_anchor(anchor);
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapflow[QMRK]: key ref! [{}]~~~{}~~~", ref.len, ref);
+            m_evt_handler->set_key_ref(ref);
+            addrem_flags(RKCL, QMRK);
+        }
+        else if(first == '[')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree sink. Other sink types may be
+            // able to handle it.
+            _c4dbgp("mapflow[QMRK]: start child seqflow (!)");
+            addrem_flags(RKCL, QMRK);
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RSEQ|RVAL, RMAP|RKCL);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto mapflow_finish;
+        }
+        else if(first == '{')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree sink. Other sink types may be
+            // able to handle it.
+            _c4dbgp("mapflow[QMRK]: start child mapflow (!)");
+            addrem_flags(RKCL, QMRK);
+            m_evt_handler->begin_map_key_flow();
+            _set_indentation(m_evt_handler->m_parent->indref);
+            addrem_flags(RKEY, RKCL);
+            _line_progressed(1);
+            // keep going in this function
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapflow[QMRK]: tag! [{}]~~~{}~~~", tag.len, tag);
+            _check_tag(tag);
+            m_evt_handler->set_key_tag(tag);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+ mapflow_again:
+    _c4dbgt("mapflow: go again", 0);
+    if(_finished_line())
+    {
+        if(C4_LIKELY(!_finished_file()))
+        {
+            _line_ended();
+            _scan_line();
+            _c4dbgnextline();
+        }
+        else
+        {
+            _c4err("missing terminating }");
+        }
+    }
+    goto mapflow_start;
+
+ mapflow_finish:
+    _c4dbgp("mapflow: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_seq_block()
+{
+seqblck_start:
+    _c4dbgpf("handle2_seq_block: seq_id={} node_id={} level={} indent={}", m_evt_handler->m_parent->node_id, m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RSEQ));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RVAL|RNXT));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, 1 == (has_any(RVAL) + has_any(RNXT)));
+
+    _maybe_skip_comment();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto seqblck_again;
+
+    if(has_any(RVAL))
+    {
+        _c4dbgpf("seqblck[RVAL]: col={}", m_evt_handler->m_curr->pos.col);
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            _c4dbgpf("seqblck[RVAL]: indref={} indentation={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->line_contents.indentation);
+            if(m_evt_handler->m_curr->indentation_ge())
+            {
+                _c4dbgpf("seqblck[RVAL]: skip {} from indentation", m_evt_handler->m_curr->line_contents.indentation);
+                _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto seqblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("seqblck[RVAL]: smaller indentation!");
+                _handle_indentation_pop_from_block_seq();
+                goto seqblck_finish;
+            }
+            else if(m_evt_handler->m_curr->line_contents.indentation == npos)
+            {
+                _c4dbgp("seqblck[RVAL]: empty line!");
+                _line_progressed(m_evt_handler->m_curr->line_contents.rem.len);
+                goto seqblck_again;
+            }
+        }
+        #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+        else
+        {
+            // accomodate annotation on the previous line. eg:
+            // - &elm
+            //   foo            # <-- on this line
+            // - &elm
+            //   &foo foo: bar  # <-- on this line
+            if(rem.str[0] == ' ')
+            {
+                if(_handle_indentation_from_annotations())
+                {
+                    _c4dbgp("seqblck[RVAL]: annotations!");
+                    rem = m_evt_handler->m_curr->line_contents.rem;
+                    if(!rem.len)
+                        goto seqblck_again;
+                }
+            }
+        }
+        #endif
+        _RYML_CB_ASSERT(callbacks(), rem.len);
+        _c4dbgpf("seqblck[RVAL]: '{}' node_id={}", rem.str[0], m_evt_handler->m_curr->node_id);
+        const char first = rem.str[0];
+        const size_t startline = m_evt_handler->m_curr->pos.line;
+        // warning: the gcc optimizer on x86 builds is brittle with
+        // this function:
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col();
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("seqblck[RVAL]: single-quoted scalar");
+            sc = _scan_scalar_squot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("seqblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc); // VAL!
+                m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4dbgp("seqblck[RVAL]: start mapblck, set scalar as key");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_start_mapblck(startline);
+                _handle_colon();
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc); // KEY!
+                m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                addrem_flags(RMAP|RVAL, RSEQ|RNXT);
+                _maybe_skip_whitespace_tokens();
+                goto seqblck_finish;
+            }
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("seqblck[RVAL]: double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("seqblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc); // VAL!
+                m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4dbgp("seqblck[RVAL]: start mapblck, set scalar as key");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_start_mapblck(startline);
+                _handle_colon();
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc); // KEY!
+                m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                addrem_flags(RMAP|RVAL, RSEQ|RNXT);
+                _maybe_skip_whitespace_tokens();
+                goto seqblck_finish;
+            }
+        }
+        // block scalars can only appear as keys when in QMRK scope
+        // (ie, after ? tokens), so no need to scan following colon in
+        // here.
+        else if(first == '|')
+        {
+            _c4dbgp("seqblck[RVAL]: block-literal scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            _handle_annotations_before_blck_val_scalar();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_literal(sb);
+            m_evt_handler->set_val_scalar_literal(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '>')
+        {
+            _c4dbgp("seqblck[RVAL]: block-folded scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            _handle_annotations_before_blck_val_scalar();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_folded(sb);
+            m_evt_handler->set_val_scalar_folded(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(_scan_scalar_plain_seq_blck(&sc))
+        {
+            _c4dbgp("seqblck[RVAL]: plain scalar.");
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("seqblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);  // VAL!
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                if(startindent > m_evt_handler->m_curr->indref)
+                {
+                    _c4dbgp("seqblck[RVAL]: start mapblck, set scalar as key");
+                    addrem_flags(RNXT, RVAL);
+                    _handle_annotations_before_start_mapblck(startline);
+                    _handle_colon();
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref);  // KEY!
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    addrem_flags(RMAP|RVAL, RSEQ|RNXT);
+                    _maybe_skip_whitespace_tokens();
+                    goto seqblck_finish;
+                }
+                else if(m_evt_handler->m_parent && m_evt_handler->m_parent->indref == startindent && has_any(RMAP|BLCK, m_evt_handler->m_parent))
+                {
+                    _c4dbgp("seqblck[RVAL]: empty val + end indentless seq + set key");
+                    m_evt_handler->set_val_scalar_plain_empty();
+                    m_evt_handler->end_seq();
+                    m_evt_handler->add_sibling();
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref);  // KEY!
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    addrem_flags(RVAL, RNXT|RKEY);
+                    _maybe_skip_whitespace_tokens();
+                    goto seqblck_finish;
+                }
+                else
+                {
+                    _c4err("parse error");
+                }
+            }
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("seqblck[RVAL]: start child seqflow");
+            addrem_flags(RNXT, RVAL);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(FLOW|RVAL, BLCK|RNXT);
+            _line_progressed(1);
+            _set_indentation(m_evt_handler->m_parent->indref + 1u);
+            goto seqblck_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("seqblck[RVAL]: start child mapflow");
+            addrem_flags(RNXT, RVAL);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RMAP|RKEY|FLOW, BLCK|RSEQ|RVAL|RNXT);
+            _line_progressed(1);
+            _set_indentation(m_evt_handler->m_parent->indref + 1u);
+            goto seqblck_finish;
+        }
+        else if(first == '-')
+        {
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("seqblck[RVAL]: prev val was empty");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_scalar_plain_empty();
+                // keep in RVAL, but for the next sibling
+                m_evt_handler->add_sibling();
+            }
+            else
+            {
+                _c4dbgp("seqblck[RVAL]: start child seqblck");
+                _RYML_CB_ASSERT(this->callbacks(), startindent > m_evt_handler->m_curr->indref);
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->begin_seq_val_block();
+                addrem_flags(RVAL, RNXT);
+                _save_indentation();
+                // keep going on inside this function
+            }
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == ':')
+        {
+            _c4dbgp("seqblck[RVAL]: start child mapblck with empty key");
+            addrem_flags(RNXT, RVAL);
+            _handle_annotations_before_start_mapblck(startline);
+            _handle_colon();
+            m_evt_handler->begin_map_val_block();
+            _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RMAP|RVAL, RSEQ|RNXT);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            goto seqblck_finish;
+        }
+        else if(first == '&')
+        {
+            const csubstr anchor = _scan_anchor();
+            _c4dbgpf("seqblck[RVAL]: anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            // we need to buffer the anchors, as there may be two
+            // consecutive anchors in here
+            _add_annotation(&m_pending_anchors, anchor, startindent, startline);
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_seq();
+            _c4dbgpf("seqblck[RVAL]: ref! [{}]~~~{}~~~", ref.len, ref);
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("seqblck[RVAL]: set ref as val!");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_ref(ref);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4dbgp("seqblck[RVAL]: ref is key of map");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_start_mapblck(startline);
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_ref(ref);
+                addrem_flags(RMAP|RVAL, RSEQ|RNXT);
+                _set_indentation(startindent);
+                _maybe_skip_whitespace_tokens();
+                goto seqblck_finish;
+            }
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("seqblck[RVAL]: val tag! [{}]~~~{}~~~", tag.len, tag);
+            // we need to buffer the tags, as there may be two
+            // consecutive tags in here
+            _add_annotation(&m_pending_tags, tag, startindent, startline);
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("seqblck[RVAL]: start child mapblck, explicit key");
+            addrem_flags(RNXT, RVAL);
+            m_was_inside_qmrk = true;
+            m_evt_handler->begin_map_val_block();
+            addrem_flags(RMAP|QMRK, RSEQ|RNXT);
+            _save_indentation();
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            goto seqblck_finish;
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else // RNXT
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        //
+        // handle indentation
+        //
+        _c4dbgpf("seqblck[RNXT]: indref={} indentation={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->line_contents.indentation);
+        if(C4_LIKELY(_at_line_begin()))
+        {
+            _c4dbgp("seqblck[RNXT]: at line begin");
+            if(m_evt_handler->m_curr->indentation_ge())
+            {
+                _c4dbgpf("seqblck[RNXT]: skip {} from indref", m_evt_handler->m_curr->indref);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                _maybe_skip_whitespace_tokens();
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto seqblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("seqblck[RNXT]: smaller indentation!");
+                _handle_indentation_pop_from_block_seq();
+                if(has_all(RSEQ|BLCK))
+                {
+                    _c4dbgp("seqblck[RNXT]: still seqblck!");
+                    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RNXT));
+                    _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                    rem = m_evt_handler->m_curr->line_contents.rem;
+                    if(!rem.len)
+                        goto seqblck_again;
+                }
+                else
+                {
+                    _c4dbgp("seqblck[RNXT]: no longer seqblck!");
+                    goto seqblck_finish;
+                }
+            }
+            else if(m_evt_handler->m_curr->line_contents.indentation == npos)
+            {
+                _c4dbgpf("seqblck[RNXT]: blank line, len={}", m_evt_handler->m_curr->line_contents.rem);
+                _line_progressed(m_evt_handler->m_curr->line_contents.rem.len);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto seqblck_again;
+            }
+        }
+        else
+        {
+            _c4dbgp("seqblck[RNXT]: NOT at line begin");
+            if(!rem.begins_with_any(" \t"))
+            {
+                _c4err("parse error");
+            }
+            else
+            {
+                _skipchars(" \t");
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                {
+                    _c4dbgp("seqblck[RNXT]: again");
+                    goto seqblck_again;
+                }
+            }
+        }
+        //
+        // now handle the tokens
+        //
+        const char first = rem.str[0];
+        _c4dbgpf("seqblck[RNXT]: '{}' node_id={}", first, m_evt_handler->m_curr->node_id);
+        if(first == '-')
+        {
+            if(m_evt_handler->m_curr->indref > 0 || m_evt_handler->m_curr->line_contents.indentation > 0 || !_is_doc_begin_token(rem))
+            {
+                _c4dbgp("seqblck[RNXT]: expect next val");
+                addrem_flags(RVAL, RNXT);
+                m_evt_handler->add_sibling();
+                _line_progressed(1);
+                _maybe_skip_whitespace_tokens();
+            }
+            else
+            {
+                _c4dbgp("seqblck[RNXT]: start doc");
+                _start_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto seqblck_finish;
+            }
+        }
+        else if(first == ':')
+        {
+            // This happens for example in `- [a: b]: c` (after
+            // terminating the seq, ie, after `]`). All other cases
+            // (ie colon after scalars) are caught elsewhere (ie, in
+            // RVAL state).
+            auto const *C4_RESTRICT prev_state = m_evt_handler->m_parent;
+            if(C4_LIKELY(prev_state && (prev_state->flags & RMAP)))
+            {
+                _c4dbgp("seqblck[RNXT]: actually this seq was '?' key of parent map");
+                m_evt_handler->end_seq();
+                goto seqblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("seqblck[RNXT]: maybe doc?");
+            csubstr rs = rem.sub(1);
+            if(rs == ".." || rs.begins_with(".. "))
+            {
+                _c4dbgp("seqblck[RNXT]: end+start doc");
+                _end_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto seqblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else
+        {
+            // may be an indentless sequence nested in a map...
+            //if(m_evt_handler->m_stack.size() >= 2)
+            #ifdef RYML_DBG
+            char flagbuf_[128];
+            for(auto const& s : m_evt_handler->m_stack)
+            {
+                _dbg_printf("state[{}]: ind={} node={} flags={}\n", s.level, s.indref, s.node_id, detail::_parser_flags_to_str(flagbuf_, s.flags));
+            }
+            #endif
+            if(m_evt_handler->m_parent && has_all(RMAP|BLCK, m_evt_handler->m_parent) && m_evt_handler->m_curr->indref == m_evt_handler->m_parent->indref)
+            {
+                _c4dbgpf("seqblck[RNXT]: end indentless seq, go to parent={}. node={}", m_evt_handler->m_parent->node_id, m_evt_handler->m_curr->node_id);
+                _RYML_CB_ASSERT(this->callbacks(), m_evt_handler->m_curr != m_evt_handler->m_parent);
+                _handle_indentation_pop(m_evt_handler->m_parent);
+                _RYML_CB_ASSERT(this->callbacks(), has_all(RMAP|BLCK));
+                m_evt_handler->add_sibling();
+                addrem_flags(RKEY, RNXT);
+                goto seqblck_finish;
+            }
+            else //if(first != '*')
+            {
+                _c4err("parse error");
+            }
+        }
+    }
+
+ seqblck_again:
+    _c4dbgt("seqblck: go again", 0);
+    if(_finished_line())
+    {
+        _line_ended();
+        _scan_line();
+        if(_finished_file())
+        {
+            _c4dbgp("seqblck: finish!");
+            _end_seq_blck();
+            goto seqblck_finish;
+        }
+        _c4dbgnextline();
+    }
+    goto seqblck_start;
+
+ seqblck_finish:
+    _c4dbgp("seqblck: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_map_block()
+{
+mapblck_start:
+    _c4dbgpf("handle2_map_block: map_id={} node_id={} level={} indref={}", m_evt_handler->m_parent->node_id, m_evt_handler->m_curr->node_id, m_evt_handler->m_curr->level, m_evt_handler->m_curr->indref);
+
+    // states: RKEY|QMRK -> RKCL -> RVAL -> RNXT
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(BLCK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY|RKCL|RVAL|RNXT|QMRK));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, 1 == (has_any(RKEY) + has_any(RKCL) + has_any(RVAL) + has_any(RNXT) + has_any(QMRK)));
+
+    _maybe_skip_comment();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        goto mapblck_again;
+
+    if(has_any(RKEY))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        //
+        // handle indentation
+        //
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            if(m_evt_handler->m_curr->indentation_eq())
+            {
+                _c4dbgpf("mapblck[RKEY]: skip {} from indref", m_evt_handler->m_curr->indref);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("mapblck[RKEY]: smaller indentation!");
+                _handle_indentation_pop_from_block_map();
+                _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                if(has_all(RMAP|BLCK))
+                {
+                    _c4dbgp("mapblck[RKEY]: still mapblck!");
+                    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(RKEY));
+                    rem = m_evt_handler->m_curr->line_contents.rem;
+                    if(!rem.len)
+                        goto mapblck_again;
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RKEY]: no longer mapblck!");
+                    goto mapblck_finish;
+                }
+            }
+            else
+            {
+                _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->indentation_gt());
+                _c4err("invalid indentation");
+            }
+        }
+        //
+        // now handle the tokens
+        //
+        const char first = rem.str[0];
+        const size_t startline = m_evt_handler->m_curr->pos.line;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col();
+        _c4dbgpf("mapblck[RKEY]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapblck[RKEY]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+            addrem_flags(RVAL, RKEY);
+            if(!_maybe_scan_following_colon())
+                _c4err("could not find ':' colon after key");
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapblck[RKEY]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+            addrem_flags(RVAL, RKEY);
+            if(!_maybe_scan_following_colon())
+                _c4err("could not find ':' colon after key");
+            _maybe_skip_whitespace_tokens();
+        }
+        // block scalars (| and >) can not be used as keys unless they
+        // appear in an explicit QMRK scope (ie, after the ? token),
+        else if(C4_UNLIKELY(first == '|'))
+        {
+            _c4err("block literal keys must be enclosed in '?'");
+        }
+        else if(C4_UNLIKELY(first == '>'))
+        {
+            _c4err("block literal keys must be enclosed in '?'");
+        }
+        else if(_scan_scalar_plain_map_blck(&sc))
+        {
+            _c4dbgp("mapblck[RKEY]: plain scalar");
+            csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_plain(maybe_filtered);
+            addrem_flags(RVAL, RKEY);
+            if(!_maybe_scan_following_colon())
+                _c4err("could not find ':' colon after key");
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("mapblck[RKEY]: key token!");
+            addrem_flags(QMRK, RKEY);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            m_was_inside_qmrk = true;
+            goto mapblck_again;
+        }
+        else if(first == ':')
+        {
+            _c4dbgp("mapblck[RKEY]: setting empty key");
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RVAL, RKEY);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapblck[RKEY]: key ref! [{}]~~~{}~~~", ref.len, ref);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_ref(ref);
+            addrem_flags(RVAL, RKEY);
+            if(!_maybe_scan_following_colon())
+                _c4err("could not find ':' colon after key");
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapblck[RKEY]: key anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            _add_annotation(&m_pending_anchors, anchor, startindent, startline);
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapblck[RKEY]: key tag! [{}]~~~{}~~~", tag.len, tag);
+            _add_annotation(&m_pending_tags, tag, startindent, startline);
+        }
+        else if(first == '[')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree handler. Other handlers may be
+            // able to handle it.
+            _c4dbgp("mapblck[RKEY]: start child seqflow (!)");
+            addrem_flags(RKCL, RKEY);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RSEQ|FLOW|RVAL, RMAP|BLCK|RKCL);
+            _line_progressed(1);
+            _set_indentation(startindent);
+            goto mapblck_finish;
+        }
+        else if(first == '{')
+        {
+            // RYML's tree cannot store container keys, but that's
+            // handled inside the tree handler. Other handlers may be
+            // able to handle it.
+            _c4dbgp("mapblck[RKEY]: start child mapflow (!)");
+            addrem_flags(RKCL, RKEY);
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->begin_map_key_flow();
+            addrem_flags(FLOW|RKEY, BLCK|RKCL);
+            _line_progressed(1);
+            _set_indentation(startindent);
+            goto mapblck_finish;
+        }
+        else if(first == '-')
+        {
+            _c4dbgp("mapblck[RKEY]: maybe doc?");
+            if(m_evt_handler->m_curr->line_contents.indentation == 0 && _is_doc_begin_token(rem))
+            {
+                _c4dbgp("mapblck[RKEY]: end+start doc");
+                _start_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("mapblck[RKEY]: maybe end doc?");
+            if(m_evt_handler->m_curr->line_contents.indentation == 0 && _is_doc_end_token(rem))
+            {
+                _c4dbgp("mapblck[RKEY]: end doc");
+                _end_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+       _RYML_WITH_TAB_TOKENS(
+        else if(first == '\t')
+        {
+            _c4dbgp("mapblck[RKEY]: skip tabs");
+            _maybe_skipchars('\t');
+        })
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RKCL)) // read the key colon
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        //
+        // handle indentation
+        //
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            if(m_evt_handler->m_curr->indentation_eq())
+            {
+                _c4dbgpf("mapblck[RKCL]: skip {} from indref", m_evt_handler->m_curr->indref);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+            else if(C4_UNLIKELY(m_evt_handler->m_curr->indentation_lt()))
+            {
+                _c4err("invalid indentation");
+            }
+        }
+        const char first = rem.str[0];
+        _c4dbgpf("mapblck[RKCL]: '{}'", first);
+        if(first == ':')
+        {
+            _c4dbgp("mapblck[RKCL]: found the colon");
+            addrem_flags(RVAL, RKCL);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("mapblck[RKCL]: got '?'. val was empty");
+            _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_was_inside_qmrk);
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->add_sibling();
+            addrem_flags(QMRK, RKCL);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '-')
+        {
+            if(m_evt_handler->m_curr->indref == 0 || m_evt_handler->m_curr->line_contents.indentation == 0 || _is_doc_begin_token(rem))
+            {
+                _c4dbgp("mapblck[RKCL]: end+start doc");
+                _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, _is_doc_begin_token(rem));
+                _start_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("mapblck[RKCL]: maybe end doc?");
+            csubstr rs = rem.sub(1);
+            if(rs == ".." || rs.begins_with(".. "))
+            {
+                _c4dbgp("mapblck[RKCL]: end+start doc");
+                _end_doc_suddenly();
+                _line_progressed(3);
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(m_was_inside_qmrk)
+        {
+            _RYML_CB_CHECK(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->indentation_eq());
+            _c4dbgp("mapblck[RKCL]: missing :");
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->add_sibling();
+            m_was_inside_qmrk = false;
+            addrem_flags(RKEY, RKCL);
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RVAL))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        //
+        // handle indentation
+        //
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            _c4dbgpf("mapblck[RVAL]: indref={} indentation={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->line_contents.indentation);
+            m_evt_handler->m_curr->more_indented = false;
+            if(m_evt_handler->m_curr->indref == npos)
+            {
+                _c4dbgpf("mapblck[RVAL]: setting indentation={}", m_evt_handler->m_parent->indref);
+                _set_indentation(m_evt_handler->m_curr->line_contents.indentation);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_eq())
+            {
+                _c4dbgp("mapblck[RVAL]: skip indentation!");
+                _line_progressed(m_evt_handler->m_curr->indref);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+                // TODO: this is valid:
+                //
+                // ```yaml
+                // a:
+                // b:
+                // ---
+                // a:
+                //  b
+                // ---
+                // a:
+                //  b: c
+                // ```
+                //
+                // ... but this is not:
+                //
+                // ```yaml
+                // a:
+                // v
+                // ---
+                // a: b: c
+                // ```
+                //
+                // here, we probably need to set a boolean on the state
+                // to disambiguate between these cases.
+            }
+            else if(m_evt_handler->m_curr->indentation_gt())
+            {
+                _c4dbgp("mapblck[RVAL]: more indented!");
+                m_evt_handler->m_curr->more_indented = true;
+                _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("mapblck[RVAL]: smaller indentation!");
+                _handle_indentation_pop_from_block_map();
+                if(has_all(RMAP|BLCK))
+                {
+                    _c4dbgp("mapblck[RVAL]: still mapblck!");
+                    _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                    if(has_any(RNXT))
+                    {
+                        _c4dbgp("mapblck[RVAL]: speculatively expect next keyval");
+                        m_evt_handler->add_sibling();
+                        addrem_flags(RKEY, RNXT);
+                    }
+                    goto mapblck_again;
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RVAL]: no longer mapblck!");
+                    goto mapblck_finish;
+                }
+            }
+            else if(m_evt_handler->m_curr->line_contents.indentation == npos)
+            {
+                _c4dbgp("mapblck[RVAL]: empty line!");
+                _line_progressed(m_evt_handler->m_curr->line_contents.rem.len);
+                goto mapblck_again;
+            }
+        }
+        //
+        // now handle the tokens
+        //
+        const char first = rem.str[0];
+        const size_t startline = m_evt_handler->m_curr->pos.line;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col();
+        _c4dbgpf("mapblck[RVAL]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapblck[RVAL]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc); // VAL!
+                m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                if(startindent != m_evt_handler->m_curr->indref)
+                {
+                    _c4dbgp("mapblck[RVAL]: start new block map, set scalar as key");
+                    _handle_annotations_before_start_mapblck(startline);
+                    addrem_flags(RNXT, RVAL);
+                    _handle_colon();
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc); // KEY!
+                    m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                    _maybe_skip_whitespace_tokens();
+                    // keep the child state on RVAL
+                    addrem_flags(RVAL, RNXT);
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RVAL]: prev val empty+this is a key");
+                    m_evt_handler->set_val_scalar_plain_empty();
+                    m_evt_handler->add_sibling();
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc); // KEY!
+                    m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                    // keep going on RVAL
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapblck[RVAL]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc); // VAL!
+                m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                if(startindent != m_evt_handler->m_curr->indref)
+                {
+                    _c4dbgp("mapblck[RVAL]: start new block map, set scalar as key");
+                    _handle_annotations_before_start_mapblck(startline);
+                    addrem_flags(RNXT, RVAL);
+                    _handle_colon();
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc); // KEY!
+                    m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                    _maybe_skip_whitespace_tokens();
+                    // keep the child state on RVAL
+                    addrem_flags(RVAL, RNXT);
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RVAL]: prev val empty+this is a key");
+                    m_evt_handler->set_val_scalar_plain_empty();
+                    m_evt_handler->add_sibling();
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc); // KEY!
+                    m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                    // keep going on RVAL
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+        }
+        // block scalars can only appear as keys when in QMRK scope
+        // (ie, after ? tokens), so no need to scan following colon
+        else if(first == '|')
+        {
+            _c4dbgp("mapblck[RVAL]: scanning block-literal scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            _handle_annotations_before_blck_val_scalar();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_literal(sb);
+            m_evt_handler->set_val_scalar_literal(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(first == '>')
+        {
+            _c4dbgp("mapblck[RVAL]: scanning block-folded scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            _handle_annotations_before_blck_val_scalar();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_folded(sb);
+            m_evt_handler->set_val_scalar_folded(maybe_filtered);
+            addrem_flags(RNXT, RVAL);
+        }
+        else if(_scan_scalar_plain_map_blck(&sc))
+        {
+            _c4dbgp("mapblck[RVAL]: plain scalar.");
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[RVAL]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, m_evt_handler->m_curr->indref); // VAL!
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                if(startindent != m_evt_handler->m_curr->indref)
+                {
+                    _c4dbgpf("mapblck[RVAL]: start new block map, set scalar as key {}", m_evt_handler->m_curr->indref);
+                    addrem_flags(RNXT, RVAL);
+                    _handle_annotations_before_start_mapblck(startline);
+                    _handle_colon();
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref); // KEY!
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    _maybe_skip_whitespace_tokens();
+                    // keep the child state on RVAL
+                    addrem_flags(RVAL, RNXT);
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RVAL]: prev val empty+this is a key");
+                    _handle_annotations_before_blck_val_scalar();
+                    m_evt_handler->set_val_scalar_plain_empty();
+                    m_evt_handler->add_sibling();
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref); // KEY!
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    // keep going on RVAL
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+        }
+        else if(first == '-')
+        {
+            if(rem.len == 1 || rem.str[1] == ' ' _RYML_WITH_TAB_TOKENS(|| rem.str[1] == '\t'))
+            {
+                _c4dbgp("mapblck[RVAL]: start val seqblck");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->begin_seq_val_block();
+                addrem_flags(RSEQ|RVAL, RMAP|RNXT);
+                _set_indentation(startindent);
+                _line_progressed(1);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else if(m_evt_handler->m_curr->indref == 0 || m_evt_handler->m_curr->line_contents.indentation == 0 || _is_doc_begin_token(rem))
+            {
+                _c4dbgp("mapblck[RVAL]: end+start doc");
+                _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, _is_doc_begin_token(rem));
+                _start_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("mapblck[RVAL]: start val seqflow");
+            addrem_flags(RNXT, RVAL);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(RSEQ|FLOW|RVAL, RMAP|BLCK|RNXT);
+            _set_indentation(m_evt_handler->m_curr->indref + 1u);
+            _line_progressed(1);
+            goto mapblck_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("mapblck[RVAL]: start val mapflow");
+            addrem_flags(RNXT, RVAL);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RKEY|FLOW, BLCK|RVAL|RNXT);
+            m_evt_handler->m_curr->scalar_col = m_evt_handler->m_curr->line_contents.indentation;
+            _set_indentation(m_evt_handler->m_curr->indref + 1u);
+            _line_progressed(1);
+            goto mapblck_finish;
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapblck[RVAL]: ref! [{}]~~~{}~~~", ref.len, ref);
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgpf("mapblck[RVAL]: same indentation {}", startindent);
+                m_evt_handler->set_val_ref(ref);
+                addrem_flags(RNXT, RVAL);
+            }
+            else
+            {
+                _c4dbgpf("mapblck[RVAL]: larger indentation {}>{}", startindent, m_evt_handler->m_curr->indref);
+                _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, startindent > m_evt_handler->m_curr->indref);
+                if(_maybe_scan_following_colon())
+                {
+                    _c4dbgp("mapblck[RVAL]: start child map, block");
+                    addrem_flags(RNXT, RVAL);
+                    _handle_annotations_before_blck_val_scalar();
+                    m_evt_handler->begin_map_val_block();
+                    m_evt_handler->set_key_ref(ref);
+                    _set_indentation(startindent);
+                    // keep going in RVAL
+                    addrem_flags(RVAL, RNXT);
+                }
+                else
+                {
+                    _c4dbgp("mapblck[RVAL]: was val ref");
+                    _handle_annotations_before_blck_val_scalar();
+                    m_evt_handler->set_val_ref(ref);
+                    addrem_flags(RNXT, RVAL);
+                }
+            }
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapblck[RVAL]: anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: anchor for next key. val is missing!");
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+                addrem_flags(RKEY, RVAL);
+            }
+            // we need to buffer the anchors, as there may be two
+            // consecutive anchors in here
+            _add_annotation(&m_pending_anchors, anchor, startindent, startline);
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapblck[RVAL]: tag! [{}]~~~{}~~~", tag.len, tag);
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: tag for next key. val is missing!");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+                addrem_flags(RKEY, RVAL);
+            }
+            // we need to buffer the tags, as there may be two
+            // consecutive tags in here
+            _add_annotation(&m_pending_tags, tag, startindent, startline);
+        }
+        else if(first == '?')
+        {
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: got '?'. val was empty");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+                addrem_flags(QMRK, RVAL);
+            }
+            else if(startindent > m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: start val mapblck");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->begin_map_val_block();
+                addrem_flags(QMRK|BLCK, RNXT);
+                _set_indentation(startindent);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+            m_was_inside_qmrk = true;
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            goto mapblck_again;
+        }
+        else if(first == ':')
+        {
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: got ':'. val was empty, next key as well");
+                m_evt_handler->set_val_scalar_plain_empty();
+                m_evt_handler->add_sibling();
+                m_evt_handler->set_key_scalar_plain_empty();
+            }
+            else if(startindent > m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[RVAL]: start val mapblck");
+                addrem_flags(RNXT, RVAL);
+                _handle_annotations_before_start_mapblck(startline);
+                _handle_colon();
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_scalar_plain_empty();
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RNXT);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+            goto mapblck_again;
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("mapblck[RVAL]: maybe doc?");
+            csubstr rs = rem.sub(1);
+            if(rs == ".." || rs.begins_with(".. "))
+            {
+                _c4dbgp("seqblck[RVAL]: end doc expl");
+                _end_doc_suddenly();
+                _line_progressed(3);
+                _maybe_skip_whitespace_tokens();
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+       _RYML_WITH_TAB_TOKENS(
+        else if(first == '\t')
+        {
+            _c4dbgp("mapblck[RVAL]: skip tabs");
+            _maybe_skipchars('\t');
+        })
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(RNXT))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(QMRK));
+        //
+        // handle indentation
+        //
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            _c4dbgpf("mapblck[RNXT]: indref={} indentation={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->line_contents.indentation);
+            if(m_evt_handler->m_curr->indentation_eq())
+            {
+                _c4dbgpf("mapblck[RNXT]: skip {} from indref", m_evt_handler->m_curr->indref);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                _c4dbgp("mapblck[RNXT]: speculatively expect next keyval");
+                m_evt_handler->add_sibling();
+                addrem_flags(RKEY, RNXT);
+                goto mapblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("mapblck[RNXT]: smaller indentation!");
+                _handle_indentation_pop_from_block_map();
+                if(has_all(RMAP|BLCK))
+                {
+                    _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                    if(!has_any(RKCL))
+                    {
+                        _c4dbgp("mapblck[RNXT]: speculatively expect next keyval");
+                        m_evt_handler->add_sibling();
+                        addrem_flags(RKEY, RNXT);
+                    }
+                    goto mapblck_again;
+                }
+                else
+                {
+                    goto mapblck_finish;
+                }
+            }
+        }
+        else
+        {
+            _c4dbgp("mapblck[RNXT]: NOT at line begin");
+            if(!rem.begins_with_any(" \t"))
+            {
+                _c4err("parse error");
+            }
+            else
+            {
+                _skipchars(" \t");
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                {
+                    _c4dbgp("seqblck[RNXT]: again");
+                    goto mapblck_again;
+                }
+            }
+        }
+        //
+        // handle tokens
+        //
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.len > 0);
+        const char first = rem.str[0];
+        _c4dbgpf("mapblck[RNXT]: '{}'", _c4prc(first));
+        if(first == ':')
+        {
+            if(m_evt_handler->m_curr->more_indented)
+            {
+                _c4dbgp("mapblck[RNXT]: start child block map");
+                C4_NOT_IMPLEMENTED();
+                //m_evt_handler->actually_as_block_map();
+                _line_progressed(1);
+                _set_indentation(m_evt_handler->m_curr->scalar_col);
+                m_evt_handler->m_curr->more_indented = false;
+                goto mapblck_again;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(first == ' ')
+        {
+            _c4dbgp("mapblck[RNXT]: skip spaces");
+            _maybe_skip_whitespace_tokens();
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+    else if(has_any(QMRK))
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKEY));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RKCL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RVAL));
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT));
+        //
+        // handle indentation
+        //
+        if(m_evt_handler->m_curr->at_line_beginning())
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_curr->line_contents.indentation != npos);
+            if(m_evt_handler->m_curr->indentation_eq())
+            {
+                _c4dbgpf("mapblck[QMRK]: skip {} from indref", m_evt_handler->m_curr->indref);
+                _line_progressed(m_evt_handler->m_curr->indref);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+            else if(m_evt_handler->m_curr->indentation_lt())
+            {
+                _c4dbgp("mapblck[QMRK]: smaller indentation!");
+                _handle_indentation_pop_from_block_map();
+                _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                if(has_all(RMAP|BLCK))
+                {
+                    _c4dbgp("mapblck[QMRK]: still mapblck!");
+                    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_any(QMRK));
+                    rem = m_evt_handler->m_curr->line_contents.rem;
+                    if(!rem.len)
+                        goto mapblck_again;
+                }
+                else
+                {
+                    _c4dbgp("mapblck[QMRK]: no longer mapblck!");
+                    goto mapblck_finish;
+                }
+            }
+            // indentation can be larger in QMRK state
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: larger indentation !");
+                _line_progressed(m_evt_handler->m_curr->line_contents.indentation);
+                rem = m_evt_handler->m_curr->line_contents.rem;
+                if(!rem.len)
+                    goto mapblck_again;
+            }
+        }
+        //
+        // now handle the tokens
+        //
+        const char first = rem.str[0];
+        const size_t startline = m_evt_handler->m_curr->pos.line;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col();
+        _c4dbgpf("mapblck[QMRK]: '{}'", first);
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("mapblck[QMRK]: scanning single-quoted scalar");
+            sc = _scan_scalar_squot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc); // KEY!
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[QMRK]: set as key");
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                addrem_flags(RKCL, QMRK);
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start new block map as key (!), set scalar as key");
+                addrem_flags(RKCL, QMRK);
+                _handle_annotations_before_start_mapblck_as_key();
+                m_evt_handler->begin_map_key_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RKCL|QMRK);
+            }
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("mapblck[QMRK]: scanning double-quoted scalar");
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc); // KEY!
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[QMRK]: set as key");
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                addrem_flags(RKCL, QMRK);
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start new block map as key (!), set scalar as key");
+                addrem_flags(RKCL, QMRK);
+                _handle_annotations_before_start_mapblck_as_key();
+                m_evt_handler->begin_map_key_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RKCL|QMRK);
+            }
+        }
+        else if(first == '|')
+        {
+            _c4dbgp("mapblck[QMRK]: scanning block-literal scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            csubstr maybe_filtered = _maybe_filter_key_scalar_literal(sb); // KEY!
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_literal(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+        }
+        else if(first == '>')
+        {
+            _c4dbgp("mapblck[QMRK]: scanning block-literal scalar");
+            ScannedBlock sb;
+            _scan_block(&sb, m_evt_handler->m_curr->indref + 1);
+            csubstr maybe_filtered = _maybe_filter_key_scalar_folded(sb); // KEY!
+            _handle_annotations_before_blck_key_scalar();
+            m_evt_handler->set_key_scalar_folded(maybe_filtered);
+            addrem_flags(RKCL, QMRK);
+        }
+        else if(_scan_scalar_plain_map_blck(&sc))
+        {
+            _c4dbgp("mapblck[QMRK]: plain scalar");
+            csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, m_evt_handler->m_curr->indref); // KEY!
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[QMRK]: set as key");
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                addrem_flags(RKCL, QMRK);
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start new block map as key (!), set scalar as key");
+                addrem_flags(RKCL, QMRK);
+                _handle_annotations_before_start_mapblck_as_key();
+                m_evt_handler->begin_map_key_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RKCL|QMRK);
+            }
+        }
+        else if(first == ':')
+        {
+            if(startindent == m_evt_handler->m_curr->indref)
+            {
+                _c4dbgp("mapblck[QMRK]: empty key");
+                addrem_flags(RVAL, QMRK);
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->set_key_scalar_plain_empty();
+                _line_progressed(1);
+                _maybe_skip_whitespace_tokens();
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start new block map as key (!), empty key");
+                addrem_flags(RKCL, QMRK);
+                _handle_annotations_before_start_mapblck_as_key();
+                m_evt_handler->begin_map_key_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_scalar_plain_empty();
+                _line_progressed(1);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RKCL|QMRK);
+            }
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("mapblck[QMRK]: key ref! [{}]~~~{}~~~", ref.len, ref);
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("mapblck[QMRK]: set ref as key");
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->set_key_ref(ref);
+                addrem_flags(RKCL, QMRK);
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start new block map as key (!), set ref as key");
+                addrem_flags(RKCL, QMRK);
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->begin_map_key_block();
+                m_evt_handler->set_key_ref(ref);
+                _set_indentation(startindent);
+                // keep the child state on RVAL
+                addrem_flags(RVAL, RKCL|QMRK);
+            }
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("mapblck[QMRK]: key anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            _add_annotation(&m_pending_anchors, anchor, startindent, startline);
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("mapblck[QMRK]: key tag! [{}]~~~{}~~~", tag.len, tag);
+            _add_annotation(&m_pending_tags, tag, startindent, startline);
+        }
+        else if(first == '-')
+        {
+            _c4dbgp("mapblck[QMRK]: maybe doc?");
+            csubstr rs = rem.sub(1);
+            if(rs == "--" || rs.begins_with("-- "))
+            {
+                _c4dbgp("mapblck[QMRK]: end+start doc");
+                _start_doc_suddenly();
+                _line_progressed(3);
+            }
+            else
+            {
+                _c4dbgp("mapblck[QMRK]: start child seqblck (!)");
+                addrem_flags(RKCL, RKEY|QMRK);
+                _handle_annotations_before_blck_key_scalar();
+                m_evt_handler->begin_seq_key_block();
+                addrem_flags(RVAL|RSEQ, RMAP|RKCL|QMRK);
+                _set_indentation(startindent);
+                _line_progressed(1);
+            }
+            _maybe_skip_whitespace_tokens();
+            goto mapblck_finish;
+        }
+        else if(first == '[')
+        {
+            _c4dbgp("mapblck[QMRK]: start child seqflow (!)");
+            addrem_flags(RKCL, RKEY|QMRK);
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RVAL|RSEQ|FLOW, RMAP|RKCL|QMRK|BLCK);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto mapblck_finish;
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("mapblck[QMRK]: start child mapblck (!)");
+            addrem_flags(RKCL, RKEY|QMRK);
+            m_evt_handler->begin_map_key_flow();
+            addrem_flags(RKEY|FLOW, RVAL|RKCL|QMRK|BLCK);
+            _set_indentation(m_evt_handler->m_parent->indref);
+            _line_progressed(1);
+            goto mapblck_finish;
+        }
+        else if(first == '?')
+        {
+            _c4dbgp("mapblck[QMRK]: another QMRK '?'");
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_evt_handler->set_val_scalar_plain_empty();
+            m_evt_handler->add_sibling();
+            _line_progressed(1);
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("mapblck[QMRK]: maybe end doc?");
+            csubstr rs = rem.sub(1);
+            if(rs == ".." || rs.begins_with(".. "))
+            {
+                _c4dbgp("mapblck[QMRK]: end+start doc");
+                _end_doc_suddenly();
+                _line_progressed(3);
+                goto mapblck_finish;
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+
+ mapblck_again:
+    _c4dbgt("mapblck: again", 0);
+    if(_finished_line())
+    {
+        _line_ended();
+        _scan_line();
+        if(_finished_file())
+        {
+            _c4dbgp("mapblck: file finished!");
+            _end_map_blck();
+            goto mapblck_finish;
+        }
+        _c4dbgnextline();
+    }
+    goto mapblck_start;
+
+ mapblck_finish:
+    _c4dbgp("mapblck: finish");
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_unk_json()
+{
+    _c4dbgpf("handle_unk_json indref={} target={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->node_id);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT|RSEQ|RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RTOP));
+
+    _maybe_skip_comment();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        return;
+
+    size_t pos = rem.first_not_of(" \t");
+    if(pos)
+    {
+        pos = pos != npos ? pos : rem.len;
+        _c4dbgpf("skipping indentation of {}", pos);
+        _line_progressed(pos);
+        rem = m_evt_handler->m_curr->line_contents.rem;
+        if(!rem.len)
+            return;
+        _c4dbgpf("rem is now [{}]~~~{}~~~", rem.len, rem);
+    }
+
+    if(rem.begins_with('['))
+    {
+        _c4dbgp("it's a seq");
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        m_evt_handler->begin_seq_val_flow();
+        addrem_flags(RSEQ|FLOW|RVAL, RUNK|RTOP|RDOC);
+        _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        m_doc_empty = false;
+        _line_progressed(1);
+    }
+    else if(rem.begins_with('{'))
+    {
+        _c4dbgp("it's a map");
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        m_evt_handler->begin_map_val_flow();
+        addrem_flags(RMAP|FLOW|RKEY, RVAL|RTOP|RUNK|RDOC);
+        m_doc_empty = false;
+        _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        _line_progressed(1);
+    }
+    else if(_handle_bom())
+    {
+        _c4dbgp("byte order mark");
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(SSCL));
+        _maybe_skip_whitespace_tokens();
+        csubstr s = m_evt_handler->m_curr->line_contents.rem;
+        if(!s.len)
+            return;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+        const char first = s.str[0];
+        ScannedScalar sc;
+        if(first == '"')
+        {
+            _c4dbgp("runk_json: scanning double-quoted scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            sc = _scan_scalar_dquot();
+            csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("runk_json: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else if(_scan_scalar_plain_unk(&sc))
+        {
+            _c4dbgp("runk_json: got a plain scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("runk_json: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, startindent);
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+        else
+        {
+            _c4err("parse error");
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::_handle_unk()
+{
+    _c4dbgpf("handle_unk indref={} target={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->node_id);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(RNXT|RSEQ|RMAP));
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RTOP));
+
+    _maybe_skip_comment();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        return;
+
+    size_t pos = rem.first_not_of(" \t");
+    if(pos)
+    {
+        pos = pos != npos ? pos : rem.len;
+        _c4dbgpf("skipping {} whitespace characters", pos);
+        _line_progressed(pos);
+        rem = m_evt_handler->m_curr->line_contents.rem;
+        if(!rem.len)
+            return;
+        _c4dbgpf("rem is now [{}]~~~{}~~~", rem.len, rem);
+    }
+
+    if(m_evt_handler->m_curr->line_contents.indentation == 0u && _at_line_begin())
+    {
+        _c4dbgp("rtop: zero indent + at line begin");
+        if(_handle_bom())
+        {
+            _c4dbgp("byte order mark!");
+            rem = m_evt_handler->m_curr->line_contents.rem;
+            if(!rem.len)
+                return;
+        }
+        const char first = rem.str[0];
+        if(first == '-')
+        {
+            _c4dbgp("rtop: suspecting doc");
+            if(_is_doc_begin_token(rem))
+            {
+                _c4dbgp("rtop: begin doc");
+                _maybe_end_doc();
+                _begin2_doc_expl();
+                _set_indentation(0);
+                addrem_flags(RDOC|RUNK, NDOC);
+                _line_progressed(3u);
+                _maybe_skip_whitespace_tokens();
+                return;
+            }
+        }
+        else if(first == '.')
+        {
+            _c4dbgp("rtop: suspecting doc end");
+            if(_is_doc_end_token(rem))
+            {
+                _c4dbgp("rtop: end doc");
+                if(has_any(RDOC))
+                {
+                    _end2_doc_expl();
+                }
+                else
+                {
+                    _c4dbgp("rtop: ignore end doc");
+                }
+                addrem_flags(NDOC|RUNK, RDOC);
+                _line_progressed(3u);
+                _maybe_skip_whitespace_tokens();
+                return;
+            }
+        }
+        else if(first == '%')
+        {
+            _c4dbgpf("directive: {}", rem);
+            if(C4_UNLIKELY(!m_doc_empty && has_none(NDOC)))
+                _RYML_CB_ERR(m_evt_handler->m_stack.m_callbacks, "need document footer before directives");
+            _handle_directive(rem);
+            return;
+        }
+    }
+
+    /* no else-if! */
+    char first = rem.str[0];
+
+    if(first == '[')
+    {
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        m_doc_empty = false;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col(rem);
+        if(C4_LIKELY( ! _annotations_require_key_container()))
+        {
+            _c4dbgp("it's a seq, flow");
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(RSEQ|FLOW|RVAL, RUNK|RTOP|RDOC);
+            _set_indentation(startindent);
+        }
+        else
+        {
+            _c4dbgp("start new block map, set flow seq as key (!)");
+            _handle_annotations_before_start_mapblck(m_evt_handler->m_curr->pos.line);
+            m_evt_handler->begin_map_val_block();
+            addrem_flags(RMAP|BLCK|RKCL, RUNK|RTOP|RDOC);
+            _handle_annotations_and_indentation_after_start_mapblck(startindent, m_evt_handler->m_curr->pos.line);
+            m_evt_handler->begin_seq_key_flow();
+            addrem_flags(RSEQ|FLOW|RVAL, RMAP|BLCK|RKCL);
+            _set_indentation(startindent);
+        }
+        _line_progressed(1);
+    }
+    else if(first == '{')
+    {
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        m_doc_empty = false;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.current_col(rem);
+        if(C4_LIKELY( ! _annotations_require_key_container()))
+        {
+            _c4dbgp("it's a map, flow");
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RMAP|FLOW|RKEY, RVAL|RTOP|RUNK|RDOC);
+            _set_indentation(startindent);
+        }
+        else
+        {
+            _c4dbgp("start new block map, set flow map as key (!)");
+            _handle_annotations_before_start_mapblck(m_evt_handler->m_curr->pos.line);
+            m_evt_handler->begin_map_val_block();
+            addrem_flags(RMAP|BLCK|RKCL, RUNK|RTOP|RDOC);
+            _handle_annotations_and_indentation_after_start_mapblck(startindent, m_evt_handler->m_curr->pos.line);
+            m_evt_handler->begin_map_key_flow();
+            addrem_flags(RMAP|FLOW|RKEY, BLCK|RKCL);
+            _set_indentation(startindent);
+        }
+        _line_progressed(1);
+    }
+    else if(first == '-' && _is_blck_token(rem))
+    {
+        _c4dbgp("it's a seq, block");
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->begin_seq_val_block();
+        addrem_flags(RSEQ|BLCK|RVAL, RNXT|RTOP|RUNK|RDOC);
+        m_doc_empty = false;
+        _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        _line_progressed(1);
+        _maybe_skip_whitespace_tokens();
+    }
+    else if(first == '?' && _is_blck_token(rem))
+    {
+        _c4dbgp("it's a map + this key is complex");
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        _handle_annotations_before_blck_val_scalar();
+        m_evt_handler->begin_map_val_block();
+        addrem_flags(RMAP|BLCK|QMRK, RKEY|RVAL|RTOP|RUNK);
+        m_doc_empty = false;
+        m_was_inside_qmrk = true;
+        _save_indentation();
+        _line_progressed(1);
+        _maybe_skip_whitespace_tokens();
+    }
+    else if(first == ':' && _is_blck_token(rem))
+    {
+        if(m_doc_empty)
+        {
+            _c4dbgp("it's a map with an empty key");
+            const size_t startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+            const size_t startline = m_evt_handler->m_curr->pos.line; // save
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            _handle_annotations_before_start_mapblck(startline);
+            _handle_colon();
+            m_evt_handler->begin_map_val_block();
+            _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+            m_evt_handler->set_key_scalar_plain_empty();
+            m_doc_empty = false;
+            _set_indentation(startindent);
+        }
+        else
+        {
+            _c4dbgp("actually prev val is a key!");
+            size_t prev_indentation = m_evt_handler->m_curr->indref;
+            m_evt_handler->actually_val_is_first_key_of_new_map_block();
+            _set_indentation(prev_indentation);
+        }
+        addrem_flags(RMAP|BLCK|RVAL, RTOP|RUNK|RDOC);
+        _line_progressed(1);
+        _maybe_skip_whitespace_tokens();
+    }
+    else if(first == '&')
+    {
+        csubstr anchor = _scan_anchor();
+        _c4dbgpf("anchor! [{}]~~~{}~~~", anchor.len, anchor);
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+        const size_t line = m_evt_handler->m_curr->pos.line;
+        _add_annotation(&m_pending_anchors, anchor, indentation, line);
+        _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        m_doc_empty = false;
+    }
+    else if(first == '*')
+    {
+        csubstr ref = _scan_ref_map();
+        _c4dbgpf("ref! [{}]~~~{}~~~", ref.len, ref);
+        m_evt_handler->check_trailing_doc_token();
+        _maybe_begin_doc();
+        m_doc_empty = false;
+        if(!_maybe_scan_following_colon())
+        {
+            _c4dbgp("runk: set val ref");
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->set_val_ref(ref);
+        }
+        else
+        {
+            _c4dbgp("runk: start new block map, set ref as key");
+            const size_t startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+            const size_t startline = m_evt_handler->m_curr->pos.line; // save
+            _handle_annotations_before_start_mapblck(startline);
+            m_evt_handler->begin_map_val_block();
+            _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+            m_evt_handler->set_key_ref(ref);
+            _maybe_skip_whitespace_tokens();
+            _set_indentation(startindent);
+            addrem_flags(RMAP|BLCK|RVAL, RTOP|RUNK|RDOC);
+        }
+    }
+    else if(first == '!')
+    {
+        csubstr tag = _scan_tag();
+        _c4dbgpf("unk: val tag! [{}]~~~{}~~~", tag.len, tag);
+        // we need to buffer the tags, as there may be two
+        // consecutive tags in here
+        const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+        const size_t line = m_evt_handler->m_curr->pos.line;
+        _add_annotation(&m_pending_tags, tag, indentation, line);
+    }
+    else
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(SSCL));
+        _maybe_skip_whitespace_tokens();
+        csubstr s = m_evt_handler->m_curr->line_contents.rem;
+        if(!s.len)
+            return;
+        const size_t startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+        const size_t startline = m_evt_handler->m_curr->pos.line; // save
+        first = s.str[0];
+        ScannedScalar sc;
+        if(first == '\'')
+        {
+            _c4dbgp("runk: scanning single-quoted scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            sc = _scan_scalar_squot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("runk: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+                m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+            }
+            else
+            {
+                _c4dbgp("runk: start new block map, set scalar as key");
+                _handle_annotations_before_start_mapblck(startline);
+                _handle_colon();
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+                m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                addrem_flags(RMAP|BLCK|RVAL, RTOP|RUNK|RDOC);
+            }
+        }
+        else if(first == '"')
+        {
+            _c4dbgp("runk: scanning double-quoted scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            sc = _scan_scalar_dquot();
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("runk: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+                m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+            }
+            else
+            {
+                _c4dbgp("runk: start new block map, set double-quoted scalar as key");
+                _handle_annotations_before_start_mapblck(startline);
+                m_evt_handler->begin_map_val_block();
+                _handle_colon();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+                m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                addrem_flags(RMAP|BLCK|RVAL, RTOP|RUNK|RDOC);
+            }
+        }
+        else if(first == '|')
+        {
+            _c4dbgp("runk: scanning block-literal scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            ScannedBlock sb;
+            _scan_block(&sb, startindent);
+            if(C4_LIKELY(!_maybe_scan_following_colon()))
+            {
+                _c4dbgp("runk: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_literal(sb);
+                m_evt_handler->set_val_scalar_literal(maybe_filtered);
+            }
+            else
+            {
+                _c4err("block literal keys must be enclosed in '?'");
+            }
+        }
+        else if(first == '>')
+        {
+            _c4dbgp("runk: scanning block-folded scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            ScannedBlock sb;
+            _scan_block(&sb, startindent);
+            if(C4_LIKELY(!_maybe_scan_following_colon()))
+            {
+                _c4dbgp("runk: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_folded(sb);
+                m_evt_handler->set_val_scalar_folded(maybe_filtered);
+            }
+            else
+            {
+                _c4err("block folded keys must be enclosed in '?'");
+            }
+        }
+        else if(_scan_scalar_plain_unk(&sc))
+        {
+            _c4dbgp("runk: got a plain scalar");
+            m_evt_handler->check_trailing_doc_token();
+            _maybe_begin_doc();
+            add_flags(RDOC);
+            m_doc_empty = false;
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("runk: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, startindent);
+                m_evt_handler->set_val_scalar_plain(maybe_filtered);
+            }
+            else
+            {
+                _c4dbgp("runk: start new block map, set scalar as key");
+                _handle_annotations_before_start_mapblck(startline);
+                _handle_colon();
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, startindent);
+                m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                addrem_flags(RMAP|BLCK|RVAL, RTOP|RUNK|RDOC);
+            }
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+C4_COLD void ParseEngine<EventHandler>::_handle_usty()
+{
+    _c4dbgpf("handle_usty target={}", m_evt_handler->m_curr->indref, m_evt_handler->m_curr->node_id);
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_none(BLCK|FLOW));
+
+    #ifdef RYML_NO_COVERAGE__TO_BE_DELETED
+    if(has_any(RNXT))
+    {
+        _c4dbgp("usty[RNXT]: finishing!");
+        _end_stream();
+    }
+    #endif
+
+    _maybe_skip_comment();
+    csubstr rem = m_evt_handler->m_curr->line_contents.rem;
+    if(!rem.len)
+        return;
+
+    size_t pos = rem.first_not_of(" \t");
+    if(pos)
+    {
+        pos = pos != npos ? pos : rem.len;
+        _c4dbgpf("skipping indentation of {}", pos);
+        _line_progressed(pos);
+        rem = m_evt_handler->m_curr->line_contents.rem;
+        if(!rem.len)
+            return;
+        _c4dbgpf("rem is now [{}]~~~{}~~~", rem.len, rem);
+    }
+
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, rem.len > 0);
+    size_t startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+    char first = rem.str[0];
+    if(has_any(RSEQ)) // destination is a sequence
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(RMAP));
+        _c4dbgpf("usty[RSEQ]: first='{}'", _c4prc(first));
+        if(first == '[')
+        {
+            _c4dbgp("usty[RSEQ]: it's a flow seq. merging it");
+            add_flags(RNXT);
+            m_evt_handler->_push();
+            addrem_flags(FLOW|RVAL, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '-' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[RSEQ]: it's a block seq. merging it");
+            add_flags(RNXT);
+            m_evt_handler->_push();
+            addrem_flags(BLCK|RVAL, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else
+        {
+            _c4err("can only parse a seq into an existing seq");
+        }
+    }
+    else if(has_any(RMAP)) // destination is a map
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(RSEQ));
+        _c4dbgpf("usty[RMAP]: first='{}'", _c4prc(first));
+        if(first == '{')
+        {
+            _c4dbgp("usty[RMAP]: it's a flow map. merging it");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->_push();
+            addrem_flags(RMAP|FLOW|RKEY, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '?' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[RMAP]: it's a block map + this key is complex");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->_push();
+            addrem_flags(RMAP|BLCK|QMRK, RNXT|USTY);
+            m_was_inside_qmrk = true;
+            _save_indentation();
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == ':' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[RMAP]: it's a map with an empty key");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->_push();
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+            _save_indentation();
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(rem.begins_with('&'))
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("usty[RMAP]: anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+            const size_t line = m_evt_handler->m_curr->pos.line;
+            _add_annotation(&m_pending_anchors, anchor, indentation, line);
+            _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("usty[RMAP]: ref! [{}]~~~{}~~~", ref.len, ref);
+            if(!_maybe_scan_following_colon())
+            {
+                _c4err("cannot read a VAL to a map");
+            }
+            else
+            {
+                _c4dbgp("usty[RMAP]: start new block map, set ref as key");
+                const size_t startline = m_evt_handler->m_curr->pos.line; // save
+                add_flags(RNXT);
+                _handle_annotations_before_start_mapblck(startline);
+                m_evt_handler->_push();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_ref(ref);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+            }
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("usty[RMAP]: val tag! [{}]~~~{}~~~", tag.len, tag);
+            // we need to buffer the tags, as there may be two
+            // consecutive tags in here
+            const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+            const size_t line = m_evt_handler->m_curr->pos.line;
+            _add_annotation(&m_pending_tags, tag, indentation, line);
+        }
+        else if(first == '[' || (first == '-' && _is_blck_token(rem)))
+        {
+            _c4err("cannot parse a seq into an existing map");
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(SSCL));
+            startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+            const size_t startline = m_evt_handler->m_curr->pos.line; // save
+            ScannedScalar sc;
+            _c4dbgpf("usty[RMAP]: maybe scalar. first='{}'", _c4prc(first));
+            if(first == '\'')
+            {
+                _c4dbgp("usty[RMAP]: scanning single-quoted scalar");
+                sc = _scan_scalar_squot();
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4err("cannot read a VAL to a map");
+                }
+                else
+                {
+                    _c4dbgp("usty[RMAP]: start new block map, set scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->_push();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+                    m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else if(first == '"')
+            {
+                _c4dbgp("usty[RMAP]: scanning double-quoted scalar");
+                sc = _scan_scalar_dquot();
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4err("cannot read a VAL to a map");
+                }
+                else
+                {
+                    _c4dbgp("usty[RMAP]: start new block map, set double-quoted scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->_push();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+                    m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else if(first == '|')
+            {
+                _c4err("block literal keys must be enclosed in '?'");
+            }
+            else if(first == '>')
+            {
+                _c4err("block literal keys must be enclosed in '?'");
+            }
+            else if(_scan_scalar_plain_unk(&sc))
+            {
+                _c4dbgp("usty[RMAP]: got a plain scalar");
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4err("cannot read a VAL to a map");
+                }
+                else
+                {
+                    _c4dbgp("usty[RMAP]: start new block map, set scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->_push();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, startindent);
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+    }
+    else // destination is unknown
+    {
+        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(RSEQ));
+        _c4dbgpf("usty[UNK]: first='{}'", _c4prc(first));
+        if(first == '[')
+        {
+            _c4dbgp("usty[UNK]: it's a flow seq");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_seq_val_flow();
+            addrem_flags(RSEQ|FLOW|RVAL, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '-' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[UNK]: it's a block seq");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_seq_val_block();
+            addrem_flags(RSEQ|BLCK|RVAL, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '{')
+        {
+            _c4dbgp("usty[UNK]: it's a flow map");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_flow();
+            addrem_flags(RMAP|FLOW|RKEY, RNXT|USTY);
+            _set_indentation(startindent);
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '?' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[UNK]: it's a map + this key is complex");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_block();
+            addrem_flags(RMAP|BLCK|QMRK, RNXT|USTY);
+            m_was_inside_qmrk = true;
+            _save_indentation();
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == ':' && _is_blck_token(rem))
+        {
+            _c4dbgp("usty[UNK]: it's a map with an empty key");
+            add_flags(RNXT);
+            _handle_annotations_before_blck_val_scalar();
+            m_evt_handler->begin_map_val_block();
+            m_evt_handler->set_key_scalar_plain_empty();
+            addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+            _save_indentation();
+            _line_progressed(1);
+            _maybe_skip_whitespace_tokens();
+        }
+        else if(first == '&')
+        {
+            csubstr anchor = _scan_anchor();
+            _c4dbgpf("usty[UNK]: anchor! [{}]~~~{}~~~", anchor.len, anchor);
+            const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+            const size_t line = m_evt_handler->m_curr->pos.line;
+            _add_annotation(&m_pending_anchors, anchor, indentation, line);
+            _set_indentation(m_evt_handler->m_curr->line_contents.current_col(rem));
+        }
+        else if(first == '*')
+        {
+            csubstr ref = _scan_ref_map();
+            _c4dbgpf("usty[UNK]: ref! [{}]~~~{}~~~", ref.len, ref);
+            if(!_maybe_scan_following_colon())
+            {
+                _c4dbgp("usty[UNK]: set val ref");
+                _handle_annotations_before_blck_val_scalar();
+                m_evt_handler->set_val_ref(ref);
+            }
+            else
+            {
+                _c4dbgp("usty[UNK]: start new block map, set ref as key");
+                const size_t startline = m_evt_handler->m_curr->pos.line; // save
+                add_flags(RNXT);
+                _handle_annotations_before_start_mapblck(startline);
+                m_evt_handler->begin_map_val_block();
+                _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                m_evt_handler->set_key_ref(ref);
+                _maybe_skip_whitespace_tokens();
+                _set_indentation(startindent);
+                addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+            }
+        }
+        else if(first == '!')
+        {
+            csubstr tag = _scan_tag();
+            _c4dbgpf("usty[UNK]: val tag! [{}]~~~{}~~~", tag.len, tag);
+            // we need to buffer the tags, as there may be two
+            // consecutive tags in here
+            const size_t indentation = m_evt_handler->m_curr->line_contents.current_col(rem);
+            const size_t line = m_evt_handler->m_curr->pos.line;
+            _add_annotation(&m_pending_tags, tag, indentation, line);
+        }
+        else
+        {
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! has_any(SSCL));
+            startindent = m_evt_handler->m_curr->line_contents.indentation; // save
+            const size_t startline = m_evt_handler->m_curr->pos.line; // save
+            first = rem.str[0];
+            ScannedScalar sc;
+            _c4dbgpf("usty[UNK]: maybe scalar. first='{}'", _c4prc(first));
+            if(first == '\'')
+            {
+                _c4dbgp("usty[UNK]: scanning single-quoted scalar");
+                sc = _scan_scalar_squot();
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4dbgp("usty[UNK]: set as val");
+                    _handle_annotations_before_blck_val_scalar();
+                    csubstr maybe_filtered = _maybe_filter_val_scalar_squot(sc);
+                    m_evt_handler->set_val_scalar_squoted(maybe_filtered);
+                    _end_stream();
+                }
+                else
+                {
+                    _c4dbgp("usty[UNK]: start new block map, set scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_squot(sc);
+                    m_evt_handler->set_key_scalar_squoted(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else if(first == '"')
+            {
+                _c4dbgp("usty[UNK]: scanning double-quoted scalar");
+                sc = _scan_scalar_dquot();
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4dbgp("usty[UNK]: set as val");
+                    _handle_annotations_before_blck_val_scalar();
+                    csubstr maybe_filtered = _maybe_filter_val_scalar_dquot(sc);
+                    m_evt_handler->set_val_scalar_dquoted(maybe_filtered);
+                    _end_stream();
+                }
+                else
+                {
+                    _c4dbgp("usty[UNK]: start new block map, set double-quoted scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_dquot(sc);
+                    m_evt_handler->set_key_scalar_dquoted(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else if(first == '|')
+            {
+                _c4dbgp("usty[UNK]: scanning block-literal scalar");
+                ScannedBlock sb;
+                _scan_block(&sb, startindent);
+                _c4dbgp("usty[UNK]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_literal(sb);
+                m_evt_handler->set_val_scalar_literal(maybe_filtered);
+                _end_stream();
+            }
+            else if(first == '>')
+            {
+                _c4dbgp("usty[UNK]: scanning block-folded scalar");
+                ScannedBlock sb;
+                _scan_block(&sb, startindent);
+                _c4dbgp("usty[UNK]: set as val");
+                _handle_annotations_before_blck_val_scalar();
+                csubstr maybe_filtered = _maybe_filter_val_scalar_folded(sb);
+                m_evt_handler->set_val_scalar_folded(maybe_filtered);
+                _end_stream();
+            }
+            else if(_scan_scalar_plain_unk(&sc))
+            {
+                _c4dbgp("usty[UNK]: got a plain scalar");
+                if(!_maybe_scan_following_colon())
+                {
+                    _c4dbgp("usty[UNK]: set as val");
+                    _handle_annotations_before_blck_val_scalar();
+                    csubstr maybe_filtered = _maybe_filter_val_scalar_plain(sc, startindent);
+                    m_evt_handler->set_val_scalar_plain(maybe_filtered);
+                    _end_stream();
+                }
+                else
+                {
+                    _c4dbgp("usty[UNK]: start new block map, set scalar as key");
+                    add_flags(RNXT);
+                    _handle_annotations_before_start_mapblck(startline);
+                    m_evt_handler->begin_map_val_block();
+                    _handle_annotations_and_indentation_after_start_mapblck(startindent, startline);
+                    csubstr maybe_filtered = _maybe_filter_key_scalar_plain(sc, startindent);
+                    m_evt_handler->set_key_scalar_plain(maybe_filtered);
+                    _set_indentation(startindent);
+                    addrem_flags(RMAP|BLCK|RVAL, RNXT|USTY);
+                    _maybe_skip_whitespace_tokens();
+                }
+            }
+            else
+            {
+                _c4err("parse error");
+            }
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::parse_json_in_place_ev(csubstr filename, substr src)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 1);
+    m_file = filename;
+    m_buf = src;
+    _reset();
+    m_evt_handler->start_parse(filename.str, &_s_relocate_arena, this);
+    m_evt_handler->begin_stream();
+    while( ! _finished_file())
+    {
+        _scan_line();
+        while( ! _finished_line())
+        {
+            _c4dbgnextline();
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! m_evt_handler->m_curr->line_contents.rem.empty());
+            if(has_any(RSEQ))
+            {
+                _handle_seq_json();
+            }
+            else if(has_any(RMAP))
+            {
+                _handle_map_json();
+            }
+            else if(has_any(RUNK))
+            {
+                _handle_unk_json();
+            }
+            else
+            {
+                _c4err("internal error");
+            }
+        }
+        if(_finished_file())
+            break; // it may have finished because of multiline blocks
+        _line_ended();
+    }
+    _end_stream();
+    m_evt_handler->finish_parse();
+}
+
+
+//-----------------------------------------------------------------------------
+
+template<class EventHandler>
+void ParseEngine<EventHandler>::parse_in_place_ev(csubstr filename, substr src)
+{
+    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, m_evt_handler->m_stack.size() >= 1);
+    m_file = filename;
+    m_buf = src;
+    _reset();
+    m_evt_handler->start_parse(filename.str, &_s_relocate_arena, this);
+    m_evt_handler->begin_stream();
+    while( ! _finished_file())
+    {
+        _scan_line();
+        while( ! _finished_line())
+        {
+            _c4dbgnextline();
+            _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks,  ! m_evt_handler->m_curr->line_contents.rem.empty());
+            if(has_any(FLOW))
+            {
+                if(has_none(RSEQIMAP))
+                {
+                    if(has_any(RSEQ))
+                    {
+                        _handle_seq_flow();
+                    }
+                    else
+                    {
+                        _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
+                        _handle_map_flow();
+                    }
+                }
+                else
+                {
+                    _handle_seq_imap();
+                }
+            }
+            else if(has_any(BLCK))
+            {
+                if(has_any(RSEQ))
+                {
+                    _handle_seq_block();
+                }
+                else
+                {
+                    _RYML_CB_ASSERT(m_evt_handler->m_stack.m_callbacks, has_all(RMAP));
+                    _handle_map_block();
+                }
+            }
+            else if(has_any(RUNK))
+            {
+                _handle_unk();
+            }
+            else if(has_any(USTY))
+            {
+                _handle_usty();
+            }
+            else
+            {
+                _c4err("internal error");
+            }
+        }
+        if(_finished_file())
+            break; // it may have finished because of multiline blocks
+        _line_ended();
+    }
+    _end_stream();
+    m_evt_handler->finish_parse();
+}
+/** @endcond */
+
+} // namespace yml
+} // namespace c4
+
+// NOLINTEND(hicpp-signed-bitwise,cppcoreguidelines-avoid-goto,hicpp-avoid-goto,hicpp-multiway-paths-covered)
+
+#undef _c4dbgnextline
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#elif defined(__clang__)
+#   pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic pop
+#endif
+
+#endif // _C4_YML_PARSE_ENGINE_DEF_HPP_
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.def.hpp)
+
+
+
+//********************************************************************************
+//--------------------------------------------------------------------------------
+// src/c4/yml/reference_resolver.cpp
+// https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.cpp
+//--------------------------------------------------------------------------------
+//********************************************************************************
+
+#ifdef RYML_SINGLE_HDR_DEFINE_NOW
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.hpp
+//#include "c4/yml/reference_resolver.hpp"
+#if !defined(C4_YML_REFERENCE_RESOLVER_HPP_) && !defined(_C4_YML_REFERENCE_RESOLVER_HPP_)
+#error "amalgamate: file c4/yml/reference_resolver.hpp must have been included at this point"
+#endif /* C4_YML_REFERENCE_RESOLVER_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_ */
+
+// 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_ */
+
+#else
+#define _c4dbg_tree(...)
+#define _c4dbg_node(...)
+#endif
+
+namespace c4 {
+namespace yml {
+
+/** @cond dev */
+
+id_type ReferenceResolver::count_anchors_and_refs_(id_type n)
+{
+    id_type c = 0;
+    c += m_tree->has_key_anchor(n);
+    c += m_tree->has_val_anchor(n);
+    c += m_tree->is_key_ref(n);
+    c += m_tree->is_val_ref(n);
+    c += m_tree->has_key(n) && m_tree->key(n) == "<<";
+    for(id_type ch = m_tree->first_child(n); ch != NONE; ch = m_tree->next_sibling(ch))
+        c += count_anchors_and_refs_(ch);
+    return c;
+}
+
+void ReferenceResolver::gather_anchors_and_refs__(id_type n)
+{
+    // insert key refs BEFORE inserting val refs
+    if(m_tree->has_key(n))
+    {
+        if(m_tree->key(n) == "<<")
+        {
+            _c4dbgpf("node[{}]: key is <<", n);
+            if(m_tree->has_val(n))
+            {
+                if(m_tree->is_val_ref(n))
+                {
+                    _c4dbgpf("node[{}]: instance[{}]: val ref, inheriting! '{}'", n, m_refs.size(), m_tree->val_ref(n));
+                    m_refs.push({VALREF, n, NONE, NONE, NONE, NONE});
+                    //m_refs.push({KEYREF, n, NONE, NONE, NONE, NONE});
+                }
+                else
+                {
+                    _c4dbgpf("node[{}]: not ref!", n);
+                }
+            }
+            else if(m_tree->is_seq(n))
+            {
+                // for merging multiple inheritance targets
+                //   <<: [ *CENTER, *BIG ]
+                _c4dbgpf("node[{}]: is seq!", n);
+                for(id_type ich = m_tree->first_child(n); ich != NONE; ich = m_tree->next_sibling(ich))
+                {
+                    _c4dbgpf("node[{}]: instance [{}]: val ref, inheriting multiple: {} '{}'", n, m_refs.size(), ich, m_tree->val_ref(ich));
+                    if(m_tree->is_container(ich))
+                    {
+                        detail::_report_err(m_tree->m_callbacks, "ERROR: node {} child {}: refs for << cannot be containers.'", n, ich);
+                        C4_UNREACHABLE_AFTER_ERR();
+                    }
+                    m_refs.push({VALREF, ich, NONE, NONE, n, m_tree->next_sibling(n)});
+                }
+                return; // don't descend into the seq
+            }
+            else
+            {
+                detail::_report_err(m_tree->m_callbacks, "ERROR: node {}: refs for << must be either val or seq", n);
+                C4_UNREACHABLE_AFTER_ERR();
+            }
+        }
+        else if(m_tree->is_key_ref(n))
+        {
+            _c4dbgpf("node[{}]: instance[{}]: key ref: '{}', key='{}'", n, m_refs.size(), m_tree->key_ref(n), m_tree->has_key(n) ? m_tree->key(n) : csubstr{"-"});
+            _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->key(n) != "<<");
+            _RYML_CB_CHECK(m_tree->m_callbacks, (!m_tree->has_key(n)) || m_tree->key(n).ends_with(m_tree->key_ref(n)));
+            m_refs.push({KEYREF, n, NONE, NONE, NONE, NONE});
+        }
+    }
+    // val ref
+    if(m_tree->is_val_ref(n) && (!m_tree->has_key(n) || m_tree->key(n) != "<<"))
+    {
+        _c4dbgpf("node[{}]: instance[{}]: val ref: '{}'", n, m_refs.size(), m_tree->val_ref(n));
+        RYML_CHECK((!m_tree->has_val(n)) || m_tree->val(n).ends_with(m_tree->val_ref(n)));
+        m_refs.push({VALREF, n, NONE, NONE, NONE, NONE});
+    }
+    // anchors
+    if(m_tree->has_key_anchor(n))
+    {
+        _c4dbgpf("node[{}]: instance[{}]: key anchor: '{}'", n, m_refs.size(), m_tree->key_anchor(n));
+        RYML_CHECK(m_tree->has_key(n));
+        m_refs.push({KEYANCH, n, NONE, NONE, NONE, NONE});
+    }
+    if(m_tree->has_val_anchor(n))
+    {
+        _c4dbgpf("node[{}]: instance[{}]: val anchor: '{}'", n, m_refs.size(), m_tree->val_anchor(n));
+        RYML_CHECK(m_tree->has_val(n) || m_tree->is_container(n));
+        m_refs.push({VALANCH, n, NONE, NONE, NONE, NONE});
+    }
+    // recurse
+    for(id_type ch = m_tree->first_child(n); ch != NONE; ch = m_tree->next_sibling(ch))
+        gather_anchors_and_refs__(ch);
+}
+
+void ReferenceResolver::gather_anchors_and_refs_()
+{
+    _c4dbgp("gathering anchors and refs...");
+
+    // minimize (re-)allocations by counting first
+    id_type num_anchors_and_refs = count_anchors_and_refs_(m_tree->root_id());
+    if(!num_anchors_and_refs)
+        return;
+    m_refs.reserve(num_anchors_and_refs);
+    m_refs.clear();
+
+    // now descend through the hierarchy
+    gather_anchors_and_refs__(m_tree->root_id());
+
+    _c4dbgpf("found {} anchors/refs", m_refs.size());
+
+    // finally connect the reference list
+    id_type prev_anchor = NONE;
+    id_type count = 0;
+    for(auto &rd : m_refs)
+    {
+        rd.prev_anchor = prev_anchor;
+        if(rd.type.has_anchor())
+            prev_anchor = count;
+        ++count;
+    }
+    _c4dbgp("gathering anchors and refs: finished");
+}
+
+id_type ReferenceResolver::lookup_(RefData const* C4_RESTRICT ra)
+{
+    #ifdef RYML_DBG
+    id_type instance = static_cast<id_type>(ra-m_refs.m_stack);
+    id_type node = ra->node;
+    #endif
+    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;
+    _c4dbgpf("instance[{}:node{}]: lookup from node={}...", instance, node, ra->node);
+    if(ra->type.is_val_ref())
+    {
+        refname = m_tree->val_ref(ra->node);
+        _c4dbgpf("instance[{}:node{}]: valref: '{}'", instance, node, refname);
+    }
+    else
+    {
+        RYML_ASSERT(ra->type.is_key_ref());
+        refname = m_tree->key_ref(ra->node);
+        _c4dbgpf("instance[{}:node{}]: keyref: '{}'", instance, node, refname);
+    }
+    while(ra->prev_anchor != NONE)
+    {
+        ra = &m_refs[ra->prev_anchor];
+        _c4dbgpf("instance[{}:node{}]: lookup '{}' at [{}:node{}]: keyref='{}' valref='{}'", instance, node, refname, ra-m_refs.m_stack, ra->node,
+                 (m_tree->has_key_anchor(ra->node) ? m_tree->key_anchor(ra->node) : csubstr("~")),
+                 (m_tree->has_val_anchor(ra->node) ? m_tree->val_anchor(ra->node) : csubstr("~")));
+        if(m_tree->has_anchor(ra->node, refname))
+        {
+            _c4dbgpf("instance[{}:node{}]: got it at [{}:node{}]!", instance, node, ra-m_refs.m_stack, ra->node);
+            return ra->node;
+        }
+    }
+    detail::_report_err(m_tree->m_callbacks, "ERROR: anchor not found: '{}'", refname);
+    C4_UNREACHABLE_AFTER_ERR();
+}
+
+void ReferenceResolver::reset_(Tree *t_)
+{
+    if(t_->callbacks() != m_refs.m_callbacks)
+    {
+        m_refs.m_callbacks = t_->callbacks();
+    }
+    m_tree = t_;
+    m_refs.clear();
+}
+
+void ReferenceResolver::resolve_()
+{
+    /* 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 */
+    _c4dbgp("matching anchors/refs...");
+    for(id_type i = 0, e = m_refs.size(); i < e; ++i)
+    {
+        RefData &C4_RESTRICT refdata = m_refs.top(i);
+        if( ! refdata.type.is_ref())
+            continue;
+        refdata.target = lookup_(&refdata);
+    }
+    _c4dbgp("matching anchors/refs: finished");
+
+    // insert the resolved references
+    _c4dbgp("modifying tree...");
+    id_type prev_parent_ref = NONE;
+    id_type prev_parent_ref_after = NONE;
+    for(id_type i = 0, e = m_refs.size(); i < e; ++i)
+    {
+        RefData const& C4_RESTRICT refdata = m_refs[i];
+        _c4dbgpf("instance[{}:node{}]: {}/{}...", i, refdata.node, i+1, e);
+        if( ! refdata.type.is_ref())
+            continue;
+        _c4dbgpf("instance[{}:node{}]: is reference!", i, refdata.node);
+        if(refdata.parent_ref != NONE)
+        {
+            _c4dbgpf("instance[{}:node{}] has parent: {}", i, refdata.node, refdata.parent_ref);
+            _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->is_seq(refdata.parent_ref));
+            const id_type p = m_tree->parent(refdata.parent_ref);
+            const id_type after = (prev_parent_ref != refdata.parent_ref) ?
+                refdata.parent_ref//prev_sibling(rd.parent_ref_sibling)
+                :
+                prev_parent_ref_after;
+            prev_parent_ref = refdata.parent_ref;
+            prev_parent_ref_after = m_tree->duplicate_children_no_rep(refdata.target, p, after);
+            m_tree->remove(refdata.node);
+        }
+        else
+        {
+            _c4dbgpf("instance[{}:node{}] has no parent", i, refdata.node, refdata.parent_ref);
+            if(m_tree->has_key(refdata.node) && m_tree->key(refdata.node) == "<<")
+            {
+                _c4dbgpf("instance[{}:node{}] is inheriting", i, refdata.node);
+                _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->is_keyval(refdata.node));
+                const id_type p = m_tree->parent(refdata.node);
+                const id_type after = m_tree->prev_sibling(refdata.node);
+                _c4dbgpf("instance[{}:node{}] p={} after={}", i, refdata.node, p, after);
+                m_tree->duplicate_children_no_rep(refdata.target, p, after);
+                m_tree->remove(refdata.node);
+            }
+            else if(refdata.type.is_key_ref())
+            {
+                _c4dbgpf("instance[{}:node{}] is key ref", i, refdata.node);
+                _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->is_key_ref(refdata.node));
+                _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->has_key_anchor(refdata.target) || m_tree->has_val_anchor(refdata.target));
+                if(m_tree->has_val_anchor(refdata.target) && m_tree->val_anchor(refdata.target) == m_tree->key_ref(refdata.node))
+                {
+                    _c4dbgpf("instance[{}:node{}] target.anchor==val.anchor=={}", i, refdata.node, m_tree->val_anchor(refdata.target));
+                    _RYML_CB_CHECK(m_tree->m_callbacks, !m_tree->is_container(refdata.target));
+                    _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->has_val(refdata.target));
+                    const type_bits existing_style_flags = VAL_STYLE & m_tree->_p(refdata.target)->m_type.type;
+                    static_assert((VAL_STYLE >> 1u) == (KEY_STYLE), "bad flags");
+                    m_tree->_p(refdata.node)->m_key.scalar = m_tree->val(refdata.target);
+                    m_tree->_add_flags(refdata.node, KEY | (existing_style_flags >> 1u));
+                }
+                else
+                {
+                    _c4dbgpf("instance[{}:node{}] don't inherit container flags", i, refdata.node);
+                    _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->key_anchor(refdata.target) == m_tree->key_ref(refdata.node));
+                    m_tree->_p(refdata.node)->m_key.scalar = m_tree->key(refdata.target);
+                    // keys cannot be containers, so don't inherit container flags
+                    const type_bits existing_style_flags = KEY_STYLE & m_tree->_p(refdata.target)->m_type.type;
+                    m_tree->_add_flags(refdata.node, KEY | existing_style_flags);
+                }
+            }
+            else // val ref
+            {
+                _c4dbgpf("instance[{}:node{}] is val ref", i, refdata.node);
+                _RYML_CB_ASSERT(m_tree->m_callbacks, refdata.type.is_val_ref());
+                if(m_tree->has_key_anchor(refdata.target) && m_tree->key_anchor(refdata.target) == m_tree->val_ref(refdata.node))
+                {
+                    _c4dbgpf("instance[{}:node{}] target.anchor==key.anchor=={}", i, refdata.node, m_tree->val_anchor(refdata.target));
+                    _RYML_CB_CHECK(m_tree->m_callbacks, !m_tree->is_container(refdata.target));
+                    _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->has_val(refdata.target));
+                    // keys cannot be containers, so don't inherit container flags
+                    const type_bits existing_style_flags = (KEY_STYLE) & m_tree->_p(refdata.target)->m_type.type;
+                    static_assert((KEY_STYLE << 1u) == (VAL_STYLE), "bad flags");
+                    m_tree->_p(refdata.node)->m_val.scalar = m_tree->key(refdata.target);
+                    m_tree->_add_flags(refdata.node, VAL | (existing_style_flags << 1u));
+                }
+                else
+                {
+                    _c4dbgpf("instance[{}:node{}] duplicate contents", i, refdata.node);
+                    m_tree->duplicate_contents(refdata.target, refdata.node);
+                }
+            }
+        }
+        _c4dbg_tree("after insertion", *m_tree);
+    }
+}
+
+void ReferenceResolver::resolve(Tree *t_, bool clear_anchors)
+{
+    _c4dbgp("resolving references...");
+
+    reset_(t_);
+
+    _c4dbg_tree("unresolved tree", *m_tree);
+
+    gather_anchors_and_refs_();
+    if(m_refs.empty())
+        return;
+    resolve_();
+    _c4dbg_tree("resolved tree", *m_tree);
+
+    // clear anchors and refs
+    if(clear_anchors)
+    {
+        _c4dbgp("clearing anchors/refs");
+        auto clear_ = [this]{
+            for(auto const& C4_RESTRICT ar : m_refs)
+            {
+                m_tree->rem_anchor_ref(ar.node);
+                if(ar.parent_ref != NONE)
+                    if(m_tree->type(ar.parent_ref) != NOTYPE)
+                        m_tree->remove(ar.parent_ref);
+            }
+        };
+        clear_();
+        // some of the elements injected during the resolution may
+        // have nested anchors; these anchors will have been newly
+        // injected during the resolution; collect again, and clear
+        // again, to ensure those are also cleared:
+        gather_anchors_and_refs_();
+        clear_();
+        _c4dbgp("clearing anchors/refs: finished");
+    }
+
+    _c4dbg_tree("final resolved tree", *m_tree);
+
+    m_tree = nullptr;
+    _c4dbgp("resolving references: finished");
+}
+
+/** @endcond */
+
+} // namespace ryml
+} // namespace c4
+
+#endif /* RYML_SINGLE_HDR_DEFINE_NOW */
+
+
+// (end https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.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_ */
+
+
+#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_PARSE_ENGINE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.hpp
+//#include "c4/yml/parse_engine.hpp"
+#if !defined(C4_YML_PARSE_ENGINE_HPP_) && !defined(_C4_YML_PARSE_ENGINE_HPP_)
+#error "amalgamate: file c4/yml/parse_engine.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_ENGINE_HPP_ */
+
+#endif
+#ifndef _C4_YML_PARSE_ENGINE_DEF_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.def.hpp
+//#include "c4/yml/parse_engine.def.hpp"
+#if !defined(C4_YML_PARSE_ENGINE_DEF_HPP_) && !defined(_C4_YML_PARSE_ENGINE_DEF_HPP_)
+#error "amalgamate: file c4/yml/parse_engine.def.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_ENGINE_DEF_HPP_ */
+
+#endif
+#ifndef _C4_YML_EVENT_HANDLER_TREE_HPP_
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/event_handler_tree.hpp
+//#include "c4/yml/event_handler_tree.hpp"
+#if !defined(C4_YML_EVENT_HANDLER_TREE_HPP_) && !defined(_C4_YML_EVENT_HANDLER_TREE_HPP_)
+#error "amalgamate: file c4/yml/event_handler_tree.hpp must have been included at this point"
+#endif /* C4_YML_EVENT_HANDLER_TREE_HPP_ */
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+namespace yml {
+
+// instantiate the parser class
+template class ParseEngine<EventHandlerTree>;
+
+namespace {
+inline void _reset_tree_handler(Parser *parser, Tree *t, id_type node_id)
+{
+    RYML_ASSERT(parser);
+    RYML_ASSERT(t);
+    if(!parser->m_evt_handler)
+        _RYML_CB_ERR(t->m_callbacks, "event handler is not set");
+    parser->m_evt_handler->reset(t, node_id);
+    RYML_ASSERT(parser->m_evt_handler->m_tree == t);
+}
+} // namespace
+
+void parse_in_place(Parser *parser, csubstr filename, substr yaml, Tree *t, id_type node_id)
+{
+    _reset_tree_handler(parser, t, node_id);
+    parser->parse_in_place_ev(filename, yaml);
+}
+
+void parse_json_in_place(Parser *parser, csubstr filename, substr json, Tree *t, id_type node_id)
+{
+    _reset_tree_handler(parser, t, node_id);
+    parser->parse_json_in_place_ev(filename, json);
+}
+
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_in_place(Parser *parser,                   substr yaml, Tree *t, id_type node_id) { parse_in_place(parser, {}, yaml, t, node_id); }
+void parse_in_place(Parser *parser, csubstr filename, substr yaml, Tree *t                ) { RYML_CHECK(t); parse_in_place(parser, filename, yaml, t, t->root_id()); }
+void parse_in_place(Parser *parser,                   substr yaml, Tree *t                ) { RYML_CHECK(t); parse_in_place(parser, {}      , yaml, t, t->root_id()); }
+void parse_in_place(Parser *parser, csubstr filename, substr yaml, NodeRef node           ) { RYML_CHECK(!node.invalid()); parse_in_place(parser, filename, yaml, node.tree(), node.id()); }
+void parse_in_place(Parser *parser,                   substr yaml, NodeRef node           ) { RYML_CHECK(!node.invalid()); parse_in_place(parser, {}      , yaml, node.tree(), node.id()); }
+Tree parse_in_place(Parser *parser, csubstr filename, substr yaml                         ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); parse_in_place(parser, filename, yaml, &tree, tree.root_id()); return tree; }
+Tree parse_in_place(Parser *parser,                   substr yaml                         ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); parse_in_place(parser, {}      , yaml, &tree, tree.root_id()); return tree; }
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_in_place(csubstr filename, substr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, filename, yaml, t, node_id); }
+void parse_in_place(                  substr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, {}      , yaml, t, node_id); }
+void parse_in_place(csubstr filename, substr yaml, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, filename, yaml, t, t->root_id()); }
+void parse_in_place(                  substr yaml, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, {}      , yaml, t, t->root_id()); }
+void parse_in_place(csubstr filename, substr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, filename, yaml, node.tree(), node.id()); }
+void parse_in_place(                  substr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); parse_in_place(&parser, {}      , yaml, node.tree(), node.id()); }
+Tree parse_in_place(csubstr filename, substr yaml                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); parse_in_place(&parser, filename, yaml, &tree, tree.root_id()); return tree; }
+Tree parse_in_place(                  substr yaml                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); parse_in_place(&parser, {}      , yaml, &tree, tree.root_id()); return tree; }
+
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_json_in_place(Parser *parser,                   substr json, Tree *t, id_type node_id) { parse_json_in_place(parser, {}, json, t, node_id); }
+void parse_json_in_place(Parser *parser, csubstr filename, substr json, Tree *t                 ) { RYML_CHECK(t); parse_json_in_place(parser, filename, json, t, t->root_id()); }
+void parse_json_in_place(Parser *parser,                   substr json, Tree *t                 ) { RYML_CHECK(t); parse_json_in_place(parser, {}      , json, t, t->root_id()); }
+void parse_json_in_place(Parser *parser, csubstr filename, substr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); parse_json_in_place(parser, filename, json, node.tree(), node.id()); }
+void parse_json_in_place(Parser *parser,                   substr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); parse_json_in_place(parser, {}      , json, node.tree(), node.id()); }
+Tree parse_json_in_place(Parser *parser, csubstr filename, substr json                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); parse_json_in_place(parser, filename, json, &tree, tree.root_id()); return tree; }
+Tree parse_json_in_place(Parser *parser,                   substr json                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); parse_json_in_place(parser, {}      , json, &tree, tree.root_id()); return tree; }
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_json_in_place(csubstr filename, substr json, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, filename, json, t, node_id); }
+void parse_json_in_place(                  substr json, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, {}      , json, t, node_id); }
+void parse_json_in_place(csubstr filename, substr json, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, filename, json, t, t->root_id()); }
+void parse_json_in_place(                  substr json, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, {}      , json, t, t->root_id()); }
+void parse_json_in_place(csubstr filename, substr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, filename, json, node.tree(), node.id()); }
+void parse_json_in_place(                  substr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); parse_json_in_place(&parser, {}      , json, node.tree(), node.id()); }
+Tree parse_json_in_place(csubstr filename, substr json                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); parse_json_in_place(&parser, filename, json, &tree, tree.root_id()); return tree; }
+Tree parse_json_in_place(                  substr json                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); parse_json_in_place(&parser, {}      , json, &tree, tree.root_id()); return tree; }
+
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); substr src = t->copy_to_arena(yaml); parse_in_place(parser, filename, src, t, node_id); }
+void parse_in_arena(Parser *parser,                   csubstr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); substr src = t->copy_to_arena(yaml); parse_in_place(parser, {}      , src, t, node_id); }
+void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, Tree *t                 ) { RYML_CHECK(t); substr src = t->copy_to_arena(yaml); parse_in_place(parser, filename, src, t, t->root_id()); }
+void parse_in_arena(Parser *parser,                   csubstr yaml, Tree *t                 ) { RYML_CHECK(t); substr src = t->copy_to_arena(yaml); parse_in_place(parser, {}      , src, t, t->root_id()); }
+void parse_in_arena(Parser *parser, csubstr filename, csubstr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); substr src = node.tree()->copy_to_arena(yaml); parse_in_place(parser, filename, src, node.tree(), node.id()); }
+void parse_in_arena(Parser *parser,                   csubstr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); substr src = node.tree()->copy_to_arena(yaml); parse_in_place(parser, {}      , src, node.tree(), node.id()); }
+Tree parse_in_arena(Parser *parser, csubstr filename, csubstr yaml                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); substr src = tree.copy_to_arena(yaml); parse_in_place(parser, filename, src, &tree, tree.root_id()); return tree; }
+Tree parse_in_arena(Parser *parser,                   csubstr yaml                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); substr src = tree.copy_to_arena(yaml); parse_in_place(parser, {}      , src, &tree, tree.root_id()); return tree; }
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_in_arena(csubstr filename, csubstr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(yaml); parse_in_place(&parser, filename, src, t, node_id); }
+void parse_in_arena(                  csubstr yaml, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(yaml); parse_in_place(&parser, {}      , src, t, node_id); }
+void parse_in_arena(csubstr filename, csubstr yaml, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(yaml); parse_in_place(&parser, filename, src, t, t->root_id()); }
+void parse_in_arena(                  csubstr yaml, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(yaml); parse_in_place(&parser, {}      , src, t, t->root_id()); }
+void parse_in_arena(csubstr filename, csubstr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); substr src = node.tree()->copy_to_arena(yaml); parse_in_place(&parser, filename, src, node.tree(), node.id()); }
+void parse_in_arena(                  csubstr yaml, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); substr src = node.tree()->copy_to_arena(yaml); parse_in_place(&parser, {}      , src, node.tree(), node.id()); }
+Tree parse_in_arena(csubstr filename, csubstr yaml                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); substr src = tree.copy_to_arena(yaml); parse_in_place(&parser, filename, src, &tree, tree.root_id()); return tree; }
+Tree parse_in_arena(                  csubstr yaml                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); substr src = tree.copy_to_arena(yaml); parse_in_place(&parser, {}      , src, &tree, tree.root_id()); return tree; }
+
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, Tree *t, id_type node_id) { RYML_CHECK(t); substr src = t->copy_to_arena(json); parse_json_in_place(parser, filename, src, t, node_id); }
+void parse_json_in_arena(Parser *parser,                   csubstr json, Tree *t, id_type node_id) { RYML_CHECK(t); substr src = t->copy_to_arena(json); parse_json_in_place(parser, {}      , src, t, node_id); }
+void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, Tree *t                 ) { RYML_CHECK(t); substr src = t->copy_to_arena(json); parse_json_in_place(parser, filename, src, t, t->root_id()); }
+void parse_json_in_arena(Parser *parser,                   csubstr json, Tree *t                 ) { RYML_CHECK(t); substr src = t->copy_to_arena(json); parse_json_in_place(parser, {}      , src, t, t->root_id()); }
+void parse_json_in_arena(Parser *parser, csubstr filename, csubstr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); substr src = node.tree()->copy_to_arena(json); parse_json_in_place(parser, filename, src, node.tree(), node.id()); }
+void parse_json_in_arena(Parser *parser,                   csubstr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); substr src = node.tree()->copy_to_arena(json); parse_json_in_place(parser, {}      , src, node.tree(), node.id()); }
+Tree parse_json_in_arena(Parser *parser, csubstr filename, csubstr json                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); substr src = tree.copy_to_arena(json); parse_json_in_place(parser, filename, src, &tree, tree.root_id()); return tree; }
+Tree parse_json_in_arena(Parser *parser,                   csubstr json                          ) { RYML_CHECK(parser); RYML_CHECK(parser->m_evt_handler); Tree tree(parser->callbacks()); substr src = tree.copy_to_arena(json); parse_json_in_place(parser, {}      , src, &tree, tree.root_id()); return tree; }
+
+// this is vertically aligned to highlight the parameter differences.
+void parse_json_in_arena(csubstr filename, csubstr json, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(json); parse_json_in_place(&parser, filename, src, t, node_id); }
+void parse_json_in_arena(                  csubstr json, Tree *t, id_type node_id) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(json); parse_json_in_place(&parser, {}      , src, t, node_id); }
+void parse_json_in_arena(csubstr filename, csubstr json, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(json); parse_json_in_place(&parser, filename, src, t, t->root_id()); }
+void parse_json_in_arena(                  csubstr json, Tree *t                 ) { RYML_CHECK(t); Parser::handler_type event_handler(t->callbacks()); Parser parser(&event_handler); substr src = t->copy_to_arena(json); parse_json_in_place(&parser, {}      , src, t, t->root_id()); }
+void parse_json_in_arena(csubstr filename, csubstr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); substr src = node.tree()->copy_to_arena(json); parse_json_in_place(&parser, filename, src, node.tree(), node.id()); }
+void parse_json_in_arena(                  csubstr json, NodeRef node            ) { RYML_CHECK(!node.invalid()); Parser::handler_type event_handler(node.tree()->callbacks()); Parser parser(&event_handler); substr src = node.tree()->copy_to_arena(json); parse_json_in_place(&parser, {}      , src, node.tree(), node.id()); }
+Tree parse_json_in_arena(csubstr filename, csubstr json                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); substr src = tree.copy_to_arena(json); parse_json_in_place(&parser, filename, src, &tree, tree.root_id()); return tree; }
+Tree parse_json_in_arena(                  csubstr json                          ) { Parser::handler_type event_handler; Parser parser(&event_handler); Tree tree(parser.callbacks()); substr src = tree.copy_to_arena(json); parse_json_in_place(&parser, {}      , src, &tree, tree.root_id()); return tree; }
+
+
+RYML_EXPORT C4_NO_INLINE size_t _find_last_newline_and_larger_indentation(csubstr s, size_t indentation) noexcept
+{
+    if(indentation + 1 > s.len)
+        return npos;
+    for(size_t i = s.len-indentation-1; i != size_t(-1); --i)
+    {
+        if(s.str[i] == '\n')
+        {
+            csubstr rem = s.sub(i + 1);
+            size_t first = rem.first_not_of(' ');
+            first = (first != npos) ? first : rem.len;
+            if(first > indentation)
+                return i;
+        }
+    }
+    return npos;
+}
+
+//-----------------------------------------------------------------------------
+
+RYML_EXPORT id_type estimate_tree_capacity(csubstr src)
+{
+    id_type num_nodes = 1; // root
+    for(size_t i = 0; i < src.len; ++i)
+    {
+        const char c = src.str[i];
+        num_nodes += (c == '\n') || (c == ',') || (c == '[') || (c == '{');
+    }
+    return num_nodes;
+}
+
+} // namespace yml
+} // namespace c4
+
+#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;
+}
+
+} // 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.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 {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+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 == '$');
+}
+
+enum _ppstate : int { kReadPending = 0, kKeyPending = 1, kValPending = 2 };
+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;
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} // 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, id_type node=NONE);
+void check_free_list(Tree const& t);
+void check_arena(Tree const& t);
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void check_invariants(Tree const& t, id_type node)
+{
+    if(node == NONE)
+    {
+        if(t.empty()) return;
+        node = t.root_id();
+    }
+
+    NodeData const& n = *t._p(node);
+#if defined(RYML_DBG) && 0
+    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);
+    }
+
+    id_type count = 0;
+    for(id_type i = n.m_first_child; i != NONE; i = t.next_sibling(i))
+    {
+#if defined(RYML_DBG) && 0
+        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(id_type 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);
+
+    id_type count = 0;
+    for(id_type 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_ */
+
+
+#ifdef RYML_DBG
+#define _c4dbg_tree(...) print_tree(__VA_ARGS__)
+#define _c4dbg_node(...) print_tree(__VA_ARGS__)
+#else
+#define _c4dbg_tree(...)
+#define _c4dbg_node(...)
+#endif
+
+namespace c4 {
+namespace yml {
+
+C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
+C4_SUPPRESS_WARNING_GCC("-Wuseless-cast")
+
+inline const char* _container_style_code(Tree const& p, id_type node)
+{
+    if(p.is_container(node))
+    {
+        if(p._p(node)->m_type & (FLOW_SL|FLOW_ML))
+        {
+            return "[FLOW]";
+        }
+        if(p._p(node)->m_type & (BLOCK))
+        {
+            return "[BLCK]";
+        }
+    }
+    return "";
+}
+inline char _scalar_code(NodeType masked)
+{
+    if(masked & (KEY_LITERAL|VAL_LITERAL))
+        return '|';
+    if(masked & (KEY_FOLDED|VAL_FOLDED))
+        return '>';
+    if(masked & (KEY_SQUO|VAL_SQUO))
+        return '\'';
+    if(masked & (KEY_DQUO|VAL_DQUO))
+        return '"';
+    if(masked & (KEY_PLAIN|VAL_PLAIN))
+        return '~';
+    return '@';
+}
+inline char _scalar_code_key(NodeType t)
+{
+    return _scalar_code(t & KEY_STYLE);
+}
+inline char _scalar_code_val(NodeType t)
+{
+    return _scalar_code(t & VAL_STYLE);
+}
+inline char _scalar_code_key(Tree const& p, id_type node)
+{
+    return _scalar_code_key(p._p(node)->m_type);
+}
+inline char _scalar_code_val(Tree const& p, id_type node)
+{
+    return _scalar_code_key(p._p(node)->m_type);
+}
+inline id_type print_node(Tree const& p, id_type node, int level, id_type count, bool print_children)
+{
+    printf("[%zu]%*s[%zu] %p", (size_t)count, (2*level), "", (size_t)node, (void const*)p.get(node));
+    if(p.is_root(node))
+    {
+        printf(" [ROOT]");
+    }
+    char typebuf[128];
+    csubstr typestr = p.type(node).type_str(typebuf);
+    RYML_CHECK(typestr.str);
+    printf(" %.*s", (int)typestr.len, typestr.str);
+    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);
+            printf(" <%.*s>", (int)kt.len, kt.str);
+        }
+        const char code = _scalar_code_key(p, node);
+        csubstr k  = p.key(node);
+        printf(" %c%.*s%c :", code, (int)k.len, k.str, code);
+    }
+    if(p.has_val_anchor(node))
+    {
+        csubstr a = p.val_anchor(node);
+        printf(" &%.*s'", (int)a.len, a.str);
+    }
+    if(p.has_val_tag(node))
+    {
+        csubstr vt = p.val_tag(node);
+        printf(" <%.*s>", (int)vt.len, vt.str);
+    }
+    if(p.has_val(node))
+    {
+        const char code = _scalar_code_val(p, node);
+        csubstr v  = p.val(node);
+        printf(" %c%.*s%c", code, (int)v.len, v.str, code);
+    }
+    printf("  (%zu sibs)", (size_t)p.num_siblings(node));
+
+    ++count;
+
+    if(!p.is_container(node))
+    {
+        printf("\n");
+    }
+    else
+    {
+        printf(" (%zu children)\n", (size_t)p.num_children(node));
+        if(print_children)
+        {
+            for(id_type i = p.first_child(node); i != NONE; i = p.next_sibling(i))
+            {
+                count = print_node(p, i, level+1, count, print_children);
+            }
+        }
+    }
+
+    return count;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline void print_node(ConstNodeRef const& p, int level=0)
+{
+    print_node(*p.tree(), p.id(), level, 0, true);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+inline id_type print_tree(const char *message, Tree const& p, id_type node=NONE)
+{
+    printf("--------------------------------------\n");
+    if(message != nullptr)
+        printf("%s:\n", message);
+    id_type ret = 0;
+    if(!p.empty())
+    {
+        if(node == NONE)
+            node = p.root_id();
+        ret = print_node(p, node, 0, 0, true);
+    }
+    printf("#nodes=%zu vs #printed=%zu\n", (size_t)p.size(), (size_t)ret);
+    printf("--------------------------------------\n");
+    return ret;
+}
+
+inline id_type print_tree(Tree const& p, id_type node=NONE)
+{
+    return print_tree(nullptr, p, node);
+}
+
+inline void print_tree(ConstNodeRef const& p, int level)
+{
+    print_node(p, level);
+    for(ConstNodeRef ch : p.children())
+    {
+        print_tree(ch, level+1);
+    }
+}
+
+C4_SUPPRESS_WARNING_GCC_CLANG_POP
+
+} /* 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/version.hpp
+//#include "c4/yml/version.hpp"
+#if !defined(C4_YML_VERSION_HPP_) && !defined(_C4_YML_VERSION_HPP_)
+#error "amalgamate: file c4/yml/version.hpp must have been included at this point"
+#endif /* C4_YML_VERSION_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/event_handler_tree.hpp
+//#include "c4/yml/event_handler_tree.hpp"
+#if !defined(C4_YML_EVENT_HANDLER_TREE_HPP_) && !defined(_C4_YML_EVENT_HANDLER_TREE_HPP_)
+#error "amalgamate: file c4/yml/event_handler_tree.hpp must have been included at this point"
+#endif /* C4_YML_EVENT_HANDLER_TREE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/parse_engine.hpp
+//#include "c4/yml/parse_engine.hpp"
+#if !defined(C4_YML_PARSE_ENGINE_HPP_) && !defined(_C4_YML_PARSE_ENGINE_HPP_)
+#error "amalgamate: file c4/yml/parse_engine.hpp must have been included at this point"
+#endif /* C4_YML_PARSE_ENGINE_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/filter_processor.hpp
+//#include "c4/yml/filter_processor.hpp"
+#if !defined(C4_YML_FILTER_PROCESSOR_HPP_) && !defined(_C4_YML_FILTER_PROCESSOR_HPP_)
+#error "amalgamate: file c4/yml/filter_processor.hpp must have been included at this point"
+#endif /* C4_YML_FILTER_PROCESSOR_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_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/reference_resolver.hpp
+//#include "c4/yml/reference_resolver.hpp"
+#if !defined(C4_YML_REFERENCE_RESOLVER_HPP_) && !defined(_C4_YML_REFERENCE_RESOLVER_HPP_)
+#error "amalgamate: file c4/yml/reference_resolver.hpp must have been included at this point"
+#endif /* C4_YML_REFERENCE_RESOLVER_HPP_ */
+
+// amalgamate: removed include of
+// https://github.com/biojppm/rapidyaml/src/c4/yml/tag.hpp
+//#include "c4/yml/tag.hpp"
+#if !defined(C4_YML_TAG_HPP_) && !defined(_C4_YML_TAG_HPP_)
+#error "amalgamate: file c4/yml/tag.hpp must have been included at this point"
+#endif /* C4_YML_TAG_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_ */
+